| |
| /* |
| * Copyright 2003 Tungsten Graphics, inc. |
| * All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * on the rights to use, copy, modify, merge, publish, distribute, sub |
| * license, and/or sell copies of the Software, and to permit persons to whom |
| * the Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL |
| * TUNGSTEN GRAPHICS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, |
| * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
| * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
| * USE OR OTHER DEALINGS IN THE SOFTWARE. |
| * |
| * Authors: |
| * Keith Whitwell <keithw@tungstengraphics.com> |
| */ |
| |
| #include "main/glheader.h" |
| #include "main/context.h" |
| #include "main/colormac.h" |
| #include "main/simple_list.h" |
| #include "swrast/s_chan.h" |
| #include "t_context.h" |
| #include "t_vertex.h" |
| |
| |
| #if 0 |
| #define DEBUG_INSERT printf("%s\n", __FUNCTION__) |
| #else |
| #define DEBUG_INSERT |
| #endif |
| |
| |
| /* |
| * These functions take the NDC coordinates pointed to by 'in', apply the |
| * NDC->Viewport mapping and store the results at 'v'. |
| */ |
| |
| static inline void insert_4f_viewport_4( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| GLfloat *out = (GLfloat *)v; |
| const GLfloat * const vp = a->vp; |
| DEBUG_INSERT; |
| out[0] = vp[0] * in[0] + vp[12]; |
| out[1] = vp[5] * in[1] + vp[13]; |
| out[2] = vp[10] * in[2] + vp[14]; |
| out[3] = in[3]; |
| } |
| |
| static inline void insert_4f_viewport_3( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| GLfloat *out = (GLfloat *)v; |
| const GLfloat * const vp = a->vp; |
| DEBUG_INSERT; |
| out[0] = vp[0] * in[0] + vp[12]; |
| out[1] = vp[5] * in[1] + vp[13]; |
| out[2] = vp[10] * in[2] + vp[14]; |
| out[3] = 1; |
| } |
| |
| static inline void insert_4f_viewport_2( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| GLfloat *out = (GLfloat *)v; |
| const GLfloat * const vp = a->vp; |
| DEBUG_INSERT; |
| out[0] = vp[0] * in[0] + vp[12]; |
| out[1] = vp[5] * in[1] + vp[13]; |
| out[2] = vp[14]; |
| out[3] = 1; |
| } |
| |
| static inline void insert_4f_viewport_1( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| GLfloat *out = (GLfloat *)v; |
| const GLfloat * const vp = a->vp; |
| DEBUG_INSERT; |
| out[0] = vp[0] * in[0] + vp[12]; |
| out[1] = vp[13]; |
| out[2] = vp[14]; |
| out[3] = 1; |
| } |
| |
| static inline void insert_3f_viewport_3( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| GLfloat *out = (GLfloat *)v; |
| const GLfloat * const vp = a->vp; |
| DEBUG_INSERT; |
| out[0] = vp[0] * in[0] + vp[12]; |
| out[1] = vp[5] * in[1] + vp[13]; |
| out[2] = vp[10] * in[2] + vp[14]; |
| } |
| |
| static inline void insert_3f_viewport_2( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| GLfloat *out = (GLfloat *)v; |
| const GLfloat * const vp = a->vp; |
| DEBUG_INSERT; |
| out[0] = vp[0] * in[0] + vp[12]; |
| out[1] = vp[5] * in[1] + vp[13]; |
| out[2] = vp[14]; |
| } |
| |
| static inline void insert_3f_viewport_1( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| GLfloat *out = (GLfloat *)v; |
| const GLfloat * const vp = a->vp; |
| DEBUG_INSERT; |
| out[0] = vp[0] * in[0] + vp[12]; |
| out[1] = vp[13]; |
| out[2] = vp[14]; |
| } |
| |
| static inline void insert_2f_viewport_2( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| GLfloat *out = (GLfloat *)v; |
| const GLfloat * const vp = a->vp; |
| DEBUG_INSERT; |
| out[0] = vp[0] * in[0] + vp[12]; |
| out[1] = vp[5] * in[1] + vp[13]; |
| } |
| |
| static inline void insert_2f_viewport_1( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| GLfloat *out = (GLfloat *)v; |
| const GLfloat * const vp = a->vp; |
| DEBUG_INSERT; |
| out[0] = vp[0] * in[0] + vp[12]; |
| out[1] = vp[13]; |
| } |
| |
| |
| /* |
| * These functions do the same as above, except for the viewport mapping. |
| */ |
| |
| static inline void insert_4f_4( const struct tnl_clipspace_attr *a, GLubyte *v, const GLfloat *in ) |
| { |
| GLfloat *out = (GLfloat *)(v); |
| (void) a; |
| DEBUG_INSERT; |
| out[0] = in[0]; |
| out[1] = in[1]; |
| out[2] = in[2]; |
| out[3] = in[3]; |
| } |
| |
| static inline void insert_4f_3( const struct tnl_clipspace_attr *a, GLubyte *v, const GLfloat *in ) |
| { |
| GLfloat *out = (GLfloat *)(v); |
| (void) a; |
| DEBUG_INSERT; |
| out[0] = in[0]; |
| out[1] = in[1]; |
| out[2] = in[2]; |
| out[3] = 1; |
| } |
| |
| static inline void insert_4f_2( const struct tnl_clipspace_attr *a, GLubyte *v, const GLfloat *in ) |
| { |
| GLfloat *out = (GLfloat *)(v); |
| (void) a; |
| DEBUG_INSERT; |
| out[0] = in[0]; |
| out[1] = in[1]; |
| out[2] = 0; |
| out[3] = 1; |
| } |
| |
| static inline void insert_4f_1( const struct tnl_clipspace_attr *a, GLubyte *v, const GLfloat *in ) |
| { |
| GLfloat *out = (GLfloat *)(v); |
| (void) a; |
| DEBUG_INSERT; |
| out[0] = in[0]; |
| out[1] = 0; |
| out[2] = 0; |
| out[3] = 1; |
| } |
| |
| static inline void insert_3f_xyw_4( const struct tnl_clipspace_attr *a, GLubyte *v, const GLfloat *in ) |
| { |
| GLfloat *out = (GLfloat *)(v); |
| (void) a; |
| DEBUG_INSERT; |
| out[0] = in[0]; |
| out[1] = in[1]; |
| out[2] = in[3]; |
| } |
| |
| static inline void insert_3f_xyw_err( const struct tnl_clipspace_attr *a, GLubyte *v, const GLfloat *in ) |
| { |
| (void) a; (void) v; (void) in; |
| DEBUG_INSERT; |
| exit(1); |
| } |
| |
| static inline void insert_3f_3( const struct tnl_clipspace_attr *a, GLubyte *v, const GLfloat *in ) |
| { |
| GLfloat *out = (GLfloat *)(v); |
| (void) a; |
| DEBUG_INSERT; |
| out[0] = in[0]; |
| out[1] = in[1]; |
| out[2] = in[2]; |
| } |
| |
| static inline void insert_3f_2( const struct tnl_clipspace_attr *a, GLubyte *v, const GLfloat *in ) |
| { |
| GLfloat *out = (GLfloat *)(v); |
| (void) a; |
| DEBUG_INSERT; |
| out[0] = in[0]; |
| out[1] = in[1]; |
| out[2] = 0; |
| } |
| |
| static inline void insert_3f_1( const struct tnl_clipspace_attr *a, GLubyte *v, const GLfloat *in ) |
| { |
| GLfloat *out = (GLfloat *)(v); |
| (void) a; |
| DEBUG_INSERT; |
| out[0] = in[0]; |
| out[1] = 0; |
| out[2] = 0; |
| } |
| |
| |
| static inline void insert_2f_2( const struct tnl_clipspace_attr *a, GLubyte *v, const GLfloat *in ) |
| { |
| GLfloat *out = (GLfloat *)(v); |
| (void) a; |
| DEBUG_INSERT; |
| out[0] = in[0]; |
| out[1] = in[1]; |
| } |
| |
| static inline void insert_2f_1( const struct tnl_clipspace_attr *a, GLubyte *v, const GLfloat *in ) |
| { |
| GLfloat *out = (GLfloat *)(v); |
| (void) a; |
| DEBUG_INSERT; |
| out[0] = in[0]; |
| out[1] = 0; |
| } |
| |
| static inline void insert_1f_1( const struct tnl_clipspace_attr *a, GLubyte *v, const GLfloat *in ) |
| { |
| GLfloat *out = (GLfloat *)(v); |
| (void) a; |
| DEBUG_INSERT; |
| out[0] = in[0]; |
| } |
| |
| static inline void insert_null( const struct tnl_clipspace_attr *a, GLubyte *v, const GLfloat *in ) |
| { |
| DEBUG_INSERT; |
| (void) a; (void) v; (void) in; |
| } |
| |
| static inline void insert_4chan_4f_rgba_4( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| GLchan *c = (GLchan *)v; |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_CHAN(c[0], in[0]); |
| UNCLAMPED_FLOAT_TO_CHAN(c[1], in[1]); |
| UNCLAMPED_FLOAT_TO_CHAN(c[2], in[2]); |
| UNCLAMPED_FLOAT_TO_CHAN(c[3], in[3]); |
| } |
| |
| static inline void insert_4chan_4f_rgba_3( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| GLchan *c = (GLchan *)v; |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_CHAN(c[0], in[0]); |
| UNCLAMPED_FLOAT_TO_CHAN(c[1], in[1]); |
| UNCLAMPED_FLOAT_TO_CHAN(c[2], in[2]); |
| c[3] = CHAN_MAX; |
| } |
| |
| static inline void insert_4chan_4f_rgba_2( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| GLchan *c = (GLchan *)v; |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_CHAN(c[0], in[0]); |
| UNCLAMPED_FLOAT_TO_CHAN(c[1], in[1]); |
| c[2] = 0; |
| c[3] = CHAN_MAX; |
| } |
| |
| static inline void insert_4chan_4f_rgba_1( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| GLchan *c = (GLchan *)v; |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_CHAN(c[0], in[0]); |
| c[1] = 0; |
| c[2] = 0; |
| c[3] = CHAN_MAX; |
| } |
| |
| static inline void insert_4ub_4f_rgba_4( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[0]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[1]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[2]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[3], in[3]); |
| } |
| |
| static inline void insert_4ub_4f_rgba_3( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[0]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[1]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[2]); |
| v[3] = 0xff; |
| } |
| |
| static inline void insert_4ub_4f_rgba_2( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[0]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[1]); |
| v[2] = 0; |
| v[3] = 0xff; |
| } |
| |
| static inline void insert_4ub_4f_rgba_1( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[0]); |
| v[1] = 0; |
| v[2] = 0; |
| v[3] = 0xff; |
| } |
| |
| static inline void insert_4ub_4f_bgra_4( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[0]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[1]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[2]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[3], in[3]); |
| } |
| |
| static inline void insert_4ub_4f_bgra_3( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[0]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[1]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[2]); |
| v[3] = 0xff; |
| } |
| |
| static inline void insert_4ub_4f_bgra_2( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[0]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[1]); |
| v[0] = 0; |
| v[3] = 0xff; |
| } |
| |
| static inline void insert_4ub_4f_bgra_1( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[0]); |
| v[1] = 0; |
| v[0] = 0; |
| v[3] = 0xff; |
| } |
| |
| static inline void insert_4ub_4f_argb_4( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[0]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[1]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[3], in[2]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[3]); |
| } |
| |
| static inline void insert_4ub_4f_argb_3( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[0]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[1]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[3], in[2]); |
| v[0] = 0xff; |
| } |
| |
| static inline void insert_4ub_4f_argb_2( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[0]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[1]); |
| v[3] = 0x00; |
| v[0] = 0xff; |
| } |
| |
| static inline void insert_4ub_4f_argb_1( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[0]); |
| v[2] = 0x00; |
| v[3] = 0x00; |
| v[0] = 0xff; |
| } |
| |
| static inline void insert_4ub_4f_abgr_4( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_UBYTE(v[3], in[0]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[1]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[2]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[3]); |
| } |
| |
| static inline void insert_4ub_4f_abgr_3( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_UBYTE(v[3], in[0]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[1]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[2]); |
| v[0] = 0xff; |
| } |
| |
| static inline void insert_4ub_4f_abgr_2( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_UBYTE(v[3], in[0]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[1]); |
| v[1] = 0x00; |
| v[0] = 0xff; |
| } |
| |
| static inline void insert_4ub_4f_abgr_1( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_UBYTE(v[3], in[0]); |
| v[2] = 0x00; |
| v[1] = 0x00; |
| v[0] = 0xff; |
| } |
| |
| static inline void insert_3ub_3f_rgb_3( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[0]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[1]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[2]); |
| } |
| |
| static inline void insert_3ub_3f_rgb_2( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[0]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[1]); |
| v[2] = 0; |
| } |
| |
| static inline void insert_3ub_3f_rgb_1( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[0]); |
| v[1] = 0; |
| v[2] = 0; |
| } |
| |
| static inline void insert_3ub_3f_bgr_3( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[0]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[1]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[2]); |
| } |
| |
| static inline void insert_3ub_3f_bgr_2( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[0]); |
| UNCLAMPED_FLOAT_TO_UBYTE(v[1], in[1]); |
| v[0] = 0; |
| } |
| |
| static inline void insert_3ub_3f_bgr_1( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_UBYTE(v[2], in[0]); |
| v[1] = 0; |
| v[0] = 0; |
| } |
| |
| |
| static inline void insert_1ub_1f_1( const struct tnl_clipspace_attr *a, GLubyte *v, |
| const GLfloat *in ) |
| { |
| DEBUG_INSERT; |
| (void) a; |
| UNCLAMPED_FLOAT_TO_UBYTE(v[0], in[0]); |
| } |
| |
| |
| /*********************************************************************** |
| * Functions to perform the reverse operations to the above, for |
| * swrast translation and clip-interpolation. |
| * |
| * Currently always extracts a full 4 floats. |
| */ |
| |
| static void extract_4f_viewport( const struct tnl_clipspace_attr *a, GLfloat *out, |
| const GLubyte *v ) |
| { |
| const GLfloat *in = (const GLfloat *)v; |
| const GLfloat * const vp = a->vp; |
| |
| /* Although included for completeness, the position coordinate is |
| * usually handled differently during clipping. |
| */ |
| DEBUG_INSERT; |
| out[0] = (in[0] - vp[12]) / vp[0]; |
| out[1] = (in[1] - vp[13]) / vp[5]; |
| out[2] = (in[2] - vp[14]) / vp[10]; |
| out[3] = in[3]; |
| } |
| |
| static void extract_3f_viewport( const struct tnl_clipspace_attr *a, GLfloat *out, |
| const GLubyte *v ) |
| { |
| const GLfloat *in = (const GLfloat *)v; |
| const GLfloat * const vp = a->vp; |
| DEBUG_INSERT; |
| out[0] = (in[0] - vp[12]) / vp[0]; |
| out[1] = (in[1] - vp[13]) / vp[5]; |
| out[2] = (in[2] - vp[14]) / vp[10]; |
| out[3] = 1; |
| } |
| |
| |
| static void extract_2f_viewport( const struct tnl_clipspace_attr *a, GLfloat *out, |
| const GLubyte *v ) |
| { |
| const GLfloat *in = (const GLfloat *)v; |
| const GLfloat * const vp = a->vp; |
| DEBUG_INSERT; |
| out[0] = (in[0] - vp[12]) / vp[0]; |
| out[1] = (in[1] - vp[13]) / vp[5]; |
| out[2] = 0; |
| out[3] = 1; |
| } |
| |
| |
| static void extract_4f( const struct tnl_clipspace_attr *a, GLfloat *out, const GLubyte *v ) |
| { |
| const GLfloat *in = (const GLfloat *)v; |
| (void) a; |
| |
| out[0] = in[0]; |
| out[1] = in[1]; |
| out[2] = in[2]; |
| out[3] = in[3]; |
| } |
| |
| static void extract_3f_xyw( const struct tnl_clipspace_attr *a, GLfloat *out, const GLubyte *v ) |
| { |
| const GLfloat *in = (const GLfloat *)v; |
| (void) a; |
| |
| out[0] = in[0]; |
| out[1] = in[1]; |
| out[2] = 0; |
| out[3] = in[2]; |
| } |
| |
| |
| static void extract_3f( const struct tnl_clipspace_attr *a, GLfloat *out, const GLubyte *v ) |
| { |
| const GLfloat *in = (const GLfloat *)v; |
| (void) a; |
| |
| out[0] = in[0]; |
| out[1] = in[1]; |
| out[2] = in[2]; |
| out[3] = 1; |
| } |
| |
| |
| static void extract_2f( const struct tnl_clipspace_attr *a, GLfloat *out, const GLubyte *v ) |
| { |
| const GLfloat *in = (const GLfloat *)v; |
| (void) a; |
| |
| out[0] = in[0]; |
| out[1] = in[1]; |
| out[2] = 0; |
| out[3] = 1; |
| } |
| |
| static void extract_1f( const struct tnl_clipspace_attr *a, GLfloat *out, const GLubyte *v ) |
| { |
| const GLfloat *in = (const GLfloat *)v; |
| (void) a; |
| |
| out[0] = in[0]; |
| out[1] = 0; |
| out[2] = 0; |
| out[3] = 1; |
| } |
| |
| static void extract_4chan_4f_rgba( const struct tnl_clipspace_attr *a, GLfloat *out, |
| const GLubyte *v ) |
| { |
| GLchan *c = (GLchan *)v; |
| (void) a; |
| |
| out[0] = CHAN_TO_FLOAT(c[0]); |
| out[1] = CHAN_TO_FLOAT(c[1]); |
| out[2] = CHAN_TO_FLOAT(c[2]); |
| out[3] = CHAN_TO_FLOAT(c[3]); |
| } |
| |
| static void extract_4ub_4f_rgba( const struct tnl_clipspace_attr *a, GLfloat *out, |
| const GLubyte *v ) |
| { |
| (void) a; |
| out[0] = UBYTE_TO_FLOAT(v[0]); |
| out[1] = UBYTE_TO_FLOAT(v[1]); |
| out[2] = UBYTE_TO_FLOAT(v[2]); |
| out[3] = UBYTE_TO_FLOAT(v[3]); |
| } |
| |
| static void extract_4ub_4f_bgra( const struct tnl_clipspace_attr *a, GLfloat *out, |
| const GLubyte *v ) |
| { |
| (void) a; |
| out[2] = UBYTE_TO_FLOAT(v[0]); |
| out[1] = UBYTE_TO_FLOAT(v[1]); |
| out[0] = UBYTE_TO_FLOAT(v[2]); |
| out[3] = UBYTE_TO_FLOAT(v[3]); |
| } |
| |
| static void extract_4ub_4f_argb( const struct tnl_clipspace_attr *a, GLfloat *out, |
| const GLubyte *v ) |
| { |
| (void) a; |
| out[3] = UBYTE_TO_FLOAT(v[0]); |
| out[0] = UBYTE_TO_FLOAT(v[1]); |
| out[1] = UBYTE_TO_FLOAT(v[2]); |
| out[2] = UBYTE_TO_FLOAT(v[3]); |
| } |
| |
| static void extract_4ub_4f_abgr( const struct tnl_clipspace_attr *a, GLfloat *out, |
| const GLubyte *v ) |
| { |
| (void) a; |
| out[3] = UBYTE_TO_FLOAT(v[0]); |
| out[2] = UBYTE_TO_FLOAT(v[1]); |
| out[1] = UBYTE_TO_FLOAT(v[2]); |
| out[0] = UBYTE_TO_FLOAT(v[3]); |
| } |
| |
| static void extract_3ub_3f_rgb( const struct tnl_clipspace_attr *a, GLfloat *out, |
| const GLubyte *v ) |
| { |
| (void) a; |
| out[0] = UBYTE_TO_FLOAT(v[0]); |
| out[1] = UBYTE_TO_FLOAT(v[1]); |
| out[2] = UBYTE_TO_FLOAT(v[2]); |
| out[3] = 1; |
| } |
| |
| static void extract_3ub_3f_bgr( const struct tnl_clipspace_attr *a, GLfloat *out, |
| const GLubyte *v ) |
| { |
| (void) a; |
| out[2] = UBYTE_TO_FLOAT(v[0]); |
| out[1] = UBYTE_TO_FLOAT(v[1]); |
| out[0] = UBYTE_TO_FLOAT(v[2]); |
| out[3] = 1; |
| } |
| |
| static void extract_1ub_1f( const struct tnl_clipspace_attr *a, GLfloat *out, const GLubyte *v ) |
| { |
| (void) a; |
| out[0] = UBYTE_TO_FLOAT(v[0]); |
| out[1] = 0; |
| out[2] = 0; |
| out[3] = 1; |
| } |
| |
| |
| const struct tnl_format_info _tnl_format_info[EMIT_MAX] = |
| { |
| { "1f", |
| extract_1f, |
| { insert_1f_1, insert_1f_1, insert_1f_1, insert_1f_1 }, |
| sizeof(GLfloat) }, |
| |
| { "2f", |
| extract_2f, |
| { insert_2f_1, insert_2f_2, insert_2f_2, insert_2f_2 }, |
| 2 * sizeof(GLfloat) }, |
| |
| { "3f", |
| extract_3f, |
| { insert_3f_1, insert_3f_2, insert_3f_3, insert_3f_3 }, |
| 3 * sizeof(GLfloat) }, |
| |
| { "4f", |
| extract_4f, |
| { insert_4f_1, insert_4f_2, insert_4f_3, insert_4f_4 }, |
| 4 * sizeof(GLfloat) }, |
| |
| { "2f_viewport", |
| extract_2f_viewport, |
| { insert_2f_viewport_1, insert_2f_viewport_2, insert_2f_viewport_2, |
| insert_2f_viewport_2 }, |
| 2 * sizeof(GLfloat) }, |
| |
| { "3f_viewport", |
| extract_3f_viewport, |
| { insert_3f_viewport_1, insert_3f_viewport_2, insert_3f_viewport_3, |
| insert_3f_viewport_3 }, |
| 3 * sizeof(GLfloat) }, |
| |
| { "4f_viewport", |
| extract_4f_viewport, |
| { insert_4f_viewport_1, insert_4f_viewport_2, insert_4f_viewport_3, |
| insert_4f_viewport_4 }, |
| 4 * sizeof(GLfloat) }, |
| |
| { "3f_xyw", |
| extract_3f_xyw, |
| { insert_3f_xyw_err, insert_3f_xyw_err, insert_3f_xyw_err, |
| insert_3f_xyw_4 }, |
| 3 * sizeof(GLfloat) }, |
| |
| { "1ub_1f", |
| extract_1ub_1f, |
| { insert_1ub_1f_1, insert_1ub_1f_1, insert_1ub_1f_1, insert_1ub_1f_1 }, |
| sizeof(GLubyte) }, |
| |
| { "3ub_3f_rgb", |
| extract_3ub_3f_rgb, |
| { insert_3ub_3f_rgb_1, insert_3ub_3f_rgb_2, insert_3ub_3f_rgb_3, |
| insert_3ub_3f_rgb_3 }, |
| 3 * sizeof(GLubyte) }, |
| |
| { "3ub_3f_bgr", |
| extract_3ub_3f_bgr, |
| { insert_3ub_3f_bgr_1, insert_3ub_3f_bgr_2, insert_3ub_3f_bgr_3, |
| insert_3ub_3f_bgr_3 }, |
| 3 * sizeof(GLubyte) }, |
| |
| { "4ub_4f_rgba", |
| extract_4ub_4f_rgba, |
| { insert_4ub_4f_rgba_1, insert_4ub_4f_rgba_2, insert_4ub_4f_rgba_3, |
| insert_4ub_4f_rgba_4 }, |
| 4 * sizeof(GLubyte) }, |
| |
| { "4ub_4f_bgra", |
| extract_4ub_4f_bgra, |
| { insert_4ub_4f_bgra_1, insert_4ub_4f_bgra_2, insert_4ub_4f_bgra_3, |
| insert_4ub_4f_bgra_4 }, |
| 4 * sizeof(GLubyte) }, |
| |
| { "4ub_4f_argb", |
| extract_4ub_4f_argb, |
| { insert_4ub_4f_argb_1, insert_4ub_4f_argb_2, insert_4ub_4f_argb_3, |
| insert_4ub_4f_argb_4 }, |
| 4 * sizeof(GLubyte) }, |
| |
| { "4ub_4f_abgr", |
| extract_4ub_4f_abgr, |
| { insert_4ub_4f_abgr_1, insert_4ub_4f_abgr_2, insert_4ub_4f_abgr_3, |
| insert_4ub_4f_abgr_4 }, |
| 4 * sizeof(GLubyte) }, |
| |
| { "4chan_4f_rgba", |
| extract_4chan_4f_rgba, |
| { insert_4chan_4f_rgba_1, insert_4chan_4f_rgba_2, insert_4chan_4f_rgba_3, |
| insert_4chan_4f_rgba_4 }, |
| 4 * sizeof(GLchan) }, |
| |
| { "pad", |
| NULL, |
| { NULL, NULL, NULL, NULL }, |
| 0 } |
| |
| }; |
| |
| |
| |
| |
| /*********************************************************************** |
| * Hardwired fastpaths for emitting whole vertices or groups of |
| * vertices |
| */ |
| #define EMIT5(NR, F0, F1, F2, F3, F4, NAME) \ |
| static void NAME( struct gl_context *ctx, \ |
| GLuint count, \ |
| GLubyte *v ) \ |
| { \ |
| struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); \ |
| struct tnl_clipspace_attr *a = vtx->attr; \ |
| GLuint i; \ |
| \ |
| for (i = 0 ; i < count ; i++, v += vtx->vertex_size) { \ |
| if (NR > 0) { \ |
| F0( &a[0], v + a[0].vertoffset, (GLfloat *)a[0].inputptr ); \ |
| a[0].inputptr += a[0].inputstride; \ |
| } \ |
| \ |
| if (NR > 1) { \ |
| F1( &a[1], v + a[1].vertoffset, (GLfloat *)a[1].inputptr ); \ |
| a[1].inputptr += a[1].inputstride; \ |
| } \ |
| \ |
| if (NR > 2) { \ |
| F2( &a[2], v + a[2].vertoffset, (GLfloat *)a[2].inputptr ); \ |
| a[2].inputptr += a[2].inputstride; \ |
| } \ |
| \ |
| if (NR > 3) { \ |
| F3( &a[3], v + a[3].vertoffset, (GLfloat *)a[3].inputptr ); \ |
| a[3].inputptr += a[3].inputstride; \ |
| } \ |
| \ |
| if (NR > 4) { \ |
| F4( &a[4], v + a[4].vertoffset, (GLfloat *)a[4].inputptr ); \ |
| a[4].inputptr += a[4].inputstride; \ |
| } \ |
| } \ |
| } |
| |
| |
| #define EMIT2(F0, F1, NAME) EMIT5(2, F0, F1, insert_null, \ |
| insert_null, insert_null, NAME) |
| |
| #define EMIT3(F0, F1, F2, NAME) EMIT5(3, F0, F1, F2, insert_null, \ |
| insert_null, NAME) |
| |
| #define EMIT4(F0, F1, F2, F3, NAME) EMIT5(4, F0, F1, F2, F3, \ |
| insert_null, NAME) |
| |
| |
| EMIT2(insert_3f_viewport_3, insert_4ub_4f_rgba_4, emit_viewport3_rgba4) |
| EMIT2(insert_3f_viewport_3, insert_4ub_4f_bgra_4, emit_viewport3_bgra4) |
| EMIT2(insert_3f_3, insert_4ub_4f_rgba_4, emit_xyz3_rgba4) |
| |
| EMIT3(insert_4f_viewport_4, insert_4ub_4f_rgba_4, insert_2f_2, emit_viewport4_rgba4_st2) |
| EMIT3(insert_4f_viewport_4, insert_4ub_4f_bgra_4, insert_2f_2, emit_viewport4_bgra4_st2) |
| EMIT3(insert_4f_4, insert_4ub_4f_rgba_4, insert_2f_2, emit_xyzw4_rgba4_st2) |
| |
| EMIT4(insert_4f_viewport_4, insert_4ub_4f_rgba_4, insert_2f_2, insert_2f_2, emit_viewport4_rgba4_st2_st2) |
| EMIT4(insert_4f_viewport_4, insert_4ub_4f_bgra_4, insert_2f_2, insert_2f_2, emit_viewport4_bgra4_st2_st2) |
| EMIT4(insert_4f_4, insert_4ub_4f_rgba_4, insert_2f_2, insert_2f_2, emit_xyzw4_rgba4_st2_st2) |
| |
| |
| /* Use the codegen paths to select one of a number of hardwired |
| * fastpaths. |
| */ |
| void _tnl_generate_hardwired_emit( struct gl_context *ctx ) |
| { |
| struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); |
| tnl_emit_func func = NULL; |
| |
| /* Does it fit a hardwired fastpath? Help! this is growing out of |
| * control! |
| */ |
| switch (vtx->attr_count) { |
| case 2: |
| if (vtx->attr[0].emit == insert_3f_viewport_3) { |
| if (vtx->attr[1].emit == insert_4ub_4f_bgra_4) |
| func = emit_viewport3_bgra4; |
| else if (vtx->attr[1].emit == insert_4ub_4f_rgba_4) |
| func = emit_viewport3_rgba4; |
| } |
| else if (vtx->attr[0].emit == insert_3f_3 && |
| vtx->attr[1].emit == insert_4ub_4f_rgba_4) { |
| func = emit_xyz3_rgba4; |
| } |
| break; |
| case 3: |
| if (vtx->attr[2].emit == insert_2f_2) { |
| if (vtx->attr[1].emit == insert_4ub_4f_rgba_4) { |
| if (vtx->attr[0].emit == insert_4f_viewport_4) |
| func = emit_viewport4_rgba4_st2; |
| else if (vtx->attr[0].emit == insert_4f_4) |
| func = emit_xyzw4_rgba4_st2; |
| } |
| else if (vtx->attr[1].emit == insert_4ub_4f_bgra_4 && |
| vtx->attr[0].emit == insert_4f_viewport_4) |
| func = emit_viewport4_bgra4_st2; |
| } |
| break; |
| case 4: |
| if (vtx->attr[2].emit == insert_2f_2 && |
| vtx->attr[3].emit == insert_2f_2) { |
| if (vtx->attr[1].emit == insert_4ub_4f_rgba_4) { |
| if (vtx->attr[0].emit == insert_4f_viewport_4) |
| func = emit_viewport4_rgba4_st2_st2; |
| else if (vtx->attr[0].emit == insert_4f_4) |
| func = emit_xyzw4_rgba4_st2_st2; |
| } |
| else if (vtx->attr[1].emit == insert_4ub_4f_bgra_4 && |
| vtx->attr[0].emit == insert_4f_viewport_4) |
| func = emit_viewport4_bgra4_st2_st2; |
| } |
| break; |
| } |
| |
| vtx->emit = func; |
| } |
| |
| /*********************************************************************** |
| * Generic (non-codegen) functions for whole vertices or groups of |
| * vertices |
| */ |
| |
| void _tnl_generic_emit( struct gl_context *ctx, |
| GLuint count, |
| GLubyte *v ) |
| { |
| struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); |
| struct tnl_clipspace_attr *a = vtx->attr; |
| const GLuint attr_count = vtx->attr_count; |
| const GLuint stride = vtx->vertex_size; |
| GLuint i, j; |
| |
| for (i = 0 ; i < count ; i++, v += stride) { |
| for (j = 0; j < attr_count; j++) { |
| GLfloat *in = (GLfloat *)a[j].inputptr; |
| a[j].inputptr += a[j].inputstride; |
| a[j].emit( &a[j], v + a[j].vertoffset, in ); |
| } |
| } |
| } |
| |
| |
| void _tnl_generic_interp( struct gl_context *ctx, |
| GLfloat t, |
| GLuint edst, GLuint eout, GLuint ein, |
| GLboolean force_boundary ) |
| { |
| TNLcontext *tnl = TNL_CONTEXT(ctx); |
| struct vertex_buffer *VB = &tnl->vb; |
| struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); |
| const GLubyte *vin = vtx->vertex_buf + ein * vtx->vertex_size; |
| const GLubyte *vout = vtx->vertex_buf + eout * vtx->vertex_size; |
| GLubyte *vdst = vtx->vertex_buf + edst * vtx->vertex_size; |
| const struct tnl_clipspace_attr *a = vtx->attr; |
| const GLuint attr_count = vtx->attr_count; |
| GLuint j; |
| (void) force_boundary; |
| |
| if (tnl->NeedNdcCoords) { |
| const GLfloat *dstclip = VB->ClipPtr->data[edst]; |
| if (dstclip[3] != 0.0) { |
| const GLfloat w = 1.0f / dstclip[3]; |
| GLfloat pos[4]; |
| |
| pos[0] = dstclip[0] * w; |
| pos[1] = dstclip[1] * w; |
| pos[2] = dstclip[2] * w; |
| pos[3] = w; |
| |
| a[0].insert[4-1]( &a[0], vdst, pos ); |
| } |
| } |
| else { |
| a[0].insert[4-1]( &a[0], vdst, VB->ClipPtr->data[edst] ); |
| } |
| |
| |
| for (j = 1; j < attr_count; j++) { |
| GLfloat fin[4], fout[4], fdst[4]; |
| |
| a[j].extract( &a[j], fin, vin + a[j].vertoffset ); |
| a[j].extract( &a[j], fout, vout + a[j].vertoffset ); |
| |
| INTERP_4F(t, fdst, fout, fin); |
| |
| a[j].insert[4-1]( &a[j], vdst + a[j].vertoffset, fdst ); |
| } |
| } |
| |
| |
| /* Extract color attributes from one vertex and insert them into |
| * another. (Shortcircuit extract/insert with memcpy). |
| */ |
| void _tnl_generic_copy_pv( struct gl_context *ctx, GLuint edst, GLuint esrc ) |
| { |
| struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx); |
| GLubyte *vsrc = vtx->vertex_buf + esrc * vtx->vertex_size; |
| GLubyte *vdst = vtx->vertex_buf + edst * vtx->vertex_size; |
| const struct tnl_clipspace_attr *a = vtx->attr; |
| const GLuint attr_count = vtx->attr_count; |
| GLuint j; |
| |
| for (j = 0; j < attr_count; j++) { |
| if (a[j].attrib == VERT_ATTRIB_COLOR0 || |
| a[j].attrib == VERT_ATTRIB_COLOR1) { |
| |
| memcpy( vdst + a[j].vertoffset, |
| vsrc + a[j].vertoffset, |
| a[j].vertattrsize ); |
| } |
| } |
| } |
| |
| |
| /* Helper functions for hardware which doesn't put back colors and/or |
| * edgeflags into vertices. |
| */ |
| void _tnl_generic_interp_extras( struct gl_context *ctx, |
| GLfloat t, |
| GLuint dst, GLuint out, GLuint in, |
| GLboolean force_boundary ) |
| { |
| struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; |
| |
| /* If stride is zero, BackfaceColorPtr is constant across the VB, so |
| * there is no point interpolating between two values as they will |
| * be identical. In all other cases, this value is generated by |
| * t_vb_lighttmp.h and has a stride of 4 dwords. |
| */ |
| if (VB->BackfaceColorPtr && VB->BackfaceColorPtr->stride) { |
| assert(VB->BackfaceColorPtr->stride == 4 * sizeof(GLfloat)); |
| |
| INTERP_4F( t, |
| VB->BackfaceColorPtr->data[dst], |
| VB->BackfaceColorPtr->data[out], |
| VB->BackfaceColorPtr->data[in] ); |
| } |
| |
| if (VB->BackfaceSecondaryColorPtr) { |
| assert(VB->BackfaceSecondaryColorPtr->stride == 4 * sizeof(GLfloat)); |
| |
| INTERP_3F( t, |
| VB->BackfaceSecondaryColorPtr->data[dst], |
| VB->BackfaceSecondaryColorPtr->data[out], |
| VB->BackfaceSecondaryColorPtr->data[in] ); |
| } |
| |
| if (VB->BackfaceIndexPtr) { |
| VB->BackfaceIndexPtr->data[dst][0] = LINTERP( t, |
| VB->BackfaceIndexPtr->data[out][0], |
| VB->BackfaceIndexPtr->data[in][0] ); |
| } |
| |
| if (VB->EdgeFlag) { |
| VB->EdgeFlag[dst] = VB->EdgeFlag[out] || force_boundary; |
| } |
| |
| _tnl_generic_interp(ctx, t, dst, out, in, force_boundary); |
| } |
| |
| void _tnl_generic_copy_pv_extras( struct gl_context *ctx, |
| GLuint dst, GLuint src ) |
| { |
| struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb; |
| |
| /* See above comment: |
| */ |
| if (VB->BackfaceColorPtr && VB->BackfaceColorPtr->stride) { |
| COPY_4FV( VB->BackfaceColorPtr->data[dst], |
| VB->BackfaceColorPtr->data[src] ); |
| } |
| |
| if (VB->BackfaceSecondaryColorPtr) { |
| COPY_4FV( VB->BackfaceSecondaryColorPtr->data[dst], |
| VB->BackfaceSecondaryColorPtr->data[src] ); |
| } |
| |
| if (VB->BackfaceIndexPtr) { |
| VB->BackfaceIndexPtr->data[dst][0] = VB->BackfaceIndexPtr->data[src][0]; |
| } |
| |
| _tnl_generic_copy_pv(ctx, dst, src); |
| } |
| |
| |