projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
r200: Convert r200 to use new style debug code.
[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 "math/m_translate.h"
48 #include "tnl/tnl.h"
49 #include "tnl/t_context.h"
50 #include "tnl/t_pipeline.h"
51
52 #include "r200_context.h"
53 #include "r200_ioctl.h"
54 #include "r200_state.h"
55 #include "r200_swtcl.h"
56 #include "r200_tcl.h"
57
58
59 /***********************************************************************
60 * Initialization
61 ***********************************************************************/
62
63 #define EMIT_ATTR( ATTR, STYLE, F0 ) \
64 do { \
65 rmesa->radeon.swtcl.vertex_attrs[rmesa->radeon.swtcl.vertex_attr_count].attrib = (ATTR); \
66 rmesa->radeon.swtcl.vertex_attrs[rmesa->radeon.swtcl.vertex_attr_count].format = (STYLE); \
67 rmesa->radeon.swtcl.vertex_attr_count++; \
68 fmt_0 |= F0; \
69 } while (0)
70
71 #define EMIT_PAD( N ) \
72 do { \
73 rmesa->radeon.swtcl.vertex_attrs[rmesa->radeon.swtcl.vertex_attr_count].attrib = 0; \
74 rmesa->radeon.swtcl.vertex_attrs[rmesa->radeon.swtcl.vertex_attr_count].format = EMIT_PAD; \
75 rmesa->radeon.swtcl.vertex_attrs[rmesa->radeon.swtcl.vertex_attr_count].offset = (N); \
76 rmesa->radeon.swtcl.vertex_attr_count++; \
77 } while (0)
78
79 static void r200SetVertexFormat( GLcontext *ctx )
80 {
81 r200ContextPtr rmesa = R200_CONTEXT( ctx );
82 TNLcontext *tnl = TNL_CONTEXT(ctx);
83 struct vertex_buffer *VB = &tnl->vb;
84 DECLARE_RENDERINPUTS(index_bitset);
85 int fmt_0 = 0;
86 int fmt_1 = 0;
87 int offset = 0;
88
89 RENDERINPUTS_COPY( index_bitset, tnl->render_inputs_bitset );
90
91 /* Important:
92 */
93 if ( VB->NdcPtr != NULL ) {
94 VB->AttribPtr[VERT_ATTRIB_POS] = VB->NdcPtr;
95 }
96 else {
97 VB->AttribPtr[VERT_ATTRIB_POS] = VB->ClipPtr;
98 }
99
100 assert( VB->AttribPtr[VERT_ATTRIB_POS] != NULL );
101 rmesa->radeon.swtcl.vertex_attr_count = 0;
102
103 /* EMIT_ATTR's must be in order as they tell t_vertex.c how to
104 * build up a hardware vertex.
105 */
106 if ( !rmesa->swtcl.needproj ||
107 RENDERINPUTS_TEST_RANGE( index_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX )) { /* need w coord for projected textures */
108 EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F, R200_VTX_XY | R200_VTX_Z0 | R200_VTX_W0 );
109 offset = 4;
110 }
111 else {
112 EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_3F, R200_VTX_XY | R200_VTX_Z0 );
113 offset = 3;
114 }
115
116 if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_POINTSIZE )) {
117 EMIT_ATTR( _TNL_ATTRIB_POINTSIZE, EMIT_1F, R200_VTX_POINT_SIZE );
118 offset += 1;
119 }
120
121 rmesa->swtcl.coloroffset = offset;
122 #if MESA_LITTLE_ENDIAN
123 EMIT_ATTR( _TNL_ATTRIB_COLOR0, EMIT_4UB_4F_RGBA, (R200_VTX_PK_RGBA << R200_VTX_COLOR_0_SHIFT) );
124 #else
125 EMIT_ATTR( _TNL_ATTRIB_COLOR0, EMIT_4UB_4F_ABGR, (R200_VTX_PK_RGBA << R200_VTX_COLOR_0_SHIFT) );
126 #endif
127 offset += 1;
128
129 rmesa->swtcl.specoffset = 0;
130 if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 ) ||
131 RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG )) {
132
133 #if MESA_LITTLE_ENDIAN
134 if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 )) {
135 rmesa->swtcl.specoffset = offset;
136 EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_RGB, (R200_VTX_PK_RGBA << R200_VTX_COLOR_1_SHIFT) );
137 }
138 else {
139 EMIT_PAD( 3 );
140 }
141
142 if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG )) {
143 EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, (R200_VTX_PK_RGBA << R200_VTX_COLOR_1_SHIFT) );
144 }
145 else {
146 EMIT_PAD( 1 );
147 }
148 #else
149 if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_FOG )) {
150 EMIT_ATTR( _TNL_ATTRIB_FOG, EMIT_1UB_1F, (R200_VTX_PK_RGBA << R200_VTX_COLOR_1_SHIFT) );
151 }
152 else {
153 EMIT_PAD( 1 );
154 }
155
156 if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_COLOR1 )) {
157 rmesa->swtcl.specoffset = offset;
158 EMIT_ATTR( _TNL_ATTRIB_COLOR1, EMIT_3UB_3F_BGR, (R200_VTX_PK_RGBA << R200_VTX_COLOR_1_SHIFT) );
159 }
160 else {
161 EMIT_PAD( 3 );
162 }
163 #endif
164 }
165
166 if (RENDERINPUTS_TEST_RANGE( index_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX )) {
167 int i;
168
169 for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
170 if (RENDERINPUTS_TEST( index_bitset, _TNL_ATTRIB_TEX(i) )) {
171 GLuint sz = VB->TexCoordPtr[i]->size;
172
173 fmt_1 |= sz << (3 * i);
174 EMIT_ATTR( _TNL_ATTRIB_TEX0+i, EMIT_1F + sz - 1, 0 );
175 }
176 }
177 }
178
179 if ( (rmesa->hw.ctx.cmd[CTX_PP_FOG_COLOR] & R200_FOG_USE_MASK)
180 != R200_FOG_USE_SPEC_ALPHA ) {
181 R200_STATECHANGE( rmesa, ctx );
182 rmesa->hw.ctx.cmd[CTX_PP_FOG_COLOR] &= ~R200_FOG_USE_MASK;
183 rmesa->hw.ctx.cmd[CTX_PP_FOG_COLOR] |= R200_FOG_USE_SPEC_ALPHA;
184 }
185
186 if (!RENDERINPUTS_EQUAL( rmesa->radeon.tnl_index_bitset, index_bitset ) ||
187 (rmesa->hw.vtx.cmd[VTX_VTXFMT_0] != fmt_0) ||
188 (rmesa->hw.vtx.cmd[VTX_VTXFMT_1] != fmt_1) ) {
189 R200_NEWPRIM(rmesa);
190 R200_STATECHANGE( rmesa, vtx );
191 rmesa->hw.vtx.cmd[VTX_VTXFMT_0] = fmt_0;
192 rmesa->hw.vtx.cmd[VTX_VTXFMT_1] = fmt_1;
193
194 rmesa->radeon.swtcl.vertex_size =
195 _tnl_install_attrs( ctx,
196 rmesa->radeon.swtcl.vertex_attrs,
197 rmesa->radeon.swtcl.vertex_attr_count,
198 NULL, 0 );
199 rmesa->radeon.swtcl.vertex_size /= 4;
200 RENDERINPUTS_COPY( rmesa->radeon.tnl_index_bitset, index_bitset );
201 }
202 }
203
204 static void r200_predict_emit_size( r200ContextPtr rmesa )
205 {
206 if (RADEON_DEBUG & RADEON_VERTS)
207 fprintf(stderr, "%s\n", __func__);
208 const int vertex_array_size = 7;
209 const int prim_size = 3;
210 if (!rmesa->radeon.swtcl.emit_prediction) {
211 const int state_size = radeonCountStateEmitSize(&rmesa->radeon);
212 if (rcommonEnsureCmdBufSpace(&rmesa->radeon,
213 state_size +
214 vertex_array_size + prim_size,
215 __FUNCTION__))
216 rmesa->radeon.swtcl.emit_prediction = radeonCountStateEmitSize(&rmesa->radeon);
217 else
218 rmesa->radeon.swtcl.emit_prediction = state_size;
219 rmesa->radeon.swtcl.emit_prediction += vertex_array_size + prim_size
220 + rmesa->radeon.cmdbuf.cs->cdw;
221 }
222 }
223
224
225 static void r200RenderStart( GLcontext *ctx )
226 {
227 r200SetVertexFormat( ctx );
228 if (RADEON_DEBUG & RADEON_VERTS)
229 fprintf(stderr, "%s\n", __func__);
230 }
231
232
233 /**
234 * Set vertex state for SW TCL. The primary purpose of this function is to
235 * determine in advance whether or not the hardware can / should do the
236 * projection divide or Mesa should do it.
237 */
238 void r200ChooseVertexState( GLcontext *ctx )
239 {
240 r200ContextPtr rmesa = R200_CONTEXT( ctx );
241 TNLcontext *tnl = TNL_CONTEXT(ctx);
242 GLuint vte;
243 GLuint vap;
244
245 /* We must ensure that we don't do _tnl_need_projected_coords while in a
246 * rasterization fallback. As this function will be called again when we
247 * leave a rasterization fallback, we can just skip it for now.
248 */
249 if (rmesa->radeon.Fallback != 0)
250 return;
251
252 vte = rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL];
253 vap = rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL];
254
255 /* HW perspective divide is a win, but tiny vertex formats are a
256 * bigger one.
257 */
258 if (!RENDERINPUTS_TEST_RANGE( tnl->render_inputs_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX )
259 || (ctx->_TriangleCaps & (DD_TRI_LIGHT_TWOSIDE|DD_TRI_UNFILLED))) {
260 rmesa->swtcl.needproj = GL_TRUE;
261 vte |= R200_VTX_XY_FMT | R200_VTX_Z_FMT;
262 vte &= ~R200_VTX_W0_FMT;
263 if (RENDERINPUTS_TEST_RANGE( tnl->render_inputs_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX )) {
264 vap &= ~R200_VAP_FORCE_W_TO_ONE;
265 }
266 else {
267 vap |= R200_VAP_FORCE_W_TO_ONE;
268 }
269 }
270 else {
271 rmesa->swtcl.needproj = GL_FALSE;
272 vte &= ~(R200_VTX_XY_FMT | R200_VTX_Z_FMT);
273 vte |= R200_VTX_W0_FMT;
274 vap &= ~R200_VAP_FORCE_W_TO_ONE;
275 }
276
277 _tnl_need_projected_coords( ctx, rmesa->swtcl.needproj );
278
279 if (vte != rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL]) {
280 R200_STATECHANGE( rmesa, vte );
281 rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL] = vte;
282 }
283
284 if (vap != rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL]) {
285 R200_STATECHANGE( rmesa, vap );
286 rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL] = vap;
287 }
288 }
289
290 void r200_swtcl_flush(GLcontext *ctx, uint32_t current_offset)
291 {
292 r200ContextPtr rmesa = R200_CONTEXT(ctx);
293 if (RADEON_DEBUG & RADEON_VERTS)
294 fprintf(stderr, "%s\n", __func__);
295
296
297 radeonEmitState(&rmesa->radeon);
298 r200EmitVertexAOS( rmesa,
299 rmesa->radeon.swtcl.vertex_size,
300 first_elem(&rmesa->radeon.dma.reserved)->bo,
301 current_offset);
302
303
304 r200EmitVbufPrim( rmesa,
305 rmesa->radeon.swtcl.hw_primitive,
306 rmesa->radeon.swtcl.numverts);
307 if ( rmesa->radeon.swtcl.emit_prediction < rmesa->radeon.cmdbuf.cs->cdw )
308 WARN_ONCE("Rendering was %d commands larger than predicted size."
309 " We might overflow command buffer.\n",
310 rmesa->radeon.cmdbuf.cs->cdw - rmesa->radeon.swtcl.emit_prediction );
311
312 rmesa->radeon.swtcl.emit_prediction = 0;
313
314 }
315
316 /**************************************************************************/
317
318
319 static INLINE GLuint reduced_hw_prim( GLcontext *ctx, GLuint prim)
320 {
321 switch (prim) {
322 case GL_POINTS:
323 return (ctx->Point.PointSprite ||
324 ((ctx->_TriangleCaps & (DD_POINT_SIZE | DD_POINT_ATTEN)) &&
325 !(ctx->_TriangleCaps & (DD_POINT_SMOOTH)))) ?
326 R200_VF_PRIM_POINT_SPRITES : R200_VF_PRIM_POINTS;
327 case GL_LINES:
328 /* fallthrough */
329 case GL_LINE_LOOP:
330 /* fallthrough */
331 case GL_LINE_STRIP:
332 return R200_VF_PRIM_LINES;
333 default:
334 /* all others reduced to triangles */
335 return R200_VF_PRIM_TRIANGLES;
336 }
337 }
338
339
340 static void r200RasterPrimitive( GLcontext *ctx, GLuint hwprim );
341 static void r200RenderPrimitive( GLcontext *ctx, GLenum prim );
342 static void r200ResetLineStipple( GLcontext *ctx );
343
344 /***********************************************************************
345 * Emit primitives as inline vertices *
346 ***********************************************************************/
347
348 #define HAVE_POINTS 1
349 #define HAVE_LINES 1
350 #define HAVE_LINE_STRIPS 1
351 #define HAVE_TRIANGLES 1
352 #define HAVE_TRI_STRIPS 1
353 #define HAVE_TRI_STRIP_1 0
354 #define HAVE_TRI_FANS 1
355 #define HAVE_QUADS 0
356 #define HAVE_QUAD_STRIPS 0
357 #define HAVE_POLYGONS 1
358 #define HAVE_ELTS 0
359
360 static void* r200_alloc_verts( r200ContextPtr rmesa, GLuint n, GLuint size)
361 {
362 void *rv;
363 do {
364 r200_predict_emit_size( rmesa );
365 rv = rcommonAllocDmaLowVerts( &rmesa->radeon, n, size * 4 );
366 } while(!rv);
367 return rv;
368 }
369
370 #undef LOCAL_VARS
371 #undef ALLOC_VERTS
372 #define CTX_ARG r200ContextPtr rmesa
373 #define GET_VERTEX_DWORDS() rmesa->radeon.swtcl.vertex_size
374 #define ALLOC_VERTS( n, size ) r200_alloc_verts(rmesa, n, size)
375 #define LOCAL_VARS \
376 r200ContextPtr rmesa = R200_CONTEXT(ctx); \
377 const char *r200verts = (char *)rmesa->radeon.swtcl.verts;
378 #define VERT(x) (radeonVertex *)(r200verts + ((x) * vertsize * sizeof(int)))
379 #define VERTEX radeonVertex
380 #define DO_DEBUG_VERTS (1 && (R200_DEBUG & RADEON_VERTS))
381
382 #undef TAG
383 #define TAG(x) r200_##x
384 #include "tnl_dd/t_dd_triemit.h"
385
386
387 /***********************************************************************
388 * Macros for t_dd_tritmp.h to draw basic primitives *
389 ***********************************************************************/
390
391 #define QUAD( a, b, c, d ) r200_quad( rmesa, a, b, c, d )
392 #define TRI( a, b, c ) r200_triangle( rmesa, a, b, c )
393 #define LINE( a, b ) r200_line( rmesa, a, b )
394 #define POINT( a ) r200_point( rmesa, a )
395
396 /***********************************************************************
397 * Build render functions from dd templates *
398 ***********************************************************************/
399
400 #define R200_TWOSIDE_BIT 0x01
401 #define R200_UNFILLED_BIT 0x02
402 #define R200_MAX_TRIFUNC 0x04
403
404
405 static struct {
406 tnl_points_func points;
407 tnl_line_func line;
408 tnl_triangle_func triangle;
409 tnl_quad_func quad;
410 } rast_tab[R200_MAX_TRIFUNC];
411
412
413 #define DO_FALLBACK 0
414 #define DO_UNFILLED (IND & R200_UNFILLED_BIT)
415 #define DO_TWOSIDE (IND & R200_TWOSIDE_BIT)
416 #define DO_FLAT 0
417 #define DO_OFFSET 0
418 #define DO_TRI 1
419 #define DO_QUAD 1
420 #define DO_LINE 1
421 #define DO_POINTS 1
422 #define DO_FULL_QUAD 1
423
424 #define HAVE_RGBA 1
425 #define HAVE_SPEC 1
426 #define HAVE_BACK_COLORS 0
427 #define HAVE_HW_FLATSHADE 1
428 #define TAB rast_tab
429
430 #define DEPTH_SCALE 1.0
431 #define UNFILLED_TRI unfilled_tri
432 #define UNFILLED_QUAD unfilled_quad
433 #define VERT_X(_v) _v->v.x
434 #define VERT_Y(_v) _v->v.y
435 #define VERT_Z(_v) _v->v.z
436 #define AREA_IS_CCW( a ) (a < 0)
437 #define GET_VERTEX(e) (rmesa->radeon.swtcl.verts + (e*rmesa->radeon.swtcl.vertex_size*sizeof(int)))
438
439 #define VERT_SET_RGBA( v, c ) \
440 do { \
441 radeon_color_t *color = (radeon_color_t *)&((v)->ui[coloroffset]); \
442 UNCLAMPED_FLOAT_TO_UBYTE(color->red, (c)[0]); \
443 UNCLAMPED_FLOAT_TO_UBYTE(color->green, (c)[1]); \
444 UNCLAMPED_FLOAT_TO_UBYTE(color->blue, (c)[2]); \
445 UNCLAMPED_FLOAT_TO_UBYTE(color->alpha, (c)[3]); \
446 } while (0)
447
448 #define VERT_COPY_RGBA( v0, v1 ) v0->ui[coloroffset] = v1->ui[coloroffset]
449
450 #define VERT_SET_SPEC( v, c ) \
451 do { \
452 if (specoffset) { \
453 radeon_color_t *spec = (radeon_color_t *)&((v)->ui[specoffset]); \
454 UNCLAMPED_FLOAT_TO_UBYTE(spec->red, (c)[0]); \
455 UNCLAMPED_FLOAT_TO_UBYTE(spec->green, (c)[1]); \
456 UNCLAMPED_FLOAT_TO_UBYTE(spec->blue, (c)[2]); \
457 } \
458 } while (0)
459 #define VERT_COPY_SPEC( v0, v1 ) \
460 do { \
461 if (specoffset) { \
462 radeon_color_t *spec0 = (radeon_color_t *)&((v0)->ui[specoffset]); \
463 radeon_color_t *spec1 = (radeon_color_t *)&((v1)->ui[specoffset]); \
464 spec0->red = spec1->red; \
465 spec0->green = spec1->green; \
466 spec0->blue = spec1->blue; \
467 } \
468 } while (0)
469
470 /* These don't need LE32_TO_CPU() as they used to save and restore
471 * colors which are already in the correct format.
472 */
473 #define VERT_SAVE_RGBA( idx ) color[idx] = v[idx]->ui[coloroffset]
474 #define VERT_RESTORE_RGBA( idx ) v[idx]->ui[coloroffset] = color[idx]
475 #define VERT_SAVE_SPEC( idx ) if (specoffset) spec[idx] = v[idx]->ui[specoffset]
476 #define VERT_RESTORE_SPEC( idx ) if (specoffset) v[idx]->ui[specoffset] = spec[idx]
477
478 #undef LOCAL_VARS
479 #undef TAG
480 #undef INIT
481
482 #define LOCAL_VARS(n) \
483 r200ContextPtr rmesa = R200_CONTEXT(ctx); \
484 GLuint color[n] = {0}, spec[n] = {0}; \
485 GLuint coloroffset = rmesa->swtcl.coloroffset; \
486 GLuint specoffset = rmesa->swtcl.specoffset; \
487 (void) color; (void) spec; (void) coloroffset; (void) specoffset;
488
489 /***********************************************************************
490 * Helpers for rendering unfilled primitives *
491 ***********************************************************************/
492
493 #define RASTERIZE(x) r200RasterPrimitive( ctx, reduced_hw_prim(ctx, x) )
494 #define RENDER_PRIMITIVE rmesa->radeon.swtcl.render_primitive
495 #undef TAG
496 #define TAG(x) x
497 #include "tnl_dd/t_dd_unfilled.h"
498 #undef IND
499
500
501 /***********************************************************************
502 * Generate GL render functions *
503 ***********************************************************************/
504
505
506 #define IND (0)
507 #define TAG(x) x
508 #include "tnl_dd/t_dd_tritmp.h"
509
510 #define IND (R200_TWOSIDE_BIT)
511 #define TAG(x) x##_twoside
512 #include "tnl_dd/t_dd_tritmp.h"
513
514 #define IND (R200_UNFILLED_BIT)
515 #define TAG(x) x##_unfilled
516 #include "tnl_dd/t_dd_tritmp.h"
517
518 #define IND (R200_TWOSIDE_BIT|R200_UNFILLED_BIT)
519 #define TAG(x) x##_twoside_unfilled
520 #include "tnl_dd/t_dd_tritmp.h"
521
522
523 static void init_rast_tab( void )
524 {
525 init();
526 init_twoside();
527 init_unfilled();
528 init_twoside_unfilled();
529 }
530
531 /**********************************************************************/
532 /* Render unclipped begin/end objects */
533 /**********************************************************************/
534
535 #define RENDER_POINTS( start, count ) \
536 for ( ; start < count ; start++) \
537 r200_point( rmesa, VERT(start) )
538 #define RENDER_LINE( v0, v1 ) \
539 r200_line( rmesa, VERT(v0), VERT(v1) )
540 #define RENDER_TRI( v0, v1, v2 ) \
541 r200_triangle( rmesa, VERT(v0), VERT(v1), VERT(v2) )
542 #define RENDER_QUAD( v0, v1, v2, v3 ) \
543 r200_quad( rmesa, VERT(v0), VERT(v1), VERT(v2), VERT(v3) )
544 #define INIT(x) do { \
545 r200RenderPrimitive( ctx, x ); \
546 } while (0)
547 #undef LOCAL_VARS
548 #define LOCAL_VARS \
549 r200ContextPtr rmesa = R200_CONTEXT(ctx); \
550 const GLuint vertsize = rmesa->radeon.swtcl.vertex_size; \
551 const char *r200verts = (char *)rmesa->radeon.swtcl.verts; \
552 const GLuint * const elt = TNL_CONTEXT(ctx)->vb.Elts; \
553 const GLboolean stipple = ctx->Line.StippleFlag; \
554 (void) elt; (void) stipple;
555 #define RESET_STIPPLE if ( stipple ) r200ResetLineStipple( ctx );
556 #define RESET_OCCLUSION
557 #define PRESERVE_VB_DEFS
558 #define ELT(x) (x)
559 #define TAG(x) r200_##x##_verts
560 #include "tnl/t_vb_rendertmp.h"
561 #undef ELT
562 #undef TAG
563 #define TAG(x) r200_##x##_elts
564 #define ELT(x) elt[x]
565 #include "tnl/t_vb_rendertmp.h"
566
567
568
569 /**********************************************************************/
570 /* Choose render functions */
571 /**********************************************************************/
572
573 void r200ChooseRenderState( GLcontext *ctx )
574 {
575 TNLcontext *tnl = TNL_CONTEXT(ctx);
576 r200ContextPtr rmesa = R200_CONTEXT(ctx);
577 GLuint index = 0;
578 GLuint flags = ctx->_TriangleCaps;
579
580 if (!rmesa->radeon.TclFallback || rmesa->radeon.Fallback)
581 return;
582
583 if (flags & DD_TRI_LIGHT_TWOSIDE) index |= R200_TWOSIDE_BIT;
584 if (flags & DD_TRI_UNFILLED) index |= R200_UNFILLED_BIT;
585
586 if (index != rmesa->radeon.swtcl.RenderIndex) {
587 tnl->Driver.Render.Points = rast_tab[index].points;
588 tnl->Driver.Render.Line = rast_tab[index].line;
589 tnl->Driver.Render.ClippedLine = rast_tab[index].line;
590 tnl->Driver.Render.Triangle = rast_tab[index].triangle;
591 tnl->Driver.Render.Quad = rast_tab[index].quad;
592
593 if (index == 0) {
594 tnl->Driver.Render.PrimTabVerts = r200_render_tab_verts;
595 tnl->Driver.Render.PrimTabElts = r200_render_tab_elts;
596 tnl->Driver.Render.ClippedPolygon = r200_fast_clipped_poly;
597 } else {
598 tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts;
599 tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts;
600 tnl->Driver.Render.ClippedPolygon = _tnl_RenderClippedPolygon;
601 }
602
603 rmesa->radeon.swtcl.RenderIndex = index;
604 }
605 }
606
607
608 /**********************************************************************/
609 /* High level hooks for t_vb_render.c */
610 /**********************************************************************/
611
612
613 static void r200RasterPrimitive( GLcontext *ctx, GLuint hwprim )
614 {
615 r200ContextPtr rmesa = R200_CONTEXT(ctx);
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( GLcontext *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( GLcontext *ctx )
643 {
644 }
645
646 static void r200ResetLineStipple( GLcontext *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( GLcontext *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 RENDERINPUTS_ZERO( rmesa->radeon.tnl_index_bitset );
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( GLcontext *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 LOCK_HARDWARE( &rmesa->radeon );
853 UNLOCK_HARDWARE( &rmesa->radeon );
854 h = radeon_get_drawable(&rmesa->radeon)->h + radeon_get_drawable(&rmesa->radeon)->y;
855 px += radeon_get_drawable(&rmesa->radeon)->x;
856
857 /* Clipping handled by existing mechansims in r200_ioctl.c?
858 */
859 for (row=0; row<height; row++) {
860 const GLubyte *src = (const GLubyte *)
861 _mesa_image_address2d(unpack, bitmap, width, height,
862 GL_COLOR_INDEX, GL_BITMAP, row, 0 );
863
864 if (unpack->LsbFirst) {
865 /* Lsb first */
866 GLubyte mask = 1U << (unpack->SkipPixels & 0x7);
867 for (col=0; col<width; col++) {
868 if (*src & mask) {
869 vert.tv.x = px+col;
870 vert.tv.y = h - (py+row) - 1;
871 r200_point( rmesa, &vert );
872 }
873 src += (mask >> 7);
874 mask = ((mask << 1) & 0xff) | (mask >> 7);
875 }
876
877 /* get ready for next row */
878 if (mask != 1)
879 src++;
880 }
881 else {
882 /* Msb first */
883 GLubyte mask = 128U >> (unpack->SkipPixels & 0x7);
884 for (col=0; col<width; col++) {
885 if (*src & mask) {
886 vert.tv.x = px+col;
887 vert.tv.y = h - (py+row) - 1;
888 r200_point( rmesa, &vert );
889 }
890 src += mask & 1;
891 mask = ((mask << 7) & 0xff) | (mask >> 1);
892 }
893 /* get ready for next row */
894 if (mask != 128)
895 src++;
896 }
897 }
898
899 /* Fire outstanding vertices, restore state
900 */
901 R200_STATECHANGE( rmesa, vte );
902 rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL] = orig_vte;
903
904 /* Unfallback
905 */
906 TCL_FALLBACK( ctx, R200_TCL_FALLBACK_BITMAP, 0 );
907
908 /* Need to restore vertexformat?
909 */
910 if (rmesa->radeon.TclFallback)
911 r200ChooseVertexState( ctx );
912 }
913
914
915
916 /**********************************************************************/
917 /* Initialization. */
918 /**********************************************************************/
919
920 void r200InitSwtcl( GLcontext *ctx )
921 {
922 TNLcontext *tnl = TNL_CONTEXT(ctx);
923 r200ContextPtr rmesa = R200_CONTEXT(ctx);
924 static int firsttime = 1;
925
926 if (firsttime) {
927 init_rast_tab();
928 firsttime = 0;
929 }
930 rmesa->radeon.swtcl.emit_prediction = 0;
931
932 tnl->Driver.Render.Start = r200RenderStart;
933 tnl->Driver.Render.Finish = r200RenderFinish;
934 tnl->Driver.Render.PrimitiveNotify = r200RenderPrimitive;
935 tnl->Driver.Render.ResetLineStipple = r200ResetLineStipple;
936 tnl->Driver.Render.BuildVertices = _tnl_build_vertices;
937 tnl->Driver.Render.CopyPV = _tnl_copy_pv;
938 tnl->Driver.Render.Interp = _tnl_interp;
939
940 /* FIXME: what are these numbers? */
941 _tnl_init_vertices( ctx, ctx->Const.MaxArrayLockSize + 12,
942 36 * sizeof(GLfloat) );
943
944 rmesa->radeon.swtcl.verts = (GLubyte *)tnl->clipspace.vertex_buf;
945 rmesa->radeon.swtcl.RenderIndex = ~0;
946 rmesa->radeon.swtcl.render_primitive = GL_TRIANGLES;
947 rmesa->radeon.swtcl.hw_primitive = 0;
948 }
949