src/mesa/drivers/dri/ffb/ffb_tritmp.h

   1
   2 static void TAG(ffb_triangle)( GLcontext *ctx,
   3                                ffb_vertex *v0,
   4                                ffb_vertex *v1,
   5                                ffb_vertex *v2 )
   6 {
   7         ffbContextPtr fmesa = FFB_CONTEXT(ctx);
   8         ffb_fbcPtr ffb = fmesa->regs;
   9 #if (IND & FFB_TRI_FLAT_BIT)
  10         GLuint const_fg;
  11 #endif
  12         FFB_DELAYED_VIEWPORT_VARS;
  13
  14 #ifdef TRI_DEBUG
  15         fprintf(stderr, "FFB: ffb_triangle ["
  16 #if (IND & FFB_TRI_CULL_BIT)
  17                 " CULL"
  18 #endif
  19 #if (IND & FFB_TRI_FLAT_BIT)
  20                 " FLAT"
  21 #endif
  22 #if (IND & FFB_TRI_ALPHA_BIT)
  23                 " ALPHA"
  24 #endif
  25                 " ]\n");
  26 #endif
  27
  28 #if (IND & FFB_TRI_CULL_BIT)
  29         {       /* NOTE: These are not viewport transformed yet. */
  30                 GLfloat ex = v1->x - v0->x;
  31                 GLfloat ey = v1->y - v0->y;
  32                 GLfloat fx = v2->x - v0->x;
  33                 GLfloat fy = v2->y - v0->y;
  34                 GLfloat c = ex*fy-ey*fx;
  35
  36                 /* Culled... */
  37                 if (c * fmesa->backface_sign > fmesa->ffb_zero)
  38                         return;
  39         }
  40 #endif
  41
  42 #if (IND & FFB_TRI_FLAT_BIT)
  43         const_fg = FFB_PACK_CONST_UBYTE_ARGB_COLOR( v2->color[0] );
  44 #ifdef TRI_DEBUG
  45         fprintf(stderr, "FFB_tri: const_fg %08x (B[%f] G[%f] R[%f])\n",
  46                 const_fg,
  47                 FFB_2_30_FIXED_TO_FLOAT(v2->color[0].blue),
  48                 FFB_2_30_FIXED_TO_FLOAT(v2->color[0].green),
  49                 FFB_2_30_FIXED_TO_FLOAT(v2->color[0].red));
  50 #endif
  51 #endif
  52
  53
  54 #if (IND & FFB_TRI_FLAT_BIT)
  55         FFBFifo(fmesa, 1);
  56         ffb->fg = const_fg;
  57 #endif
  58
  59 #if (IND & FFB_TRI_FLAT_BIT)
  60         FFBFifo(fmesa, 9);
  61 #else
  62 #if (IND & FFB_TRI_ALPHA_BIT)
  63         FFBFifo(fmesa, 21);
  64 #else
  65         FFBFifo(fmesa, 18);
  66 #endif
  67 #endif
  68
  69         FFB_DUMP_VERTEX(v0);
  70 #if !(IND & FFB_TRI_FLAT_BIT)
  71 #if (IND & FFB_TRI_ALPHA_BIT)
  72         ffb->alpha = FFB_GET_ALPHA(v0);
  73 #endif
  74         ffb->red   = FFB_GET_RED(v0);
  75         ffb->green = FFB_GET_GREEN(v0);
  76         ffb->blue  = FFB_GET_BLUE(v0);
  77 #endif
  78         ffb->z     = FFB_GET_Z(v0);
  79         ffb->ryf   = FFB_GET_Y(v0);
  80         ffb->rxf   = FFB_GET_X(v0);
  81
  82         FFB_DUMP_VERTEX(v1);
  83 #if !(IND & FFB_TRI_FLAT_BIT)
  84 #if (IND & FFB_TRI_ALPHA_BIT)
  85         ffb->alpha = FFB_GET_ALPHA(v1);
  86 #endif
  87         ffb->red   = FFB_GET_RED(v1);
  88         ffb->green = FFB_GET_GREEN(v1);
  89         ffb->blue  = FFB_GET_BLUE(v1);
  90 #endif
  91         ffb->z     = FFB_GET_Z(v1);
  92         ffb->y     = FFB_GET_Y(v1);
  93         ffb->x     = FFB_GET_X(v1);
  94
  95         FFB_DUMP_VERTEX(v2);
  96 #if !(IND & FFB_TRI_FLAT_BIT)
  97 #if (IND & FFB_TRI_ALPHA_BIT)
  98         ffb->alpha = FFB_GET_ALPHA(v2);
  99 #endif
 100         ffb->red   = FFB_GET_RED(v2);
 101         ffb->green = FFB_GET_GREEN(v2);
 102         ffb->blue  = FFB_GET_BLUE(v2);
 103 #endif
 104         ffb->z     = FFB_GET_Z(v2);
 105         ffb->y     = FFB_GET_Y(v2);
 106         ffb->x     = FFB_GET_X(v2);
 107
 108         fmesa->ffbScreen->rp_active = 1;
 109 }
 110
 111
 112 static void TAG(ffb_quad)(GLcontext *ctx,
 113                           ffb_vertex *v0,
 114                           ffb_vertex *v1,
 115                           ffb_vertex *v2,
 116                           ffb_vertex *v3 )
 117 {
 118         ffbContextPtr fmesa = FFB_CONTEXT(ctx);
 119         ffb_fbcPtr ffb = fmesa->regs;
 120 #if (IND & FFB_TRI_FLAT_BIT)
 121         GLuint const_fg;
 122 #endif
 123         FFB_DELAYED_VIEWPORT_VARS;
 124
 125 #ifdef TRI_DEBUG
 126         fprintf(stderr, "FFB: ffb_quad ["
 127 #if (IND & FFB_TRI_CULL_BIT)
 128                 " CULL"
 129 #endif
 130 #if (IND & FFB_TRI_FLAT_BIT)
 131                 " FLAT"
 132 #endif
 133 #if (IND & FFB_TRI_ALPHA_BIT)
 134                 " ALPHA"
 135 #endif
 136                 " ]\n");
 137 #endif /* TRI_DEBUG */
 138
 139 #if (IND & FFB_TRI_CULL_BIT)
 140         {       /* NOTE: These are not viewport transformed yet. */
 141                 GLfloat ex = v2->x - v0->x;
 142                 GLfloat ey = v2->y - v0->y;
 143                 GLfloat fx = v3->x - v1->x;
 144                 GLfloat fy = v3->y - v1->y;
 145                 GLfloat c = ex*fy-ey*fx;
 146
 147                 /* Culled... */
 148                 if (c * fmesa->backface_sign > fmesa->ffb_zero)
 149                         return;
 150         }
 151 #endif
 152
 153 #if (IND & FFB_TRI_FLAT_BIT)
 154         const_fg = FFB_PACK_CONST_UBYTE_ARGB_COLOR( v3->color[0] );
 155 #ifdef TRI_DEBUG
 156         fprintf(stderr, "FFB_quad: const_fg %08x (B[%f] G[%f] R[%f])\n",
 157                 const_fg,
 158                 FFB_2_30_FIXED_TO_FLOAT(v3->color[0].blue),
 159                 FFB_2_30_FIXED_TO_FLOAT(v3->color[0].green),
 160                 FFB_2_30_FIXED_TO_FLOAT(v3->color[0].red));
 161 #endif
 162 #endif
 163
 164
 165 #if (IND & FFB_TRI_FLAT_BIT)
 166         FFBFifo(fmesa, 13);
 167         ffb->fg = const_fg;
 168 #else
 169 #if (IND & FFB_TRI_ALPHA_BIT)
 170         FFBFifo(fmesa, 28);
 171 #else
 172         FFBFifo(fmesa, 24);
 173 #endif
 174 #endif
 175
 176         FFB_DUMP_VERTEX(v0);
 177 #if !(IND & FFB_TRI_FLAT_BIT)
 178 #if (IND & FFB_TRI_ALPHA_BIT)
 179         ffb->alpha = FFB_GET_ALPHA(v0);
 180 #endif
 181         ffb->red   = FFB_GET_RED(v0);
 182         ffb->green = FFB_GET_GREEN(v0);
 183         ffb->blue  = FFB_GET_BLUE(v0);
 184 #endif
 185         ffb->z     = FFB_GET_Z(v0);
 186         ffb->ryf   = FFB_GET_Y(v0);
 187         ffb->rxf   = FFB_GET_X(v0);
 188
 189         FFB_DUMP_VERTEX(v1);
 190 #if !(IND & FFB_TRI_FLAT_BIT)
 191 #if (IND & FFB_TRI_ALPHA_BIT)
 192         ffb->alpha = FFB_GET_ALPHA(v1);
 193 #endif
 194         ffb->red   = FFB_GET_RED(v1);
 195         ffb->green = FFB_GET_GREEN(v1);
 196         ffb->blue  = FFB_GET_BLUE(v1);
 197 #endif
 198         ffb->z     = FFB_GET_Z(v1);
 199         ffb->y     = FFB_GET_Y(v1);
 200         ffb->x     = FFB_GET_X(v1);
 201
 202         FFB_DUMP_VERTEX(v2);
 203 #if !(IND & FFB_TRI_FLAT_BIT)
 204 #if (IND & FFB_TRI_ALPHA_BIT)
 205         ffb->alpha = FFB_GET_ALPHA(v2);
 206 #endif
 207         ffb->red   = FFB_GET_RED(v2);
 208         ffb->green = FFB_GET_GREEN(v2);
 209         ffb->blue  = FFB_GET_BLUE(v2);
 210 #endif
 211         ffb->z     = FFB_GET_Z(v2);
 212         ffb->y     = FFB_GET_Y(v2);
 213         ffb->x     = FFB_GET_X(v2);
 214
 215         FFB_DUMP_VERTEX(v3);
 216 #if !(IND & FFB_TRI_FLAT_BIT)
 217 #if (IND & FFB_TRI_ALPHA_BIT)
 218         ffb->alpha = FFB_GET_ALPHA(v3);
 219 #endif
 220         ffb->red   = FFB_GET_RED(v3);
 221         ffb->green = FFB_GET_GREEN(v3);
 222         ffb->blue  = FFB_GET_BLUE(v3);
 223 #endif
 224         ffb->z     = FFB_GET_Z(v3);
 225         ffb->dmyf  = FFB_GET_Y(v3);
 226         ffb->dmxf  = FFB_GET_X(v3);
 227
 228         fmesa->ffbScreen->rp_active = 1;
 229 }
 230
 231 static void TAG(ffb_init)(void)
 232 {
 233         ffb_tri_tab[IND]        = TAG(ffb_triangle);
 234         ffb_quad_tab[IND]       = TAG(ffb_quad);
 235 }
 236
 237 #undef IND
 238 #undef TAG