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