projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
r200: Make swtcl use state size prediction for flush.
[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
205 static void r200RenderStart( GLcontext *ctx )
206 {
207 r200SetVertexFormat( ctx );
208 }
209
210
211 /**
212 * Set vertex state for SW TCL. The primary purpose of this function is to
213 * determine in advance whether or not the hardware can / should do the
214 * projection divide or Mesa should do it.
215 */
216 void r200ChooseVertexState( GLcontext *ctx )
217 {
218 r200ContextPtr rmesa = R200_CONTEXT( ctx );
219 TNLcontext *tnl = TNL_CONTEXT(ctx);
220 GLuint vte;
221 GLuint vap;
222
223 /* We must ensure that we don't do _tnl_need_projected_coords while in a
224 * rasterization fallback. As this function will be called again when we
225 * leave a rasterization fallback, we can just skip it for now.
226 */
227 if (rmesa->radeon.Fallback != 0)
228 return;
229
230 vte = rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL];
231 vap = rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL];
232
233 /* HW perspective divide is a win, but tiny vertex formats are a
234 * bigger one.
235 */
236 if (!RENDERINPUTS_TEST_RANGE( tnl->render_inputs_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX )
237 || (ctx->_TriangleCaps & (DD_TRI_LIGHT_TWOSIDE|DD_TRI_UNFILLED))) {
238 rmesa->swtcl.needproj = GL_TRUE;
239 vte |= R200_VTX_XY_FMT | R200_VTX_Z_FMT;
240 vte &= ~R200_VTX_W0_FMT;
241 if (RENDERINPUTS_TEST_RANGE( tnl->render_inputs_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX )) {
242 vap &= ~R200_VAP_FORCE_W_TO_ONE;
243 }
244 else {
245 vap |= R200_VAP_FORCE_W_TO_ONE;
246 }
247 }
248 else {
249 rmesa->swtcl.needproj = GL_FALSE;
250 vte &= ~(R200_VTX_XY_FMT | R200_VTX_Z_FMT);
251 vte |= R200_VTX_W0_FMT;
252 vap &= ~R200_VAP_FORCE_W_TO_ONE;
253 }
254
255 _tnl_need_projected_coords( ctx, rmesa->swtcl.needproj );
256
257 if (vte != rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL]) {
258 R200_STATECHANGE( rmesa, vte );
259 rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL] = vte;
260 }
261
262 if (vap != rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL]) {
263 R200_STATECHANGE( rmesa, vap );
264 rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL] = vap;
265 }
266 }
267
268 void r200_swtcl_flush(GLcontext *ctx, uint32_t current_offset)
269 {
270 r200ContextPtr rmesa = R200_CONTEXT(ctx);
271 rcommonEnsureCmdBufSpace(&rmesa->radeon,
272 radeonCountEmitSize(&rmesa->radeon) + (12*sizeof(int)),
273 __FUNCTION__);
274
275
276 radeonEmitState(&rmesa->radeon);
277 r200EmitVertexAOS( rmesa,
278 rmesa->radeon.swtcl.vertex_size,
279 first_elem(&rmesa->radeon.dma.reserved)->bo,
280 current_offset);
281
282
283 r200EmitVbufPrim( rmesa,
284 rmesa->radeon.swtcl.hw_primitive,
285 rmesa->radeon.swtcl.numverts);
286
287 }
288
289 /**************************************************************************/
290
291
292 static INLINE GLuint reduced_hw_prim( GLcontext *ctx, GLuint prim)
293 {
294 switch (prim) {
295 case GL_POINTS:
296 return (ctx->Point.PointSprite ||
297 ((ctx->_TriangleCaps & (DD_POINT_SIZE | DD_POINT_ATTEN)) &&
298 !(ctx->_TriangleCaps & (DD_POINT_SMOOTH)))) ?
299 R200_VF_PRIM_POINT_SPRITES : R200_VF_PRIM_POINTS;
300 case GL_LINES:
301 /* fallthrough */
302 case GL_LINE_LOOP:
303 /* fallthrough */
304 case GL_LINE_STRIP:
305 return R200_VF_PRIM_LINES;
306 default:
307 /* all others reduced to triangles */
308 return R200_VF_PRIM_TRIANGLES;
309 }
310 }
311
312
313 static void r200RasterPrimitive( GLcontext *ctx, GLuint hwprim );
314 static void r200RenderPrimitive( GLcontext *ctx, GLenum prim );
315 static void r200ResetLineStipple( GLcontext *ctx );
316
317 /***********************************************************************
318 * Emit primitives as inline vertices *
319 ***********************************************************************/
320
321 #define HAVE_POINTS 1
322 #define HAVE_LINES 1
323 #define HAVE_LINE_STRIPS 1
324 #define HAVE_TRIANGLES 1
325 #define HAVE_TRI_STRIPS 1
326 #define HAVE_TRI_STRIP_1 0
327 #define HAVE_TRI_FANS 1
328 #define HAVE_QUADS 0
329 #define HAVE_QUAD_STRIPS 0
330 #define HAVE_POLYGONS 1
331 #define HAVE_ELTS 0
332
333 #undef LOCAL_VARS
334 #undef ALLOC_VERTS
335 #define CTX_ARG r200ContextPtr rmesa
336 #define GET_VERTEX_DWORDS() rmesa->radeon.swtcl.vertex_size
337 #define ALLOC_VERTS( n, size ) rcommonAllocDmaLowVerts( &rmesa->radeon, n, size * 4 )
338 #define LOCAL_VARS \
339 r200ContextPtr rmesa = R200_CONTEXT(ctx); \
340 const char *r200verts = (char *)rmesa->radeon.swtcl.verts;
341 #define VERT(x) (radeonVertex *)(r200verts + ((x) * vertsize * sizeof(int)))
342 #define VERTEX radeonVertex
343 #define DO_DEBUG_VERTS (1 && (R200_DEBUG & DEBUG_VERTS))
344
345 #undef TAG
346 #define TAG(x) r200_##x
347 #include "tnl_dd/t_dd_triemit.h"
348
349
350 /***********************************************************************
351 * Macros for t_dd_tritmp.h to draw basic primitives *
352 ***********************************************************************/
353
354 #define QUAD( a, b, c, d ) r200_quad( rmesa, a, b, c, d )
355 #define TRI( a, b, c ) r200_triangle( rmesa, a, b, c )
356 #define LINE( a, b ) r200_line( rmesa, a, b )
357 #define POINT( a ) r200_point( rmesa, a )
358
359 /***********************************************************************
360 * Build render functions from dd templates *
361 ***********************************************************************/
362
363 #define R200_TWOSIDE_BIT 0x01
364 #define R200_UNFILLED_BIT 0x02
365 #define R200_MAX_TRIFUNC 0x04
366
367
368 static struct {
369 tnl_points_func points;
370 tnl_line_func line;
371 tnl_triangle_func triangle;
372 tnl_quad_func quad;
373 } rast_tab[R200_MAX_TRIFUNC];
374
375
376 #define DO_FALLBACK 0
377 #define DO_UNFILLED (IND & R200_UNFILLED_BIT)
378 #define DO_TWOSIDE (IND & R200_TWOSIDE_BIT)
379 #define DO_FLAT 0
380 #define DO_OFFSET 0
381 #define DO_TRI 1
382 #define DO_QUAD 1
383 #define DO_LINE 1
384 #define DO_POINTS 1
385 #define DO_FULL_QUAD 1
386
387 #define HAVE_RGBA 1
388 #define HAVE_SPEC 1
389 #define HAVE_BACK_COLORS 0
390 #define HAVE_HW_FLATSHADE 1
391 #define TAB rast_tab
392
393 #define DEPTH_SCALE 1.0
394 #define UNFILLED_TRI unfilled_tri
395 #define UNFILLED_QUAD unfilled_quad
396 #define VERT_X(_v) _v->v.x
397 #define VERT_Y(_v) _v->v.y
398 #define VERT_Z(_v) _v->v.z
399 #define AREA_IS_CCW( a ) (a < 0)
400 #define GET_VERTEX(e) (rmesa->radeon.swtcl.verts + (e*rmesa->radeon.swtcl.vertex_size*sizeof(int)))
401
402 #define VERT_SET_RGBA( v, c ) \
403 do { \
404 radeon_color_t *color = (radeon_color_t *)&((v)->ui[coloroffset]); \
405 UNCLAMPED_FLOAT_TO_UBYTE(color->red, (c)[0]); \
406 UNCLAMPED_FLOAT_TO_UBYTE(color->green, (c)[1]); \
407 UNCLAMPED_FLOAT_TO_UBYTE(color->blue, (c)[2]); \
408 UNCLAMPED_FLOAT_TO_UBYTE(color->alpha, (c)[3]); \
409 } while (0)
410
411 #define VERT_COPY_RGBA( v0, v1 ) v0->ui[coloroffset] = v1->ui[coloroffset]
412
413 #define VERT_SET_SPEC( v, c ) \
414 do { \
415 if (specoffset) { \
416 radeon_color_t *spec = (radeon_color_t *)&((v)->ui[specoffset]); \
417 UNCLAMPED_FLOAT_TO_UBYTE(spec->red, (c)[0]); \
418 UNCLAMPED_FLOAT_TO_UBYTE(spec->green, (c)[1]); \
419 UNCLAMPED_FLOAT_TO_UBYTE(spec->blue, (c)[2]); \
420 } \
421 } while (0)
422 #define VERT_COPY_SPEC( v0, v1 ) \
423 do { \
424 if (specoffset) { \
425 radeon_color_t *spec0 = (radeon_color_t *)&((v0)->ui[specoffset]); \
426 radeon_color_t *spec1 = (radeon_color_t *)&((v1)->ui[specoffset]); \
427 spec0->red = spec1->red; \
428 spec0->green = spec1->green; \
429 spec0->blue = spec1->blue; \
430 } \
431 } while (0)
432
433 /* These don't need LE32_TO_CPU() as they used to save and restore
434 * colors which are already in the correct format.
435 */
436 #define VERT_SAVE_RGBA( idx ) color[idx] = v[idx]->ui[coloroffset]
437 #define VERT_RESTORE_RGBA( idx ) v[idx]->ui[coloroffset] = color[idx]
438 #define VERT_SAVE_SPEC( idx ) if (specoffset) spec[idx] = v[idx]->ui[specoffset]
439 #define VERT_RESTORE_SPEC( idx ) if (specoffset) v[idx]->ui[specoffset] = spec[idx]
440
441 #undef LOCAL_VARS
442 #undef TAG
443 #undef INIT
444
445 #define LOCAL_VARS(n) \
446 r200ContextPtr rmesa = R200_CONTEXT(ctx); \
447 GLuint color[n], spec[n]; \
448 GLuint coloroffset = rmesa->swtcl.coloroffset; \
449 GLuint specoffset = rmesa->swtcl.specoffset; \
450 (void) color; (void) spec; (void) coloroffset; (void) specoffset;
451
452 /***********************************************************************
453 * Helpers for rendering unfilled primitives *
454 ***********************************************************************/
455
456 #define RASTERIZE(x) r200RasterPrimitive( ctx, reduced_hw_prim(ctx, x) )
457 #define RENDER_PRIMITIVE rmesa->radeon.swtcl.render_primitive
458 #undef TAG
459 #define TAG(x) x
460 #include "tnl_dd/t_dd_unfilled.h"
461 #undef IND
462
463
464 /***********************************************************************
465 * Generate GL render functions *
466 ***********************************************************************/
467
468
469 #define IND (0)
470 #define TAG(x) x
471 #include "tnl_dd/t_dd_tritmp.h"
472
473 #define IND (R200_TWOSIDE_BIT)
474 #define TAG(x) x##_twoside
475 #include "tnl_dd/t_dd_tritmp.h"
476
477 #define IND (R200_UNFILLED_BIT)
478 #define TAG(x) x##_unfilled
479 #include "tnl_dd/t_dd_tritmp.h"
480
481 #define IND (R200_TWOSIDE_BIT|R200_UNFILLED_BIT)
482 #define TAG(x) x##_twoside_unfilled
483 #include "tnl_dd/t_dd_tritmp.h"
484
485
486 static void init_rast_tab( void )
487 {
488 init();
489 init_twoside();
490 init_unfilled();
491 init_twoside_unfilled();
492 }
493
494 /**********************************************************************/
495 /* Render unclipped begin/end objects */
496 /**********************************************************************/
497
498 #define RENDER_POINTS( start, count ) \
499 for ( ; start < count ; start++) \
500 r200_point( rmesa, VERT(start) )
501 #define RENDER_LINE( v0, v1 ) \
502 r200_line( rmesa, VERT(v0), VERT(v1) )
503 #define RENDER_TRI( v0, v1, v2 ) \
504 r200_triangle( rmesa, VERT(v0), VERT(v1), VERT(v2) )
505 #define RENDER_QUAD( v0, v1, v2, v3 ) \
506 r200_quad( rmesa, VERT(v0), VERT(v1), VERT(v2), VERT(v3) )
507 #define INIT(x) do { \
508 r200RenderPrimitive( ctx, x ); \
509 } while (0)
510 #undef LOCAL_VARS
511 #define LOCAL_VARS \
512 r200ContextPtr rmesa = R200_CONTEXT(ctx); \
513 const GLuint vertsize = rmesa->radeon.swtcl.vertex_size; \
514 const char *r200verts = (char *)rmesa->radeon.swtcl.verts; \
515 const GLuint * const elt = TNL_CONTEXT(ctx)->vb.Elts; \
516 const GLboolean stipple = ctx->Line.StippleFlag; \
517 (void) elt; (void) stipple;
518 #define RESET_STIPPLE if ( stipple ) r200ResetLineStipple( ctx );
519 #define RESET_OCCLUSION
520 #define PRESERVE_VB_DEFS
521 #define ELT(x) (x)
522 #define TAG(x) r200_##x##_verts
523 #include "tnl/t_vb_rendertmp.h"
524 #undef ELT
525 #undef TAG
526 #define TAG(x) r200_##x##_elts
527 #define ELT(x) elt[x]
528 #include "tnl/t_vb_rendertmp.h"
529
530
531
532 /**********************************************************************/
533 /* Choose render functions */
534 /**********************************************************************/
535
536 void r200ChooseRenderState( GLcontext *ctx )
537 {
538 TNLcontext *tnl = TNL_CONTEXT(ctx);
539 r200ContextPtr rmesa = R200_CONTEXT(ctx);
540 GLuint index = 0;
541 GLuint flags = ctx->_TriangleCaps;
542
543 if (!rmesa->radeon.TclFallback || rmesa->radeon.Fallback)
544 return;
545
546 if (flags & DD_TRI_LIGHT_TWOSIDE) index |= R200_TWOSIDE_BIT;
547 if (flags & DD_TRI_UNFILLED) index |= R200_UNFILLED_BIT;
548
549 if (index != rmesa->radeon.swtcl.RenderIndex) {
550 tnl->Driver.Render.Points = rast_tab[index].points;
551 tnl->Driver.Render.Line = rast_tab[index].line;
552 tnl->Driver.Render.ClippedLine = rast_tab[index].line;
553 tnl->Driver.Render.Triangle = rast_tab[index].triangle;
554 tnl->Driver.Render.Quad = rast_tab[index].quad;
555
556 if (index == 0) {
557 tnl->Driver.Render.PrimTabVerts = r200_render_tab_verts;
558 tnl->Driver.Render.PrimTabElts = r200_render_tab_elts;
559 tnl->Driver.Render.ClippedPolygon = r200_fast_clipped_poly;
560 } else {
561 tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts;
562 tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts;
563 tnl->Driver.Render.ClippedPolygon = _tnl_RenderClippedPolygon;
564 }
565
566 rmesa->radeon.swtcl.RenderIndex = index;
567 }
568 }
569
570
571 /**********************************************************************/
572 /* High level hooks for t_vb_render.c */
573 /**********************************************************************/
574
575
576 static void r200RasterPrimitive( GLcontext *ctx, GLuint hwprim )
577 {
578 r200ContextPtr rmesa = R200_CONTEXT(ctx);
579
580 if (rmesa->radeon.swtcl.hw_primitive != hwprim) {
581 /* need to disable perspective-correct texturing for point sprites */
582 if ((hwprim & 0xf) == R200_VF_PRIM_POINT_SPRITES && ctx->Point.PointSprite) {
583 if (rmesa->hw.set.cmd[SET_RE_CNTL] & R200_PERSPECTIVE_ENABLE) {
584 R200_STATECHANGE( rmesa, set );
585 rmesa->hw.set.cmd[SET_RE_CNTL] &= ~R200_PERSPECTIVE_ENABLE;
586 }
587 }
588 else if (!(rmesa->hw.set.cmd[SET_RE_CNTL] & R200_PERSPECTIVE_ENABLE)) {
589 R200_STATECHANGE( rmesa, set );
590 rmesa->hw.set.cmd[SET_RE_CNTL] |= R200_PERSPECTIVE_ENABLE;
591 }
592 R200_NEWPRIM( rmesa );
593 rmesa->radeon.swtcl.hw_primitive = hwprim;
594 }
595 }
596
597 static void r200RenderPrimitive( GLcontext *ctx, GLenum prim )
598 {
599 r200ContextPtr rmesa = R200_CONTEXT(ctx);
600 rmesa->radeon.swtcl.render_primitive = prim;
601 if (prim < GL_TRIANGLES || !(ctx->_TriangleCaps & DD_TRI_UNFILLED))
602 r200RasterPrimitive( ctx, reduced_hw_prim(ctx, prim) );
603 }
604
605 static void r200RenderFinish( GLcontext *ctx )
606 {
607 }
608
609 static void r200ResetLineStipple( GLcontext *ctx )
610 {
611 r200ContextPtr rmesa = R200_CONTEXT(ctx);
612 R200_STATECHANGE( rmesa, lin );
613 }
614
615
616 /**********************************************************************/
617 /* Transition to/from hardware rasterization. */
618 /**********************************************************************/
619
620 static const char * const fallbackStrings[] = {
621 "Texture mode",
622 "glDrawBuffer(GL_FRONT_AND_BACK)",
623 "glEnable(GL_STENCIL) without hw stencil buffer",
624 "glRenderMode(selection or feedback)",
625 "R200_NO_RAST",
626 "Mixing GL_CLAMP_TO_BORDER and GL_CLAMP (or GL_MIRROR_CLAMP_ATI)"
627 };
628
629
630 static const char *getFallbackString(GLuint bit)
631 {
632 int i = 0;
633 while (bit > 1) {
634 i++;
635 bit >>= 1;
636 }
637 return fallbackStrings[i];
638 }
639
640
641 void r200Fallback( GLcontext *ctx, GLuint bit, GLboolean mode )
642 {
643 r200ContextPtr rmesa = R200_CONTEXT(ctx);
644 TNLcontext *tnl = TNL_CONTEXT(ctx);
645 GLuint oldfallback = rmesa->radeon.Fallback;
646
647 if (mode) {
648 rmesa->radeon.Fallback |= bit;
649 if (oldfallback == 0) {
650 radeon_firevertices(&rmesa->radeon);
651 TCL_FALLBACK( ctx, R200_TCL_FALLBACK_RASTER, GL_TRUE );
652 _swsetup_Wakeup( ctx );
653 rmesa->radeon.swtcl.RenderIndex = ~0;
654 if (R200_DEBUG & DEBUG_FALLBACKS) {
655 fprintf(stderr, "R200 begin rasterization fallback: 0x%x %s\n",
656 bit, getFallbackString(bit));
657 }
658 }
659 }
660 else {
661 rmesa->radeon.Fallback &= ~bit;
662 if (oldfallback == bit) {
663
664 _swrast_flush( ctx );
665 tnl->Driver.Render.Start = r200RenderStart;
666 tnl->Driver.Render.PrimitiveNotify = r200RenderPrimitive;
667 tnl->Driver.Render.Finish = r200RenderFinish;
668
669 tnl->Driver.Render.BuildVertices = _tnl_build_vertices;
670 tnl->Driver.Render.CopyPV = _tnl_copy_pv;
671 tnl->Driver.Render.Interp = _tnl_interp;
672
673 tnl->Driver.Render.ResetLineStipple = r200ResetLineStipple;
674 TCL_FALLBACK( ctx, R200_TCL_FALLBACK_RASTER, GL_FALSE );
675 if (rmesa->radeon.TclFallback) {
676 /* These are already done if rmesa->radeon.TclFallback goes to
677 * zero above. But not if it doesn't (R200_NO_TCL for
678 * example?)
679 */
680 _tnl_invalidate_vertex_state( ctx, ~0 );
681 _tnl_invalidate_vertices( ctx, ~0 );
682 RENDERINPUTS_ZERO( rmesa->radeon.tnl_index_bitset );
683 r200ChooseVertexState( ctx );
684 r200ChooseRenderState( ctx );
685 }
686 if (R200_DEBUG & DEBUG_FALLBACKS) {
687 fprintf(stderr, "R200 end rasterization fallback: 0x%x %s\n",
688 bit, getFallbackString(bit));
689 }
690 }
691 }
692 }
693
694
695
696
697 /**
698 * Cope with depth operations by drawing individual pixels as points.
699 *
700 * \todo
701 * The way the vertex state is set in this routine is hokey. It seems to
702 * work, but it's very hackish. This whole routine is pretty hackish. If
703 * the bitmap is small enough, it seems like it would be faster to copy it
704 * to AGP memory and use it as a non-power-of-two texture (i.e.,
705 * NV_texture_rectangle).
706 */
707 void
708 r200PointsBitmap( GLcontext *ctx, GLint px, GLint py,
709 GLsizei width, GLsizei height,
710 const struct gl_pixelstore_attrib *unpack,
711 const GLubyte *bitmap )
712 {
713 r200ContextPtr rmesa = R200_CONTEXT(ctx);
714 const GLfloat *rc = ctx->Current.RasterColor;
715 GLint row, col;
716 radeonVertex vert;
717 GLuint orig_vte;
718 GLuint h;
719
720
721 /* Turn off tcl.
722 */
723 TCL_FALLBACK( ctx, R200_TCL_FALLBACK_BITMAP, 1 );
724
725 /* Choose tiny vertex format
726 */
727 {
728 const GLuint fmt_0 = R200_VTX_XY | R200_VTX_Z0 | R200_VTX_W0
729 | (R200_VTX_PK_RGBA << R200_VTX_COLOR_0_SHIFT);
730 const GLuint fmt_1 = 0;
731 GLuint vte = rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL];
732 GLuint vap = rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL];
733
734 vte &= ~(R200_VTX_XY_FMT | R200_VTX_Z_FMT);
735 vte |= R200_VTX_W0_FMT;
736 vap &= ~R200_VAP_FORCE_W_TO_ONE;
737
738 rmesa->radeon.swtcl.vertex_size = 5;
739
740 if ( (rmesa->hw.vtx.cmd[VTX_VTXFMT_0] != fmt_0)
741 || (rmesa->hw.vtx.cmd[VTX_VTXFMT_1] != fmt_1) ) {
742 R200_NEWPRIM(rmesa);
743 R200_STATECHANGE( rmesa, vtx );
744 rmesa->hw.vtx.cmd[VTX_VTXFMT_0] = fmt_0;
745 rmesa->hw.vtx.cmd[VTX_VTXFMT_1] = fmt_1;
746 }
747
748 if (vte != rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL]) {
749 R200_STATECHANGE( rmesa, vte );
750 rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL] = vte;
751 }
752
753 if (vap != rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL]) {
754 R200_STATECHANGE( rmesa, vap );
755 rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL] = vap;
756 }
757 }
758
759 /* Ready for point primitives:
760 */
761 r200RenderPrimitive( ctx, GL_POINTS );
762
763 /* Turn off the hw viewport transformation:
764 */
765 R200_STATECHANGE( rmesa, vte );
766 orig_vte = rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL];
767 rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL] &= ~(R200_VPORT_X_SCALE_ENA |
768 R200_VPORT_Y_SCALE_ENA |
769 R200_VPORT_Z_SCALE_ENA |
770 R200_VPORT_X_OFFSET_ENA |
771 R200_VPORT_Y_OFFSET_ENA |
772 R200_VPORT_Z_OFFSET_ENA);
773
774 /* Turn off other stuff: Stipple?, texture?, blending?, etc.
775 */
776
777
778 /* Populate the vertex
779 *
780 * Incorporate FOG into RGBA
781 */
782 if (ctx->Fog.Enabled) {
783 const GLfloat *fc = ctx->Fog.Color;
784 GLfloat color[4];
785 GLfloat f;
786
787 if (ctx->Fog.FogCoordinateSource == GL_FOG_COORDINATE_EXT)
788 f = _swrast_z_to_fogfactor(ctx, ctx->Current.Attrib[VERT_ATTRIB_FOG][0]);
789 else
790 f = _swrast_z_to_fogfactor(ctx, ctx->Current.RasterDistance);
791
792 color[0] = f * rc[0] + (1.F - f) * fc[0];
793 color[1] = f * rc[1] + (1.F - f) * fc[1];
794 color[2] = f * rc[2] + (1.F - f) * fc[2];
795 color[3] = rc[3];
796
797 UNCLAMPED_FLOAT_TO_CHAN(vert.tv.color.red, color[0]);
798 UNCLAMPED_FLOAT_TO_CHAN(vert.tv.color.green, color[1]);
799 UNCLAMPED_FLOAT_TO_CHAN(vert.tv.color.blue, color[2]);
800 UNCLAMPED_FLOAT_TO_CHAN(vert.tv.color.alpha, color[3]);
801 }
802 else {
803 UNCLAMPED_FLOAT_TO_CHAN(vert.tv.color.red, rc[0]);
804 UNCLAMPED_FLOAT_TO_CHAN(vert.tv.color.green, rc[1]);
805 UNCLAMPED_FLOAT_TO_CHAN(vert.tv.color.blue, rc[2]);
806 UNCLAMPED_FLOAT_TO_CHAN(vert.tv.color.alpha, rc[3]);
807 }
808
809
810 vert.tv.z = ctx->Current.RasterPos[2];
811
812
813 /* Update window height
814 */
815 LOCK_HARDWARE( &rmesa->radeon );
816 UNLOCK_HARDWARE( &rmesa->radeon );
817 h = radeon_get_drawable(&rmesa->radeon)->h + radeon_get_drawable(&rmesa->radeon)->y;
818 px += radeon_get_drawable(&rmesa->radeon)->x;
819
820 /* Clipping handled by existing mechansims in r200_ioctl.c?
821 */
822 for (row=0; row<height; row++) {
823 const GLubyte *src = (const GLubyte *)
824 _mesa_image_address2d(unpack, bitmap, width, height,
825 GL_COLOR_INDEX, GL_BITMAP, row, 0 );
826
827 if (unpack->LsbFirst) {
828 /* Lsb first */
829 GLubyte mask = 1U << (unpack->SkipPixels & 0x7);
830 for (col=0; col<width; col++) {
831 if (*src & mask) {
832 vert.tv.x = px+col;
833 vert.tv.y = h - (py+row) - 1;
834 r200_point( rmesa, &vert );
835 }
836 src += (mask >> 7);
837 mask = ((mask << 1) & 0xff) | (mask >> 7);
838 }
839
840 /* get ready for next row */
841 if (mask != 1)
842 src++;
843 }
844 else {
845 /* Msb first */
846 GLubyte mask = 128U >> (unpack->SkipPixels & 0x7);
847 for (col=0; col<width; col++) {
848 if (*src & mask) {
849 vert.tv.x = px+col;
850 vert.tv.y = h - (py+row) - 1;
851 r200_point( rmesa, &vert );
852 }
853 src += mask & 1;
854 mask = ((mask << 7) & 0xff) | (mask >> 1);
855 }
856 /* get ready for next row */
857 if (mask != 128)
858 src++;
859 }
860 }
861
862 /* Fire outstanding vertices, restore state
863 */
864 R200_STATECHANGE( rmesa, vte );
865 rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL] = orig_vte;
866
867 /* Unfallback
868 */
869 TCL_FALLBACK( ctx, R200_TCL_FALLBACK_BITMAP, 0 );
870
871 /* Need to restore vertexformat?
872 */
873 if (rmesa->radeon.TclFallback)
874 r200ChooseVertexState( ctx );
875 }
876
877
878
879 /**********************************************************************/
880 /* Initialization. */
881 /**********************************************************************/
882
883 void r200InitSwtcl( GLcontext *ctx )
884 {
885 TNLcontext *tnl = TNL_CONTEXT(ctx);
886 r200ContextPtr rmesa = R200_CONTEXT(ctx);
887 static int firsttime = 1;
888
889 if (firsttime) {
890 init_rast_tab();
891 firsttime = 0;
892 }
893
894 tnl->Driver.Render.Start = r200RenderStart;
895 tnl->Driver.Render.Finish = r200RenderFinish;
896 tnl->Driver.Render.PrimitiveNotify = r200RenderPrimitive;
897 tnl->Driver.Render.ResetLineStipple = r200ResetLineStipple;
898 tnl->Driver.Render.BuildVertices = _tnl_build_vertices;
899 tnl->Driver.Render.CopyPV = _tnl_copy_pv;
900 tnl->Driver.Render.Interp = _tnl_interp;
901
902 /* FIXME: what are these numbers? */
903 _tnl_init_vertices( ctx, ctx->Const.MaxArrayLockSize + 12,
904 36 * sizeof(GLfloat) );
905
906 rmesa->radeon.swtcl.verts = (GLubyte *)tnl->clipspace.vertex_buf;
907 rmesa->radeon.swtcl.RenderIndex = ~0;
908 rmesa->radeon.swtcl.render_primitive = GL_TRIANGLES;
909 rmesa->radeon.swtcl.hw_primitive = 0;
910 }
911