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