projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
i965/vs: Add comment noting copy_edgeflag state dependency.
[mesa.git] / src / mesa / drivers / dri / r200 / r200_swtcl.c
1 /*
2 Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
3
4 The Weather Channel (TM) funded Tungsten Graphics to develop the
5 initial release of the Radeon 8500 driver under the XFree86 license.
6 This notice must be preserved.
7
8 Permission is hereby granted, free of charge, to any person obtaining
9 a copy of this software and associated documentation files (the
10 "Software"), to deal in the Software without restriction, including
11 without limitation the rights to use, copy, modify, merge, publish,
12 distribute, sublicense, and/or sell copies of the Software, and to
13 permit persons to whom the Software is furnished to do so, subject to
14 the following conditions:
15
16 The above copyright notice and this permission notice (including the
17 next paragraph) shall be included in all copies or substantial
18 portions of the Software.
19
20 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
21 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
23 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
24 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
25 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
26 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27
28 **************************************************************************/
29
30 /*
31 * Authors:
32 * Keith Whitwell <keith@tungstengraphics.com>
33 */
34
35 #include "main/glheader.h"
36 #include "main/mtypes.h"
37 #include "main/colormac.h"
38 #include "main/enums.h"
39 #include "main/image.h"
40 #include "main/imports.h"
41 #include "main/macros.h"
42 #include "main/simple_list.h"
43
44 #include "swrast/s_context.h"
45 #include "swrast/s_fog.h"
46 #include "swrast_setup/swrast_setup.h"
47 #include "tnl/tnl.h"
48 #include "tnl/t_context.h"
49 #include "tnl/t_pipeline.h"
50
51 #include "r200_context.h"
52 #include "r200_ioctl.h"
53 #include "r200_state.h"
54 #include "r200_swtcl.h"
55 #include "r200_tcl.h"
56
57
58 /***********************************************************************
59 * Initialization
60 ***********************************************************************/
61
62 #define EMIT_ATTR( ATTR, STYLE, F0 ) \
63 do { \
64 rmesa->radeon.swtcl.vertex_attrs[rmesa->radeon.swtcl.vertex_attr_count].attrib = (ATTR); \
65 rmesa->radeon.swtcl.vertex_attrs[rmesa->radeon.swtcl.vertex_attr_count].format = (STYLE); \
66 rmesa->radeon.swtcl.vertex_attr_count++; \
67 fmt_0 |= F0; \
68 } while (0)
69
70 #define EMIT_PAD( N ) \
71 do { \
72 rmesa->radeon.swtcl.vertex_attrs[rmesa->radeon.swtcl.vertex_attr_count].attrib = 0; \
73 rmesa->radeon.swtcl.vertex_attrs[rmesa->radeon.swtcl.vertex_attr_count].format = EMIT_PAD; \
74 rmesa->radeon.swtcl.vertex_attrs[rmesa->radeon.swtcl.vertex_attr_count].offset = (N); \
75 rmesa->radeon.swtcl.vertex_attr_count++; \
76 } while (0)
77
78 static void r200SetVertexFormat( struct gl_context *ctx )
79 {
80 r200ContextPtr rmesa = R200_CONTEXT( ctx );
81 TNLcontext *tnl = TNL_CONTEXT(ctx);
82 struct vertex_buffer *VB = &tnl->vb;
83 GLbitfield64 index_bitset = tnl->render_inputs_bitset;
84 int fmt_0 = 0;
85 int fmt_1 = 0;
86 int offset = 0;
87
88 /* Important:
89 */
90 if ( VB->NdcPtr != NULL ) {
91 VB->AttribPtr[VERT_ATTRIB_POS] = VB->NdcPtr;
92 }
93 else {
94 VB->AttribPtr[VERT_ATTRIB_POS] = VB->ClipPtr;
95 }
96
97 assert( VB->AttribPtr[VERT_ATTRIB_POS] != NULL );
98 rmesa->radeon.swtcl.vertex_attr_count = 0;
99
100 /* EMIT_ATTR's must be in order as they tell t_vertex.c how to
101 * build up a hardware vertex.
102 */
103 if ( !rmesa->swtcl.needproj ||
104 (index_bitset & BITFIELD64_RANGE(_TNL_ATTRIB_TEX0, _TNL_NUM_TEX)) ) {
105 /* need w coord for projected textures */
106 EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F, R200_VTX_XY | R200_VTX_Z0 | R200_VTX_W0 );
107 offset = 4;
108 }
109 else {
110 EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_3F, R200_VTX_XY | R200_VTX_Z0 );
111 offset = 3;
112 }
113
114 if (index_bitset & BITFIELD64_BIT(_TNL_ATTRIB_POINTSIZE)) {
115 EMIT_ATTR( _TNL_ATTRIB_POINTSIZE, EMIT_1F, R200_VTX_POINT_SIZE );
116 offset += 1;
117 }
118
119 rmesa->swtcl.coloroffset = offset;
120 #if MESA_LITTLE_ENDIAN
121 EMIT_ATTR( _TNL_ATTRIB_COLOR0, EMIT_4UB_4F_RGBA, (R200_VTX_PK_RGBA << R200_VTX_COLOR_0_SHIFT) );
122 #else
123 EMIT_ATTR( _TNL_ATTRIB_COLOR0, EMIT_4UB_4F_ABGR, (R200_VTX_PK_RGBA << R200_VTX_COLOR_0_SHIFT) );
124 #endif
125 offset += 1;
126
127 rmesa->swtcl.specoffset = 0;
128 if (index_bitset &
129 (BITFIELD64_BIT(_TNL_ATTRIB_COLOR1) | BITFIELD64_BIT(_TNL_ATTRIB_FOG))) {
130
131 #if MESA_LITTLE_ENDIAN
132 if (index_bitset & BITFIELD64_BIT(_TNL_ATTRIB_COLOR1)) {
133 rmesa->swtcl.specoffset = offset;
134 EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_RGB, (R200_VTX_PK_RGBA << R200_VTX_COLOR_1_SHIFT) );
135 }
136 else {
137 EMIT_PAD( 3 );
138 }
139
140 if (index_bitset & BITFIELD64_BIT(_TNL_ATTRIB_FOG)) {
141 EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, (R200_VTX_PK_RGBA << R200_VTX_COLOR_1_SHIFT) );
142 }
143 else {
144 EMIT_PAD( 1 );
145 }
146 #else
147 if (index_bitset & BITFIELD64_BIT(_TNL_ATTRIB_FOG)) {
148 EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, (R200_VTX_PK_RGBA << R200_VTX_COLOR_1_SHIFT) );
149 }
150 else {
151 EMIT_PAD( 1 );
152 }
153
154 if (index_bitset & BITFIELD64_BIT(_TNL_ATTRIB_COLOR1)) {
155 rmesa->swtcl.specoffset = offset;
156 EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_BGR, (R200_VTX_PK_RGBA << R200_VTX_COLOR_1_SHIFT) );
157 }
158 else {
159 EMIT_PAD( 3 );
160 }
161 #endif
162 }
163
164 if (index_bitset & BITFIELD64_RANGE(_TNL_ATTRIB_TEX0, _TNL_NUM_TEX)) {
165 int i;
166
167 for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
168 if (index_bitset & BITFIELD64_BIT(_TNL_ATTRIB_TEX(i))) {
169 GLuint sz = VB->AttribPtr[_TNL_ATTRIB_TEX0 + i]->size;
170
171 fmt_1 |= sz << (3 * i);
172 EMIT_ATTR( _TNL_ATTRIB_TEX0+i, EMIT_1F + sz - 1, 0 );
173 }
174 }
175 }
176
177 if ( (rmesa->hw.ctx.cmd[CTX_PP_FOG_COLOR] & R200_FOG_USE_MASK)
178 != R200_FOG_USE_SPEC_ALPHA ) {
179 R200_STATECHANGE( rmesa, ctx );
180 rmesa->hw.ctx.cmd[CTX_PP_FOG_COLOR] &= ~R200_FOG_USE_MASK;
181 rmesa->hw.ctx.cmd[CTX_PP_FOG_COLOR] |= R200_FOG_USE_SPEC_ALPHA;
182 }
183
184 if (rmesa->radeon.tnl_index_bitset != index_bitset ||
185 (rmesa->hw.vtx.cmd[VTX_VTXFMT_0] != fmt_0) ||
186 (rmesa->hw.vtx.cmd[VTX_VTXFMT_1] != fmt_1) ) {
187 R200_NEWPRIM(rmesa);
188 R200_STATECHANGE( rmesa, vtx );
189 rmesa->hw.vtx.cmd[VTX_VTXFMT_0] = fmt_0;
190 rmesa->hw.vtx.cmd[VTX_VTXFMT_1] = fmt_1;
191
192 rmesa->radeon.swtcl.vertex_size =
193 _tnl_install_attrs( ctx,
194 rmesa->radeon.swtcl.vertex_attrs,
195 rmesa->radeon.swtcl.vertex_attr_count,
196 NULL, 0 );
197 rmesa->radeon.swtcl.vertex_size /= 4;
198 rmesa->radeon.tnl_index_bitset = index_bitset;
199 }
200 }
201
202 static void r200_predict_emit_size( r200ContextPtr rmesa )
203 {
204 if (RADEON_DEBUG & RADEON_VERTS)
205 fprintf(stderr, "%s\n", __func__);
206 const int vertex_array_size = 7;
207 const int prim_size = 3;
208 if (!rmesa->radeon.swtcl.emit_prediction) {
209 const int state_size = radeonCountStateEmitSize(&rmesa->radeon);
210 if (rcommonEnsureCmdBufSpace(&rmesa->radeon,
211 state_size +
212 vertex_array_size + prim_size,
213 __FUNCTION__))
214 rmesa->radeon.swtcl.emit_prediction = radeonCountStateEmitSize(&rmesa->radeon);
215 else
216 rmesa->radeon.swtcl.emit_prediction = state_size;
217 rmesa->radeon.swtcl.emit_prediction += vertex_array_size + prim_size
218 + rmesa->radeon.cmdbuf.cs->cdw;
219 }
220 }
221
222
223 static void r200RenderStart( struct gl_context *ctx )
224 {
225 r200SetVertexFormat( ctx );
226 if (RADEON_DEBUG & RADEON_VERTS)
227 fprintf(stderr, "%s\n", __func__);
228 }
229
230
231 /**
232 * Set vertex state for SW TCL. The primary purpose of this function is to
233 * determine in advance whether or not the hardware can / should do the
234 * projection divide or Mesa should do it.
235 */
236 void r200ChooseVertexState( struct gl_context *ctx )
237 {
238 r200ContextPtr rmesa = R200_CONTEXT( ctx );
239 TNLcontext *tnl = TNL_CONTEXT(ctx);
240 GLuint vte;
241 GLuint vap;
242
243 /* We must ensure that we don't do _tnl_need_projected_coords while in a
244 * rasterization fallback. As this function will be called again when we
245 * leave a rasterization fallback, we can just skip it for now.
246 */
247 if (rmesa->radeon.Fallback != 0)
248 return;
249
250 vte = rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL];
251 vap = rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL];
252
253 /* HW perspective divide is a win, but tiny vertex formats are a
254 * bigger one.
255 */
256 if ((0 == (tnl->render_inputs_bitset & BITFIELD64_RANGE(_TNL_ATTRIB_TEX0, _TNL_NUM_TEX)))
257 || (ctx->_TriangleCaps & (DD_TRI_LIGHT_TWOSIDE|DD_TRI_UNFILLED))) {
258 rmesa->swtcl.needproj = GL_TRUE;
259 vte |= R200_VTX_XY_FMT | R200_VTX_Z_FMT;
260 vte &= ~R200_VTX_W0_FMT;
261 if (tnl->render_inputs_bitset & BITFIELD64_RANGE(_TNL_ATTRIB_TEX0, _TNL_NUM_TEX)) {
262 vap &= ~R200_VAP_FORCE_W_TO_ONE;
263 }
264 else {
265 vap |= R200_VAP_FORCE_W_TO_ONE;
266 }
267 }
268 else {
269 rmesa->swtcl.needproj = GL_FALSE;
270 vte &= ~(R200_VTX_XY_FMT | R200_VTX_Z_FMT);
271 vte |= R200_VTX_W0_FMT;
272 vap &= ~R200_VAP_FORCE_W_TO_ONE;
273 }
274
275 _tnl_need_projected_coords( ctx, rmesa->swtcl.needproj );
276
277 if (vte != rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL]) {
278 R200_STATECHANGE( rmesa, vte );
279 rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL] = vte;
280 }
281
282 if (vap != rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL]) {
283 R200_STATECHANGE( rmesa, vap );
284 rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL] = vap;
285 }
286 }
287
288 void r200_swtcl_flush(struct gl_context *ctx, uint32_t current_offset)
289 {
290 r200ContextPtr rmesa = R200_CONTEXT(ctx);
291 if (RADEON_DEBUG & RADEON_VERTS)
292 fprintf(stderr, "%s\n", __func__);
293
294
295 radeonEmitState(&rmesa->radeon);
296 r200EmitVertexAOS( rmesa,
297 rmesa->radeon.swtcl.vertex_size,
298 rmesa->radeon.swtcl.bo,
299 current_offset);
300
301
302 r200EmitVbufPrim( rmesa,
303 rmesa->radeon.swtcl.hw_primitive,
304 rmesa->radeon.swtcl.numverts);
305 if ( rmesa->radeon.swtcl.emit_prediction < rmesa->radeon.cmdbuf.cs->cdw )
306 WARN_ONCE("Rendering was %d commands larger than predicted size."
307 " We might overflow command buffer.\n",
308 rmesa->radeon.cmdbuf.cs->cdw - rmesa->radeon.swtcl.emit_prediction );
309
310 rmesa->radeon.swtcl.emit_prediction = 0;
311
312 }
313
314 /**************************************************************************/
315
316
317 static INLINE GLuint reduced_hw_prim( struct gl_context *ctx, GLuint prim)
318 {
319 switch (prim) {
320 case GL_POINTS:
321 return ((!(ctx->_TriangleCaps & DD_POINT_SMOOTH)) ?
322 R200_VF_PRIM_POINT_SPRITES : R200_VF_PRIM_POINTS);
323 case GL_LINES:
324 /* fallthrough */
325 case GL_LINE_LOOP:
326 /* fallthrough */
327 case GL_LINE_STRIP:
328 return R200_VF_PRIM_LINES;
329 default:
330 /* all others reduced to triangles */
331 return R200_VF_PRIM_TRIANGLES;
332 }
333 }
334
335
336 static void r200RasterPrimitive( struct gl_context *ctx, GLuint hwprim );
337 static void r200RenderPrimitive( struct gl_context *ctx, GLenum prim );
338 static void r200ResetLineStipple( struct gl_context *ctx );
339
340 /***********************************************************************
341 * Emit primitives as inline vertices *
342 ***********************************************************************/
343
344 #define HAVE_POINTS 1
345 #define HAVE_LINES 1
346 #define HAVE_LINE_STRIPS 1
347 #define HAVE_TRIANGLES 1
348 #define HAVE_TRI_STRIPS 1
349 #define HAVE_TRI_STRIP_1 0
350 #define HAVE_TRI_FANS 1
351 #define HAVE_QUADS 0
352 #define HAVE_QUAD_STRIPS 0
353 #define HAVE_POLYGONS 1
354 #define HAVE_ELTS 0
355
356 static void* r200_alloc_verts( r200ContextPtr rmesa, GLuint n, GLuint size)
357 {
358 void *rv;
359 do {
360 r200_predict_emit_size( rmesa );
361 rv = rcommonAllocDmaLowVerts( &rmesa->radeon, n, size * 4 );
362 } while(!rv);
363 return rv;
364 }
365
366 #undef LOCAL_VARS
367 #undef ALLOC_VERTS
368 #define CTX_ARG r200ContextPtr rmesa
369 #define GET_VERTEX_DWORDS() rmesa->radeon.swtcl.vertex_size
370 #define ALLOC_VERTS( n, size ) r200_alloc_verts(rmesa, n, size)
371 #define LOCAL_VARS \
372 r200ContextPtr rmesa = R200_CONTEXT(ctx); \
373 const char *r200verts = (char *)rmesa->radeon.swtcl.verts;
374 #define VERT(x) (radeonVertex *)(r200verts + ((x) * vertsize * sizeof(int)))
375 #define VERTEX radeonVertex
376 #define DO_DEBUG_VERTS (1 && (R200_DEBUG & RADEON_VERTS))
377
378 #undef TAG
379 #define TAG(x) r200_##x
380 #include "tnl_dd/t_dd_triemit.h"
381
382
383 /***********************************************************************
384 * Macros for t_dd_tritmp.h to draw basic primitives *
385 ***********************************************************************/
386
387 #define QUAD( a, b, c, d ) r200_quad( rmesa, a, b, c, d )
388 #define TRI( a, b, c ) r200_triangle( rmesa, a, b, c )
389 #define LINE( a, b ) r200_line( rmesa, a, b )
390 #define POINT( a ) r200_point( rmesa, a )
391
392 /***********************************************************************
393 * Build render functions from dd templates *
394 ***********************************************************************/
395
396 #define R200_TWOSIDE_BIT 0x01
397 #define R200_UNFILLED_BIT 0x02
398 #define R200_MAX_TRIFUNC 0x04
399
400
401 static struct {
402 tnl_points_func points;
403 tnl_line_func line;
404 tnl_triangle_func triangle;
405 tnl_quad_func quad;
406 } rast_tab[R200_MAX_TRIFUNC];
407
408
409 #define DO_FALLBACK 0
410 #define DO_UNFILLED (IND & R200_UNFILLED_BIT)
411 #define DO_TWOSIDE (IND & R200_TWOSIDE_BIT)
412 #define DO_FLAT 0
413 #define DO_OFFSET 0
414 #define DO_TRI 1
415 #define DO_QUAD 1
416 #define DO_LINE 1
417 #define DO_POINTS 1
418 #define DO_FULL_QUAD 1
419
420 #define HAVE_SPEC 1
421 #define HAVE_BACK_COLORS 0
422 #define HAVE_HW_FLATSHADE 1
423 #define TAB rast_tab
424
425 #define DEPTH_SCALE 1.0
426 #define UNFILLED_TRI unfilled_tri
427 #define UNFILLED_QUAD unfilled_quad
428 #define VERT_X(_v) _v->v.x
429 #define VERT_Y(_v) _v->v.y
430 #define VERT_Z(_v) _v->v.z
431 #define AREA_IS_CCW( a ) (a < 0)
432 #define GET_VERTEX(e) (rmesa->radeon.swtcl.verts + (e*rmesa->radeon.swtcl.vertex_size*sizeof(int)))
433
434 #define VERT_SET_RGBA( v, c ) \
435 do { \
436 radeon_color_t *color = (radeon_color_t *)&((v)->ui[coloroffset]); \
437 UNCLAMPED_FLOAT_TO_UBYTE(color->red, (c)[0]); \
438 UNCLAMPED_FLOAT_TO_UBYTE(color->green, (c)[1]); \
439 UNCLAMPED_FLOAT_TO_UBYTE(color->blue, (c)[2]); \
440 UNCLAMPED_FLOAT_TO_UBYTE(color->alpha, (c)[3]); \
441 } while (0)
442
443 #define VERT_COPY_RGBA( v0, v1 ) v0->ui[coloroffset] = v1->ui[coloroffset]
444
445 #define VERT_SET_SPEC( v, c ) \
446 do { \
447 if (specoffset) { \
448 radeon_color_t *spec = (radeon_color_t *)&((v)->ui[specoffset]); \
449 UNCLAMPED_FLOAT_TO_UBYTE(spec->red, (c)[0]); \
450 UNCLAMPED_FLOAT_TO_UBYTE(spec->green, (c)[1]); \
451 UNCLAMPED_FLOAT_TO_UBYTE(spec->blue, (c)[2]); \
452 } \
453 } while (0)
454 #define VERT_COPY_SPEC( v0, v1 ) \
455 do { \
456 if (specoffset) { \
457 radeon_color_t *spec0 = (radeon_color_t *)&((v0)->ui[specoffset]); \
458 radeon_color_t *spec1 = (radeon_color_t *)&((v1)->ui[specoffset]); \
459 spec0->red = spec1->red; \
460 spec0->green = spec1->green; \
461 spec0->blue = spec1->blue; \
462 } \
463 } while (0)
464
465 /* These don't need LE32_TO_CPU() as they used to save and restore
466 * colors which are already in the correct format.
467 */
468 #define VERT_SAVE_RGBA( idx ) color[idx] = v[idx]->ui[coloroffset]
469 #define VERT_RESTORE_RGBA( idx ) v[idx]->ui[coloroffset] = color[idx]
470 #define VERT_SAVE_SPEC( idx ) if (specoffset) spec[idx] = v[idx]->ui[specoffset]
471 #define VERT_RESTORE_SPEC( idx ) if (specoffset) v[idx]->ui[specoffset] = spec[idx]
472
473 #undef LOCAL_VARS
474 #undef TAG
475 #undef INIT
476
477 #define LOCAL_VARS(n) \
478 r200ContextPtr rmesa = R200_CONTEXT(ctx); \
479 GLuint color[n] = {0}, spec[n] = {0}; \
480 GLuint coloroffset = rmesa->swtcl.coloroffset; \
481 GLuint specoffset = rmesa->swtcl.specoffset; \
482 (void) color; (void) spec; (void) coloroffset; (void) specoffset;
483
484 /***********************************************************************
485 * Helpers for rendering unfilled primitives *
486 ***********************************************************************/
487
488 #define RASTERIZE(x) r200RasterPrimitive( ctx, reduced_hw_prim(ctx, x) )
489 #define RENDER_PRIMITIVE rmesa->radeon.swtcl.render_primitive
490 #undef TAG
491 #define TAG(x) x
492 #include "tnl_dd/t_dd_unfilled.h"
493 #undef IND
494
495
496 /***********************************************************************
497 * Generate GL render functions *
498 ***********************************************************************/
499
500
501 #define IND (0)
502 #define TAG(x) x
503 #include "tnl_dd/t_dd_tritmp.h"
504
505 #define IND (R200_TWOSIDE_BIT)
506 #define TAG(x) x##_twoside
507 #include "tnl_dd/t_dd_tritmp.h"
508
509 #define IND (R200_UNFILLED_BIT)
510 #define TAG(x) x##_unfilled
511 #include "tnl_dd/t_dd_tritmp.h"
512
513 #define IND (R200_TWOSIDE_BIT|R200_UNFILLED_BIT)
514 #define TAG(x) x##_twoside_unfilled
515 #include "tnl_dd/t_dd_tritmp.h"
516
517
518 static void init_rast_tab( void )
519 {
520 init();
521 init_twoside();
522 init_unfilled();
523 init_twoside_unfilled();
524 }
525
526 /**********************************************************************/
527 /* Render unclipped begin/end objects */
528 /**********************************************************************/
529
530 #define RENDER_POINTS( start, count ) \
531 for ( ; start < count ; start++) \
532 r200_point( rmesa, VERT(start) )
533 #define RENDER_LINE( v0, v1 ) \
534 r200_line( rmesa, VERT(v0), VERT(v1) )
535 #define RENDER_TRI( v0, v1, v2 ) \
536 r200_triangle( rmesa, VERT(v0), VERT(v1), VERT(v2) )
537 #define RENDER_QUAD( v0, v1, v2, v3 ) \
538 r200_quad( rmesa, VERT(v0), VERT(v1), VERT(v2), VERT(v3) )
539 #define INIT(x) do { \
540 r200RenderPrimitive( ctx, x ); \
541 } while (0)
542 #undef LOCAL_VARS
543 #define LOCAL_VARS \
544 r200ContextPtr rmesa = R200_CONTEXT(ctx); \
545 const GLuint vertsize = rmesa->radeon.swtcl.vertex_size; \
546 const char *r200verts = (char *)rmesa->radeon.swtcl.verts; \
547 const GLuint * const elt = TNL_CONTEXT(ctx)->vb.Elts; \
548 const GLboolean stipple = ctx->Line.StippleFlag; \
549 (void) elt; (void) stipple;
550 #define RESET_STIPPLE if ( stipple ) r200ResetLineStipple( ctx );
551 #define RESET_OCCLUSION
552 #define PRESERVE_VB_DEFS
553 #define ELT(x) (x)
554 #define TAG(x) r200_##x##_verts
555 #include "tnl/t_vb_rendertmp.h"
556 #undef ELT
557 #undef TAG
558 #define TAG(x) r200_##x##_elts
559 #define ELT(x) elt[x]
560 #include "tnl/t_vb_rendertmp.h"
561
562
563
564 /**********************************************************************/
565 /* Choose render functions */
566 /**********************************************************************/
567
568 void r200ChooseRenderState( struct gl_context *ctx )
569 {
570 TNLcontext *tnl = TNL_CONTEXT(ctx);
571 r200ContextPtr rmesa = R200_CONTEXT(ctx);
572 GLuint index = 0;
573 GLuint flags = ctx->_TriangleCaps;
574
575 if (!rmesa->radeon.TclFallback || rmesa->radeon.Fallback)
576 return;
577
578 if (flags & DD_TRI_LIGHT_TWOSIDE) index |= R200_TWOSIDE_BIT;
579 if (flags & DD_TRI_UNFILLED) index |= R200_UNFILLED_BIT;
580
581 if (index != rmesa->radeon.swtcl.RenderIndex) {
582 tnl->Driver.Render.Points = rast_tab[index].points;
583 tnl->Driver.Render.Line = rast_tab[index].line;
584 tnl->Driver.Render.ClippedLine = rast_tab[index].line;
585 tnl->Driver.Render.Triangle = rast_tab[index].triangle;
586 tnl->Driver.Render.Quad = rast_tab[index].quad;
587
588 if (index == 0) {
589 tnl->Driver.Render.PrimTabVerts = r200_render_tab_verts;
590 tnl->Driver.Render.PrimTabElts = r200_render_tab_elts;
591 tnl->Driver.Render.ClippedPolygon = r200_fast_clipped_poly;
592 } else {
593 tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts;
594 tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts;
595 tnl->Driver.Render.ClippedPolygon = _tnl_RenderClippedPolygon;
596 }
597
598 rmesa->radeon.swtcl.RenderIndex = index;
599 }
600 }
601
602
603 /**********************************************************************/
604 /* High level hooks for t_vb_render.c */
605 /**********************************************************************/
606
607
608 static void r200RasterPrimitive( struct gl_context *ctx, GLuint hwprim )
609 {
610 r200ContextPtr rmesa = R200_CONTEXT(ctx);
611
612 radeon_prepare_render(&rmesa->radeon);
613 if (rmesa->radeon.NewGLState)
614 r200ValidateState( ctx );
615
616
617 if (rmesa->radeon.swtcl.hw_primitive != hwprim) {
618 /* need to disable perspective-correct texturing for point sprites */
619 if ((hwprim & 0xf) == R200_VF_PRIM_POINT_SPRITES && ctx->Point.PointSprite) {
620 if (rmesa->hw.set.cmd[SET_RE_CNTL] & R200_PERSPECTIVE_ENABLE) {
621 R200_STATECHANGE( rmesa, set );
622 rmesa->hw.set.cmd[SET_RE_CNTL] &= ~R200_PERSPECTIVE_ENABLE;
623 }
624 }
625 else if (!(rmesa->hw.set.cmd[SET_RE_CNTL] & R200_PERSPECTIVE_ENABLE)) {
626 R200_STATECHANGE( rmesa, set );
627 rmesa->hw.set.cmd[SET_RE_CNTL] |= R200_PERSPECTIVE_ENABLE;
628 }
629 R200_NEWPRIM( rmesa );
630 rmesa->radeon.swtcl.hw_primitive = hwprim;
631 }
632 }
633
634 static void r200RenderPrimitive( struct gl_context *ctx, GLenum prim )
635 {
636 r200ContextPtr rmesa = R200_CONTEXT(ctx);
637 rmesa->radeon.swtcl.render_primitive = prim;
638 if (prim < GL_TRIANGLES || !(ctx->_TriangleCaps & DD_TRI_UNFILLED))
639 r200RasterPrimitive( ctx, reduced_hw_prim(ctx, prim) );
640 }
641
642 static void r200RenderFinish( struct gl_context *ctx )
643 {
644 }
645
646 static void r200ResetLineStipple( struct gl_context *ctx )
647 {
648 r200ContextPtr rmesa = R200_CONTEXT(ctx);
649 R200_STATECHANGE( rmesa, lin );
650 }
651
652
653 /**********************************************************************/
654 /* Transition to/from hardware rasterization. */
655 /**********************************************************************/
656
657 static const char * const fallbackStrings[] = {
658 "Texture mode",
659 "glDrawBuffer(GL_FRONT_AND_BACK)",
660 "glEnable(GL_STENCIL) without hw stencil buffer",
661 "glRenderMode(selection or feedback)",
662 "R200_NO_RAST",
663 "Mixing GL_CLAMP_TO_BORDER and GL_CLAMP (or GL_MIRROR_CLAMP_ATI)"
664 };
665
666
667 static const char *getFallbackString(GLuint bit)
668 {
669 int i = 0;
670 while (bit > 1) {
671 i++;
672 bit >>= 1;
673 }
674 return fallbackStrings[i];
675 }
676
677
678 void r200Fallback( struct gl_context *ctx, GLuint bit, GLboolean mode )
679 {
680 r200ContextPtr rmesa = R200_CONTEXT(ctx);
681 TNLcontext *tnl = TNL_CONTEXT(ctx);
682 GLuint oldfallback = rmesa->radeon.Fallback;
683
684 if (mode) {
685 rmesa->radeon.Fallback |= bit;
686 if (oldfallback == 0) {
687 radeon_firevertices(&rmesa->radeon);
688 TCL_FALLBACK( ctx, R200_TCL_FALLBACK_RASTER, GL_TRUE );
689 _swsetup_Wakeup( ctx );
690 rmesa->radeon.swtcl.RenderIndex = ~0;
691 if (R200_DEBUG & RADEON_FALLBACKS) {
692 fprintf(stderr, "R200 begin rasterization fallback: 0x%x %s\n",
693 bit, getFallbackString(bit));
694 }
695 }
696 }
697 else {
698 rmesa->radeon.Fallback &= ~bit;
699 if (oldfallback == bit) {
700
701 _swrast_flush( ctx );
702 tnl->Driver.Render.Start = r200RenderStart;
703 tnl->Driver.Render.PrimitiveNotify = r200RenderPrimitive;
704 tnl->Driver.Render.Finish = r200RenderFinish;
705
706 tnl->Driver.Render.BuildVertices = _tnl_build_vertices;
707 tnl->Driver.Render.CopyPV = _tnl_copy_pv;
708 tnl->Driver.Render.Interp = _tnl_interp;
709
710 tnl->Driver.Render.ResetLineStipple = r200ResetLineStipple;
711 TCL_FALLBACK( ctx, R200_TCL_FALLBACK_RASTER, GL_FALSE );
712 if (rmesa->radeon.TclFallback) {
713 /* These are already done if rmesa->radeon.TclFallback goes to
714 * zero above. But not if it doesn't (R200_NO_TCL for
715 * example?)
716 */
717 _tnl_invalidate_vertex_state( ctx, ~0 );
718 _tnl_invalidate_vertices( ctx, ~0 );
719 rmesa->radeon.tnl_index_bitset = 0;
720 r200ChooseVertexState( ctx );
721 r200ChooseRenderState( ctx );
722 }
723 if (R200_DEBUG & RADEON_FALLBACKS) {
724 fprintf(stderr, "R200 end rasterization fallback: 0x%x %s\n",
725 bit, getFallbackString(bit));
726 }
727 }
728 }
729 }
730
731
732
733
734 /**
735 * Cope with depth operations by drawing individual pixels as points.
736 *
737 * \todo
738 * The way the vertex state is set in this routine is hokey. It seems to
739 * work, but it's very hackish. This whole routine is pretty hackish. If
740 * the bitmap is small enough, it seems like it would be faster to copy it
741 * to AGP memory and use it as a non-power-of-two texture (i.e.,
742 * NV_texture_rectangle).
743 */
744 void
745 r200PointsBitmap( struct gl_context *ctx, GLint px, GLint py,
746 GLsizei width, GLsizei height,
747 const struct gl_pixelstore_attrib *unpack,
748 const GLubyte *bitmap )
749 {
750 r200ContextPtr rmesa = R200_CONTEXT(ctx);
751 const GLfloat *rc = ctx->Current.RasterColor;
752 GLint row, col;
753 radeonVertex vert;
754 GLuint orig_vte;
755 GLuint h;
756
757
758 /* Turn off tcl.
759 */
760 TCL_FALLBACK( ctx, R200_TCL_FALLBACK_BITMAP, 1 );
761
762 /* Choose tiny vertex format
763 */
764 {
765 const GLuint fmt_0 = R200_VTX_XY | R200_VTX_Z0 | R200_VTX_W0
766 | (R200_VTX_PK_RGBA << R200_VTX_COLOR_0_SHIFT);
767 const GLuint fmt_1 = 0;
768 GLuint vte = rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL];
769 GLuint vap = rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL];
770
771 vte &= ~(R200_VTX_XY_FMT | R200_VTX_Z_FMT);
772 vte |= R200_VTX_W0_FMT;
773 vap &= ~R200_VAP_FORCE_W_TO_ONE;
774
775 rmesa->radeon.swtcl.vertex_size = 5;
776
777 if ( (rmesa->hw.vtx.cmd[VTX_VTXFMT_0] != fmt_0)
778 || (rmesa->hw.vtx.cmd[VTX_VTXFMT_1] != fmt_1) ) {
779 R200_NEWPRIM(rmesa);
780 R200_STATECHANGE( rmesa, vtx );
781 rmesa->hw.vtx.cmd[VTX_VTXFMT_0] = fmt_0;
782 rmesa->hw.vtx.cmd[VTX_VTXFMT_1] = fmt_1;
783 }
784
785 if (vte != rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL]) {
786 R200_STATECHANGE( rmesa, vte );
787 rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL] = vte;
788 }
789
790 if (vap != rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL]) {
791 R200_STATECHANGE( rmesa, vap );
792 rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL] = vap;
793 }
794 }
795
796 /* Ready for point primitives:
797 */
798 r200RenderPrimitive( ctx, GL_POINTS );
799
800 /* Turn off the hw viewport transformation:
801 */
802 R200_STATECHANGE( rmesa, vte );
803 orig_vte = rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL];
804 rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL] &= ~(R200_VPORT_X_SCALE_ENA |
805 R200_VPORT_Y_SCALE_ENA |
806 R200_VPORT_Z_SCALE_ENA |
807 R200_VPORT_X_OFFSET_ENA |
808 R200_VPORT_Y_OFFSET_ENA |
809 R200_VPORT_Z_OFFSET_ENA);
810
811 /* Turn off other stuff: Stipple?, texture?, blending?, etc.
812 */
813
814
815 /* Populate the vertex
816 *
817 * Incorporate FOG into RGBA
818 */
819 if (ctx->Fog.Enabled) {
820 const GLfloat *fc = ctx->Fog.Color;
821 GLfloat color[4];
822 GLfloat f;
823
824 if (ctx->Fog.FogCoordinateSource == GL_FOG_COORDINATE_EXT)
825 f = _swrast_z_to_fogfactor(ctx, ctx->Current.Attrib[VERT_ATTRIB_FOG][0]);
826 else
827 f = _swrast_z_to_fogfactor(ctx, ctx->Current.RasterDistance);
828
829 color[0] = f * rc[0] + (1.F - f) * fc[0];
830 color[1] = f * rc[1] + (1.F - f) * fc[1];
831 color[2] = f * rc[2] + (1.F - f) * fc[2];
832 color[3] = rc[3];
833
834 UNCLAMPED_FLOAT_TO_CHAN(vert.tv.color.red, color[0]);
835 UNCLAMPED_FLOAT_TO_CHAN(vert.tv.color.green, color[1]);
836 UNCLAMPED_FLOAT_TO_CHAN(vert.tv.color.blue, color[2]);
837 UNCLAMPED_FLOAT_TO_CHAN(vert.tv.color.alpha, color[3]);
838 }
839 else {
840 UNCLAMPED_FLOAT_TO_CHAN(vert.tv.color.red, rc[0]);
841 UNCLAMPED_FLOAT_TO_CHAN(vert.tv.color.green, rc[1]);
842 UNCLAMPED_FLOAT_TO_CHAN(vert.tv.color.blue, rc[2]);
843 UNCLAMPED_FLOAT_TO_CHAN(vert.tv.color.alpha, rc[3]);
844 }
845
846
847 vert.tv.z = ctx->Current.RasterPos[2];
848
849
850 /* Update window height
851 */
852 h = radeon_get_drawable(&rmesa->radeon)->h;
853
854 /* Clipping handled by existing mechansims in r200_ioctl.c?
855 */
856 for (row=0; row<height; row++) {
857 const GLubyte *src = (const GLubyte *)
858 _mesa_image_address2d(unpack, bitmap, width, height,
859 GL_COLOR_INDEX, GL_BITMAP, row, 0 );
860
861 if (unpack->LsbFirst) {
862 /* Lsb first */
863 GLubyte mask = 1U << (unpack->SkipPixels & 0x7);
864 for (col=0; col<width; col++) {
865 if (*src & mask) {
866 vert.tv.x = px+col;
867 vert.tv.y = h - (py+row) - 1;
868 r200_point( rmesa, &vert );
869 }
870 src += (mask >> 7);
871 mask = ((mask << 1) & 0xff) | (mask >> 7);
872 }
873
874 /* get ready for next row */
875 if (mask != 1)
876 src++;
877 }
878 else {
879 /* Msb first */
880 GLubyte mask = 128U >> (unpack->SkipPixels & 0x7);
881 for (col=0; col<width; col++) {
882 if (*src & mask) {
883 vert.tv.x = px+col;
884 vert.tv.y = h - (py+row) - 1;
885 r200_point( rmesa, &vert );
886 }
887 src += mask & 1;
888 mask = ((mask << 7) & 0xff) | (mask >> 1);
889 }
890 /* get ready for next row */
891 if (mask != 128)
892 src++;
893 }
894 }
895
896 /* Fire outstanding vertices, restore state
897 */
898 R200_STATECHANGE( rmesa, vte );
899 rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL] = orig_vte;
900
901 /* Unfallback
902 */
903 TCL_FALLBACK( ctx, R200_TCL_FALLBACK_BITMAP, 0 );
904
905 /* Need to restore vertexformat?
906 */
907 if (rmesa->radeon.TclFallback)
908 r200ChooseVertexState( ctx );
909 }
910
911
912
913 /**********************************************************************/
914 /* Initialization. */
915 /**********************************************************************/
916
917 void r200InitSwtcl( struct gl_context *ctx )
918 {
919 TNLcontext *tnl = TNL_CONTEXT(ctx);
920 r200ContextPtr rmesa = R200_CONTEXT(ctx);
921 static int firsttime = 1;
922
923 if (firsttime) {
924 init_rast_tab();
925 firsttime = 0;
926 }
927 rmesa->radeon.swtcl.emit_prediction = 0;
928
929 tnl->Driver.Render.Start = r200RenderStart;
930 tnl->Driver.Render.Finish = r200RenderFinish;
931 tnl->Driver.Render.PrimitiveNotify = r200RenderPrimitive;
932 tnl->Driver.Render.ResetLineStipple = r200ResetLineStipple;
933 tnl->Driver.Render.BuildVertices = _tnl_build_vertices;
934 tnl->Driver.Render.CopyPV = _tnl_copy_pv;
935 tnl->Driver.Render.Interp = _tnl_interp;
936
937 /* FIXME: what are these numbers? */
938 _tnl_init_vertices( ctx, ctx->Const.MaxArrayLockSize + 12,
939 36 * sizeof(GLfloat) );
940
941 rmesa->radeon.swtcl.verts = (GLubyte *)tnl->clipspace.vertex_buf;
942 rmesa->radeon.swtcl.RenderIndex = ~0;
943 rmesa->radeon.swtcl.render_primitive = GL_TRIANGLES;
944 rmesa->radeon.swtcl.hw_primitive = 0;
945 }
946