1 /**************************************************************************
3 Copyright (C) 2007 Dave Airlie
7 Permission is hereby granted, free of charge, to any person obtaining a
8 copy of this software and associated documentation files (the "Software"),
9 to deal in the Software without restriction, including without limitation
10 on the rights to use, copy, modify, merge, publish, distribute, sub
11 license, and/or sell copies of the Software, and to permit persons to whom
12 the Software is furnished to do so, subject to the following conditions:
14 The above copyright notice and this permission notice (including the next
15 paragraph) shall be included in all copies or substantial portions of the
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
21 THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
22 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
23 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
24 USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **************************************************************************/
30 * Dave Airlie <airlied@linux.ie>
31 * Maciej Cencora <m.cencora@gmail.com>
35 #include "tnl/t_pipeline.h"
37 #include "r300_state.h"
38 #include "r300_swtcl.h"
39 #include "r300_emit.h"
42 #define EMIT_ATTR( ATTR, STYLE ) \
44 rmesa->radeon.swtcl.vertex_attrs[rmesa->radeon.swtcl.vertex_attr_count].attrib = (ATTR); \
45 rmesa->radeon.swtcl.vertex_attrs[rmesa->radeon.swtcl.vertex_attr_count].format = (STYLE); \
46 rmesa->radeon.swtcl.vertex_attr_count++; \
49 #define EMIT_PAD( N ) \
51 rmesa->radeon.swtcl.vertex_attrs[rmesa->radeon.swtcl.vertex_attr_count].attrib = 0; \
52 rmesa->radeon.swtcl.vertex_attrs[rmesa->radeon.swtcl.vertex_attr_count].format = EMIT_PAD; \
53 rmesa->radeon.swtcl.vertex_attrs[rmesa->radeon.swtcl.vertex_attr_count].offset = (N); \
54 rmesa->radeon.swtcl.vertex_attr_count++; \
57 #define ADD_ATTR(_attr, _format, _dst_loc, _swizzle, _write_mask) \
59 attrs[num_attrs].attr = (_attr); \
60 attrs[num_attrs].format = (_format); \
61 attrs[num_attrs].dst_loc = (_dst_loc); \
62 attrs[num_attrs].swizzle = (_swizzle); \
63 attrs[num_attrs].write_mask = (_write_mask); \
67 static void r300SwtclVAPSetup(GLcontext
*ctx
, GLuint InputsRead
, GLuint OutputsWritten
, GLuint vap_out_fmt_1
)
69 r300ContextPtr rmesa
= R300_CONTEXT( ctx
);
70 struct vertex_attribute
*attrs
= rmesa
->swtcl
.vert_attrs
;
72 uint32_t *vir0
= &rmesa
->hw
.vir
[0].cmd
[1];
73 uint32_t *vir1
= &rmesa
->hw
.vir
[1].cmd
[1];
75 for (i
= 0; i
< R300_VIR_CMDSIZE
-1; ++i
)
76 vir0
[i
] = vir1
[i
] = 0;
78 for (i
= 0, j
= 0; i
< rmesa
->radeon
.swtcl
.vertex_attr_count
; ++i
) {
80 switch (attrs
[i
].format
) {
82 data_format
= R300_DATA_TYPE_FLOAT_1
;
85 data_format
= R300_DATA_TYPE_FLOAT_2
;
88 data_format
= R300_DATA_TYPE_FLOAT_3
;
91 data_format
= R300_DATA_TYPE_FLOAT_4
;
93 case EMIT_4UB_4F_RGBA
:
94 case EMIT_4UB_4F_ABGR
:
95 data_format
= R300_DATA_TYPE_BYTE
| R300_NORMALIZE
;
98 fprintf(stderr
, "%s: Invalid data format type", __FUNCTION__
);
103 tmp
= data_format
| (attrs
[i
].dst_loc
<< R300_DST_VEC_LOC_SHIFT
);
105 vir0
[j
] = tmp
<< R300_DATA_TYPE_0_SHIFT
;
106 vir1
[j
] = attrs
[i
].swizzle
| (attrs
[i
].write_mask
<< R300_WRITE_ENA_SHIFT
);
108 vir0
[j
] |= tmp
<< R300_DATA_TYPE_1_SHIFT
;
109 vir1
[j
] |= (attrs
[i
].swizzle
| (attrs
[i
].write_mask
<< R300_WRITE_ENA_SHIFT
)) << R300_SWIZZLE1_SHIFT
;
114 reg_count
= (rmesa
->radeon
.swtcl
.vertex_attr_count
+ 1) >> 1;
115 if (rmesa
->radeon
.swtcl
.vertex_attr_count
% 2 != 0) {
116 vir0
[reg_count
-1] |= R300_LAST_VEC
<< R300_DATA_TYPE_0_SHIFT
;
118 vir0
[reg_count
-1] |= R300_LAST_VEC
<< R300_DATA_TYPE_1_SHIFT
;
121 R300_STATECHANGE(rmesa
, vir
[0]);
122 R300_STATECHANGE(rmesa
, vir
[1]);
123 R300_STATECHANGE(rmesa
, vof
);
124 R300_STATECHANGE(rmesa
, vic
);
126 if (rmesa
->radeon
.radeonScreen
->kernel_mm
) {
127 rmesa
->hw
.vir
[0].cmd
[0] &= 0xC000FFFF;
128 rmesa
->hw
.vir
[1].cmd
[0] &= 0xC000FFFF;
129 rmesa
->hw
.vir
[0].cmd
[0] |= (reg_count
& 0x3FFF) << 16;
130 rmesa
->hw
.vir
[1].cmd
[0] |= (reg_count
& 0x3FFF) << 16;
132 ((drm_r300_cmd_header_t
*) rmesa
->hw
.vir
[0].cmd
)->packet0
.count
= reg_count
;
133 ((drm_r300_cmd_header_t
*) rmesa
->hw
.vir
[1].cmd
)->packet0
.count
= reg_count
;
136 rmesa
->hw
.vic
.cmd
[R300_VIC_CNTL_0
] = r300VAPInputCntl0(ctx
, InputsRead
);
137 rmesa
->hw
.vic
.cmd
[R300_VIC_CNTL_1
] = r300VAPInputCntl1(ctx
, InputsRead
);
138 rmesa
->hw
.vof
.cmd
[R300_VOF_CNTL_0
] = r300VAPOutputCntl0(ctx
, OutputsWritten
);
140 * Can't use r300VAPOutputCntl1 function because it assumes
141 * that all texture coords have 4 components and that's the case
142 * for HW TCL path, but not for SW TCL.
144 rmesa
->hw
.vof
.cmd
[R300_VOF_CNTL_1
] = vap_out_fmt_1
;
148 static void r300SetVertexFormat( GLcontext
*ctx
)
150 r300ContextPtr rmesa
= R300_CONTEXT( ctx
);
151 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
152 struct vertex_buffer
*VB
= &tnl
->vb
;
153 int first_free_tex
= 0, vap_out_fmt_1
= 0;
154 GLuint InputsRead
= 0;
155 GLuint OutputsWritten
= 0;
157 struct vertex_attribute
*attrs
= rmesa
->swtcl
.vert_attrs
;
159 rmesa
->swtcl
.coloroffset
= rmesa
->swtcl
.specoffset
= 0;
160 rmesa
->radeon
.swtcl
.vertex_attr_count
= 0;
162 /* We always want non Ndc coords format */
163 VB
->AttribPtr
[VERT_ATTRIB_POS
] = VB
->ClipPtr
;
165 if (RENDERINPUTS_TEST(tnl
->render_inputs_bitset
, _TNL_ATTRIB_POS
)) {
166 InputsRead
|= 1 << VERT_ATTRIB_POS
;
167 OutputsWritten
|= 1 << VERT_RESULT_HPOS
;
168 EMIT_ATTR( _TNL_ATTRIB_POS
, EMIT_4F
);
169 ADD_ATTR(VERT_ATTRIB_POS
, EMIT_4F
, SWTCL_OVM_POS
, SWIZZLE_XYZW
, MASK_XYZW
);
170 rmesa
->swtcl
.coloroffset
= 4;
173 if (RENDERINPUTS_TEST(tnl
->render_inputs_bitset
, _TNL_ATTRIB_COLOR0
)) {
174 InputsRead
|= 1 << VERT_ATTRIB_COLOR0
;
175 OutputsWritten
|= 1 << VERT_RESULT_COL0
;
176 #if MESA_LITTLE_ENDIAN
177 EMIT_ATTR( _TNL_ATTRIB_COLOR0
, EMIT_4UB_4F_RGBA
);
178 ADD_ATTR(VERT_ATTRIB_COLOR0
, EMIT_4UB_4F_RGBA
, SWTCL_OVM_COLOR0
, SWIZZLE_XYZW
, MASK_XYZW
);
180 EMIT_ATTR( _TNL_ATTRIB_COLOR0
, EMIT_4UB_4F_ABGR
);
181 ADD_ATTR(VERT_ATTRIB_COLOR0
, EMIT_4UB_4F_ABGR
, SWTCL_OVM_COLOR0
, SWIZZLE_XYZW
, MASK_XYZW
);
185 if (RENDERINPUTS_TEST(tnl
->render_inputs_bitset
, _TNL_ATTRIB_COLOR1
)) {
186 GLuint swiz
= MAKE_SWIZZLE4(SWIZZLE_X
, SWIZZLE_Y
, SWIZZLE_Z
, SWIZZLE_ONE
);
187 InputsRead
|= 1 << VERT_ATTRIB_COLOR1
;
188 OutputsWritten
|= 1 << VERT_RESULT_COL1
;
189 #if MESA_LITTLE_ENDIAN
190 EMIT_ATTR( _TNL_ATTRIB_COLOR1
, EMIT_4UB_4F_RGBA
);
191 ADD_ATTR(VERT_ATTRIB_COLOR1
, EMIT_4UB_4F_RGBA
, SWTCL_OVM_COLOR1
, swiz
, MASK_XYZW
);
193 EMIT_ATTR( _TNL_ATTRIB_COLOR1
, EMIT_4UB_4F_ABGR
);
194 ADD_ATTR(VERT_ATTRIB_COLOR1
, EMIT_4UB_4F_ABGR
, SWTCL_OVM_COLOR1
, swiz
, MASK_XYZW
);
196 rmesa
->swtcl
.specoffset
= rmesa
->swtcl
.coloroffset
+ 1;
199 if (ctx
->Light
.Enabled
&& ctx
->Light
.Model
.TwoSide
) {
200 VB
->AttribPtr
[VERT_ATTRIB_GENERIC0
] = VB
->ColorPtr
[1];
201 OutputsWritten
|= 1 << VERT_RESULT_BFC0
;
202 #if MESA_LITTLE_ENDIAN
203 EMIT_ATTR( _TNL_ATTRIB_GENERIC0
, EMIT_4UB_4F_RGBA
);
204 ADD_ATTR(VERT_ATTRIB_GENERIC0
, EMIT_4UB_4F_RGBA
, SWTCL_OVM_COLOR2
, SWIZZLE_XYZW
, MASK_XYZW
);
206 EMIT_ATTR( _TNL_ATTRIB_GENERIC0
, EMIT_4UB_4F_ABGR
);
207 ADD_ATTR(VERT_ATTRIB_GENERIC0
, EMIT_4UB_4F_ABGR
, SWTCL_OVM_COLOR2
, SWIZZLE_XYZW
, MASK_XYZW
);
209 if (RENDERINPUTS_TEST(tnl
->render_inputs_bitset
, _TNL_ATTRIB_COLOR1
)) {
210 GLuint swiz
= MAKE_SWIZZLE4(SWIZZLE_X
, SWIZZLE_Y
, SWIZZLE_Z
, SWIZZLE_ONE
);
211 OutputsWritten
|= 1 << VERT_RESULT_BFC1
;
212 #if MESA_LITTLE_ENDIAN
213 EMIT_ATTR( _TNL_ATTRIB_GENERIC1
, EMIT_4UB_4F_RGBA
);
214 ADD_ATTR(VERT_ATTRIB_GENERIC1
, EMIT_4UB_4F_RGBA
, SWTCL_OVM_COLOR3
, swiz
, MASK_XYZW
);
216 EMIT_ATTR( _TNL_ATTRIB_GENERIC1
, EMIT_4UB_4F_ABGR
);
217 ADD_ATTR(VERT_ATTRIB_GENERIC1
, EMIT_4UB_4F_ABGR
, SWTCL_OVM_COLOR3
, swiz
, MASK_XYZW
);
222 if (RENDERINPUTS_TEST(tnl
->render_inputs_bitset
, _TNL_ATTRIB_POINTSIZE
)) {
223 GLuint swiz
= MAKE_SWIZZLE4(SWIZZLE_X
, SWIZZLE_ZERO
, SWIZZLE_ZERO
, SWIZZLE_ZERO
);
224 InputsRead
|= 1 << VERT_ATTRIB_POINT_SIZE
;
225 OutputsWritten
|= 1 << VERT_RESULT_PSIZ
;
226 EMIT_ATTR( _TNL_ATTRIB_POINTSIZE
, EMIT_1F
);
227 ADD_ATTR(VERT_ATTRIB_POINT_SIZE
, EMIT_1F
, SWTCL_OVM_POINT_SIZE
, swiz
, MASK_X
);
231 * Sending only one texcoord component may lead to lock up,
232 * so for all textures always output 4 texcoord components to RS.
234 if (RENDERINPUTS_TEST_RANGE(tnl
->render_inputs_bitset
, _TNL_FIRST_TEX
, _TNL_LAST_TEX
)) {
237 for (i
= 0; i
< ctx
->Const
.MaxTextureUnits
; i
++) {
238 if (RENDERINPUTS_TEST(tnl
->render_inputs_bitset
, _TNL_ATTRIB_TEX(i
) )) {
239 switch (VB
->TexCoordPtr
[i
]->size
) {
242 swiz
= MAKE_SWIZZLE4(SWIZZLE_X
, SWIZZLE_ZERO
, SWIZZLE_ZERO
, SWIZZLE_ONE
);
246 swiz
= MAKE_SWIZZLE4(SWIZZLE_X
, SWIZZLE_Y
, SWIZZLE_ZERO
, SWIZZLE_ONE
);
250 swiz
= MAKE_SWIZZLE4(SWIZZLE_X
, SWIZZLE_Y
, SWIZZLE_Z
, SWIZZLE_ONE
);
259 InputsRead
|= 1 << (VERT_ATTRIB_TEX0
+ i
);
260 OutputsWritten
|= 1 << (VERT_RESULT_TEX0
+ i
);
261 EMIT_ATTR(_TNL_ATTRIB_TEX(i
), format
);
262 ADD_ATTR(VERT_ATTRIB_TEX0
+ i
, format
, SWTCL_OVM_TEX(i
), swiz
, MASK_XYZW
);
263 vap_out_fmt_1
|= 4 << (i
* 3);
269 /* RS can't put fragment position on the pixel stack, so stuff it in texcoord if needed */
270 if (RENDERINPUTS_TEST(tnl
->render_inputs_bitset
, _TNL_ATTRIB_POS
) && (ctx
->FragmentProgram
._Current
->Base
.InputsRead
& FRAG_BIT_WPOS
)) {
271 if (first_free_tex
>= ctx
->Const
.MaxTextureUnits
) {
272 fprintf(stderr
, "\tout of free texcoords to write w pos\n");
276 InputsRead
|= 1 << (VERT_ATTRIB_TEX0
+ first_free_tex
);
277 OutputsWritten
|= 1 << (VERT_RESULT_TEX0
+ first_free_tex
);
278 EMIT_ATTR( _TNL_ATTRIB_POS
, EMIT_4F
);
279 ADD_ATTR(VERT_ATTRIB_POS
, EMIT_4F
, SWTCL_OVM_TEX(first_free_tex
), SWIZZLE_XYZW
, MASK_XYZW
);
280 vap_out_fmt_1
|= 4 << (first_free_tex
* 3);
284 if (RENDERINPUTS_TEST(tnl
->render_inputs_bitset
, _TNL_ATTRIB_FOG
)) {
285 if (first_free_tex
>= ctx
->Const
.MaxTextureUnits
) {
286 fprintf(stderr
, "\tout of free texcoords to write fog coordinate\n");
290 InputsRead
|= 1 << VERT_ATTRIB_FOG
;
291 OutputsWritten
|= 1 << VERT_RESULT_FOGC
;
292 GLuint swiz
= MAKE_SWIZZLE4(SWIZZLE_X
, SWIZZLE_ZERO
, SWIZZLE_ZERO
, SWIZZLE_ZERO
);
293 EMIT_ATTR( _TNL_ATTRIB_FOG
, EMIT_1F
);
294 ADD_ATTR(VERT_ATTRIB_FOG
, EMIT_1F
, SWTCL_OVM_TEX(first_free_tex
), swiz
, MASK_X
);
295 vap_out_fmt_1
|= 1 << (first_free_tex
* 3);
299 r300SwtclVAPSetup(ctx
, InputsRead
, OutputsWritten
, vap_out_fmt_1
);
301 rmesa
->radeon
.swtcl
.vertex_size
=
302 _tnl_install_attrs( ctx
,
303 rmesa
->radeon
.swtcl
.vertex_attrs
,
304 rmesa
->radeon
.swtcl
.vertex_attr_count
,
307 rmesa
->radeon
.swtcl
.vertex_size
/= 4;
309 RENDERINPUTS_COPY(rmesa
->render_inputs_bitset
, tnl
->render_inputs_bitset
);
313 static GLuint reduced_prim
[] = {
326 static void r300RasterPrimitive( GLcontext
*ctx
, GLuint prim
);
327 static void r300RenderPrimitive( GLcontext
*ctx
, GLenum prim
);
329 /***********************************************************************
330 * Emit primitives as inline vertices *
331 ***********************************************************************/
334 #define HAVE_POINTS 1
336 #define HAVE_LINE_STRIPS 1
337 #define HAVE_TRIANGLES 1
338 #define HAVE_TRI_STRIPS 1
339 #define HAVE_TRI_STRIP_1 0
340 #define HAVE_TRI_FANS 1
342 #define HAVE_QUAD_STRIPS 0
343 #define HAVE_POLYGONS 1
348 #define CTX_ARG r300ContextPtr rmesa
349 #define GET_VERTEX_DWORDS() rmesa->radeon.swtcl.vertex_size
350 #define ALLOC_VERTS( n, size ) rcommonAllocDmaLowVerts( &rmesa->radeon, n, size * 4 )
352 r300ContextPtr rmesa = R300_CONTEXT(ctx); \
353 const char *r300verts = (char *)rmesa->radeon.swtcl.verts;
354 #define VERT(x) (r300Vertex *)(r300verts + ((x) * vertsize * sizeof(int)))
355 #define VERTEX r300Vertex
357 #define TAG(x) r300_##x
358 #include "tnl_dd/t_dd_triemit.h"
362 /***********************************************************************
363 * Macros for t_dd_tritmp.h to draw basic primitives *
364 ***********************************************************************/
366 #define QUAD( a, b, c, d ) r300_quad( rmesa, a, b, c, d )
367 #define TRI( a, b, c ) r300_triangle( rmesa, a, b, c )
368 #define LINE( a, b ) r300_line( rmesa, a, b )
369 #define POINT( a ) r300_point( rmesa, a )
371 /***********************************************************************
372 * Build render functions from dd templates *
373 ***********************************************************************/
375 #define R300_UNFILLED_BIT 0x01
376 #define R300_MAX_TRIFUNC 0x02
379 tnl_points_func points
;
381 tnl_triangle_func triangle
;
383 } rast_tab
[R300_MAX_TRIFUNC
];
385 #define DO_FALLBACK 0
386 #define DO_UNFILLED (IND & R300_UNFILLED_BIT)
394 #define DO_FULL_QUAD 1
398 #define HAVE_BACK_COLORS 0
399 #define HAVE_HW_FLATSHADE 1
402 #define DEPTH_SCALE 1.0
403 #define UNFILLED_TRI unfilled_tri
404 #define UNFILLED_QUAD unfilled_quad
405 #define VERT_X(_v) _v->v.x
406 #define VERT_Y(_v) _v->v.y
407 #define VERT_Z(_v) _v->v.z
408 #define AREA_IS_CCW( a ) (a < 0)
409 #define GET_VERTEX(e) (rmesa->radeon.swtcl.verts + (e*rmesa->radeon.swtcl.vertex_size*sizeof(int)))
411 #define VERT_SET_RGBA( v, c ) \
413 r300_color_t *color = (r300_color_t *)&((v)->ui[coloroffset]); \
414 UNCLAMPED_FLOAT_TO_UBYTE(color->red, (c)[0]); \
415 UNCLAMPED_FLOAT_TO_UBYTE(color->green, (c)[1]); \
416 UNCLAMPED_FLOAT_TO_UBYTE(color->blue, (c)[2]); \
417 UNCLAMPED_FLOAT_TO_UBYTE(color->alpha, (c)[3]); \
420 #define VERT_COPY_RGBA( v0, v1 ) v0->ui[coloroffset] = v1->ui[coloroffset]
422 #define VERT_SET_SPEC( v0, c ) \
425 UNCLAMPED_FLOAT_TO_UBYTE(v0->v.specular.red, (c)[0]); \
426 UNCLAMPED_FLOAT_TO_UBYTE(v0->v.specular.green, (c)[1]); \
427 UNCLAMPED_FLOAT_TO_UBYTE(v0->v.specular.blue, (c)[2]); \
431 #define VERT_COPY_SPEC( v0, v1 ) \
434 v0->v.specular.red = v1->v.specular.red; \
435 v0->v.specular.green = v1->v.specular.green; \
436 v0->v.specular.blue = v1->v.specular.blue; \
440 #define VERT_SAVE_RGBA( idx ) color[idx] = v[idx]->ui[coloroffset]
441 #define VERT_RESTORE_RGBA( idx ) v[idx]->ui[coloroffset] = color[idx]
442 #define VERT_SAVE_SPEC( idx ) if (specoffset) spec[idx] = v[idx]->ui[specoffset]
443 #define VERT_RESTORE_SPEC( idx ) if (specoffset) v[idx]->ui[specoffset] = spec[idx]
449 #define LOCAL_VARS(n) \
450 r300ContextPtr rmesa = R300_CONTEXT(ctx); \
451 GLuint color[n] = { 0, }, spec[n] = { 0, }; \
452 GLuint coloroffset = rmesa->swtcl.coloroffset; \
453 GLuint specoffset = rmesa->swtcl.specoffset; \
454 (void) color; (void) spec; (void) coloroffset; (void) specoffset;
456 /***********************************************************************
457 * Helpers for rendering unfilled primitives *
458 ***********************************************************************/
460 #define RASTERIZE(x) r300RasterPrimitive( ctx, reduced_prim[x] )
461 #define RENDER_PRIMITIVE rmesa->radeon.swtcl.render_primitive
464 #include "tnl_dd/t_dd_unfilled.h"
468 /***********************************************************************
469 * Generate GL render functions *
470 ***********************************************************************/
475 #include "tnl_dd/t_dd_tritmp.h"
477 #define IND (R300_UNFILLED_BIT)
478 #define TAG(x) x##_unfilled
479 #include "tnl_dd/t_dd_tritmp.h"
482 static void init_rast_tab( void )
488 /**********************************************************************/
489 /* Render unclipped begin/end objects */
490 /**********************************************************************/
492 #define RENDER_POINTS( start, count ) \
493 for ( ; start < count ; start++) \
494 r300_point( rmesa, VERT(start) )
495 #define RENDER_LINE( v0, v1 ) \
496 r300_line( rmesa, VERT(v0), VERT(v1) )
497 #define RENDER_TRI( v0, v1, v2 ) \
498 r300_triangle( rmesa, VERT(v0), VERT(v1), VERT(v2) )
499 #define RENDER_QUAD( v0, v1, v2, v3 ) \
500 r300_quad( rmesa, VERT(v0), VERT(v1), VERT(v2), VERT(v3) )
501 #define INIT(x) do { \
502 r300RenderPrimitive( ctx, x ); \
506 r300ContextPtr rmesa = R300_CONTEXT(ctx); \
507 const GLuint vertsize = rmesa->radeon.swtcl.vertex_size; \
508 const char *r300verts = (char *)rmesa->radeon.swtcl.verts; \
509 const GLuint * const elt = TNL_CONTEXT(ctx)->vb.Elts; \
510 const GLboolean stipple = ctx->Line.StippleFlag; \
511 (void) elt; (void) stipple;
512 #define RESET_STIPPLE //if ( stipple ) r200ResetLineStipple( ctx );
513 #define RESET_OCCLUSION
514 #define PRESERVE_VB_DEFS
516 #define TAG(x) r300_##x##_verts
517 #include "tnl/t_vb_rendertmp.h"
520 #define TAG(x) r300_##x##_elts
521 #define ELT(x) elt[x]
522 #include "tnl/t_vb_rendertmp.h"
527 /**********************************************************************/
528 /* Choose render functions */
529 /**********************************************************************/
530 static void r300ChooseRenderState( GLcontext
*ctx
)
532 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
533 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
535 GLuint flags
= ctx
->_TriangleCaps
;
537 if (flags
& DD_TRI_UNFILLED
) index
|= R300_UNFILLED_BIT
;
539 if (index
!= rmesa
->radeon
.swtcl
.RenderIndex
) {
540 tnl
->Driver
.Render
.Points
= rast_tab
[index
].points
;
541 tnl
->Driver
.Render
.Line
= rast_tab
[index
].line
;
542 tnl
->Driver
.Render
.ClippedLine
= rast_tab
[index
].line
;
543 tnl
->Driver
.Render
.Triangle
= rast_tab
[index
].triangle
;
544 tnl
->Driver
.Render
.Quad
= rast_tab
[index
].quad
;
547 tnl
->Driver
.Render
.PrimTabVerts
= r300_render_tab_verts
;
548 tnl
->Driver
.Render
.PrimTabElts
= r300_render_tab_elts
;
549 tnl
->Driver
.Render
.ClippedPolygon
= r300_fast_clipped_poly
;
551 tnl
->Driver
.Render
.PrimTabVerts
= _tnl_render_tab_verts
;
552 tnl
->Driver
.Render
.PrimTabElts
= _tnl_render_tab_elts
;
553 tnl
->Driver
.Render
.ClippedPolygon
= _tnl_RenderClippedPolygon
;
556 rmesa
->radeon
.swtcl
.RenderIndex
= index
;
561 static void r300RenderStart(GLcontext
*ctx
)
563 r300ContextPtr rmesa
= R300_CONTEXT( ctx
);
565 r300ChooseRenderState(ctx
);
566 r300SetVertexFormat(ctx
);
568 r300ValidateBuffers(ctx
);
570 r300UpdateShaders(rmesa
);
571 r300UpdateShaderStates(rmesa
);
573 r300EmitCacheFlush(rmesa
);
575 /* investigate if we can put back flush optimisation if needed */
576 if (rmesa
->radeon
.dma
.flush
!= NULL
) {
577 rmesa
->radeon
.dma
.flush(ctx
);
581 static void r300RenderFinish(GLcontext
*ctx
)
585 static void r300RasterPrimitive( GLcontext
*ctx
, GLuint hwprim
)
587 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
589 if (rmesa
->radeon
.swtcl
.hw_primitive
!= hwprim
) {
590 R300_NEWPRIM( rmesa
);
591 rmesa
->radeon
.swtcl
.hw_primitive
= hwprim
;
595 static void r300RenderPrimitive(GLcontext
*ctx
, GLenum prim
)
598 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
599 rmesa
->radeon
.swtcl
.render_primitive
= prim
;
601 if ((prim
== GL_TRIANGLES
) && (ctx
->_TriangleCaps
& DD_TRI_UNFILLED
))
604 r300RasterPrimitive( ctx
, reduced_prim
[prim
] );
607 static void r300ResetLineStipple(GLcontext
*ctx
)
611 void r300InitSwtcl(GLcontext
*ctx
)
613 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
614 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
615 static int firsttime
= 1;
622 tnl
->Driver
.Render
.Start
= r300RenderStart
;
623 tnl
->Driver
.Render
.Finish
= r300RenderFinish
;
624 tnl
->Driver
.Render
.PrimitiveNotify
= r300RenderPrimitive
;
625 tnl
->Driver
.Render
.ResetLineStipple
= r300ResetLineStipple
;
626 tnl
->Driver
.Render
.BuildVertices
= _tnl_build_vertices
;
627 tnl
->Driver
.Render
.CopyPV
= _tnl_copy_pv
;
628 tnl
->Driver
.Render
.Interp
= _tnl_interp
;
630 /* FIXME: what are these numbers? */
631 _tnl_init_vertices( ctx
, ctx
->Const
.MaxArrayLockSize
+ 12,
632 48 * sizeof(GLfloat
) );
634 rmesa
->radeon
.swtcl
.verts
= (GLubyte
*)tnl
->clipspace
.vertex_buf
;
635 rmesa
->radeon
.swtcl
.RenderIndex
= ~0;
636 rmesa
->radeon
.swtcl
.render_primitive
= GL_TRIANGLES
;
637 rmesa
->radeon
.swtcl
.hw_primitive
= 0;
639 _tnl_invalidate_vertex_state( ctx
, ~0 );
640 _tnl_invalidate_vertices( ctx
, ~0 );
642 _tnl_need_projected_coords( ctx
, GL_FALSE
);
643 r300ChooseRenderState(ctx
);
646 void r300DestroySwtcl(GLcontext
*ctx
)
650 static void r300EmitVertexAOS(r300ContextPtr rmesa
, GLuint vertex_size
, struct radeon_bo
*bo
, GLuint offset
)
652 BATCH_LOCALS(&rmesa
->radeon
);
654 if (RADEON_DEBUG
& DEBUG_VERTS
)
655 fprintf(stderr
, "%s: vertex_size %d, offset 0x%x \n",
656 __FUNCTION__
, vertex_size
, offset
);
659 OUT_BATCH_PACKET3(R300_PACKET3_3D_LOAD_VBPNTR
, 2);
661 OUT_BATCH(vertex_size
| (vertex_size
<< 8));
662 OUT_BATCH_RELOC(offset
, bo
, offset
, RADEON_GEM_DOMAIN_GTT
, 0, 0);
666 static void r300EmitVbufPrim(r300ContextPtr rmesa
, GLuint primitive
, GLuint vertex_nr
)
668 BATCH_LOCALS(&rmesa
->radeon
);
671 type
= r300PrimitiveType(rmesa
, primitive
);
672 num_verts
= r300NumVerts(rmesa
, vertex_nr
, primitive
);
675 OUT_BATCH_PACKET3(R300_PACKET3_3D_DRAW_VBUF_2
, 0);
676 OUT_BATCH(R300_VAP_VF_CNTL__PRIM_WALK_VERTEX_LIST
| (num_verts
<< 16) | type
);
680 void r300_swtcl_flush(GLcontext
*ctx
, uint32_t current_offset
)
682 r300ContextPtr rmesa
= R300_CONTEXT(ctx
);
684 rcommonEnsureCmdBufSpace(&rmesa
->radeon
,
685 rmesa
->radeon
.hw
.max_state_size
+ (12*sizeof(int)),
687 radeonEmitState(&rmesa
->radeon
);
688 r300EmitVertexAOS(rmesa
,
689 rmesa
->radeon
.swtcl
.vertex_size
,
690 rmesa
->radeon
.dma
.current
,
693 r300EmitVbufPrim(rmesa
,
694 rmesa
->radeon
.swtcl
.hw_primitive
,
695 rmesa
->radeon
.swtcl
.numverts
);
696 r300EmitCacheFlush(rmesa
);