1 /* -*- mode: c; c-basic-offset: 3 -*- */
3 * Copyright 2000 Gareth Hughes
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice (including the next
14 * paragraph) shall be included in all copies or substantial portions of the
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * GARETH HUGHES BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
21 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 * Gareth Hughes <gareth@valinux.com>
28 * Leif Delgass <ldelgass@retinalburn.net>
29 * José Fonseca <j_r_fonseca@yahoo.co.uk>
32 #include "main/glheader.h"
33 #include "main/mtypes.h"
34 #include "main/colormac.h"
35 #include "main/macros.h"
37 #include "swrast/swrast.h"
38 #include "swrast_setup/swrast_setup.h"
40 #include "tnl/t_context.h"
41 #include "tnl/t_pipeline.h"
43 #include "mach64_tris.h"
44 #include "mach64_state.h"
45 #include "mach64_context.h"
46 #include "mach64_vb.h"
47 #include "mach64_ioctl.h"
49 static const GLuint hw_prim
[GL_POLYGON
+1] = {
52 MACH64_PRIM_LINE_LOOP
,
53 MACH64_PRIM_LINE_STRIP
,
54 MACH64_PRIM_TRIANGLES
,
55 MACH64_PRIM_TRIANGLE_STRIP
,
56 MACH64_PRIM_TRIANGLE_FAN
,
58 MACH64_PRIM_QUAD_STRIP
,
62 static void mach64RasterPrimitive( struct gl_context
*ctx
, GLuint hwprim
);
63 static void mach64RenderPrimitive( struct gl_context
*ctx
, GLenum prim
);
66 /* FIXME: Remove this when native template is finished. */
67 #define MACH64_PRINT_BUFFER 0
69 /***********************************************************************
70 * Emit primitives as inline vertices *
71 ***********************************************************************/
73 #if defined(USE_X86_ASM)
74 #define DO_COPY_VERTEX( vb, vertsize, v, n, m ) \
76 register const CARD32 *__p __asm__( "esi" ) = (CARD32 *)v + 10 - vertsize; \
77 register int __s __asm__( "ecx" ) = vertsize; \
78 if ( vertsize > 7 ) { \
79 *vb++ = (2 << 16) | ADRINDEX( MACH64_VERTEX_##n##_SECONDARY_S ); \
80 __asm__ __volatile__( "movsl ; movsl ; movsl" \
81 : "=D" (vb), "=S" (__p) \
82 : "0" (vb), "1" (__p) ); \
85 *vb++ = ((__s - 1 + m) << 16) | \
86 (ADRINDEX( MACH64_VERTEX_##n##_X_Y ) - (__s - 1) ); \
87 __asm__ __volatile__( "rep ; movsl" \
88 : "=%c" (__s), "=D" (vb), "=S" (__p) \
89 : "0" (__s), "1" (vb), "2" (__p) ); \
92 #define DO_COPY_VERTEX( vb, vertsize, v, n, m ) \
94 CARD32 *__p = (CARD32 *)v + 10 - vertsize; \
96 if ( vertsize > 7 ) { \
97 LE32_OUT( vb++, (2 << 16) | \
98 ADRINDEX( MACH64_VERTEX_##n##_SECONDARY_S ) ); \
104 LE32_OUT( vb++, ((__s - 1 + m) << 16) | \
105 (ADRINDEX( MACH64_VERTEX_##n##_X_Y ) - (__s - 1)) ); \
112 #define COPY_VERTEX( vb, vertsize, v, n ) DO_COPY_VERTEX( vb, vertsize, v, n, 0 )
113 #define COPY_VERTEX_OOA( vb, vertsize, v, n ) DO_COPY_VERTEX( vb, vertsize, v, n, 1 )
116 static INLINE
void mach64_draw_quad( mach64ContextPtr mmesa
,
122 #if MACH64_NATIVE_VTXFMT
123 struct gl_context
*ctx
= mmesa
->glCtx
;
124 const GLuint vertsize
= mmesa
->vertex_size
;
128 const GLuint xyoffset
= 9;
129 GLint xx
[3], yy
[3]; /* 2 fractional bits for hardware */
130 unsigned vbsiz
= (vertsize
+ (vertsize
> 7 ? 2 : 1)) * 4 + 2;
133 if ( MACH64_DEBUG
& DEBUG_VERBOSE_PRIMS
) {
134 fprintf(stderr
, "%s:\n", __FUNCTION__
);
135 fprintf(stderr
,"Vertex 1:\n");
136 mach64_print_vertex( ctx
, v0
);
137 fprintf(stderr
,"Vertex 2:\n");
138 mach64_print_vertex( ctx
, v1
);
139 fprintf(stderr
,"Vertex 3:\n");
140 mach64_print_vertex( ctx
, v2
);
141 fprintf(stderr
,"Vertex 4:\n");
142 mach64_print_vertex( ctx
, v3
);
145 xy
= LE32_IN( &v0
->ui
[xyoffset
] );
146 xx
[0] = (GLshort
)( xy
>> 16 );
147 yy
[0] = (GLshort
)( xy
& 0xffff );
149 xy
= LE32_IN( &v1
->ui
[xyoffset
] );
150 xx
[1] = (GLshort
)( xy
>> 16 );
151 yy
[1] = (GLshort
)( xy
& 0xffff );
153 xy
= LE32_IN( &v3
->ui
[xyoffset
] );
154 xx
[2] = (GLshort
)( xy
>> 16 );
155 yy
[2] = (GLshort
)( xy
& 0xffff );
157 a
= (xx
[0] - xx
[2]) * (yy
[1] - yy
[2]) -
158 (yy
[0] - yy
[2]) * (xx
[1] - xx
[2]);
160 if ( (mmesa
->backface_sign
&&
161 ((a
< 0 && !signbit( mmesa
->backface_sign
)) ||
162 (a
> 0 && signbit( mmesa
->backface_sign
)))) ) {
164 if ( MACH64_DEBUG
& DEBUG_VERBOSE_PRIMS
)
165 fprintf(stderr
,"Quad culled\n");
171 vb
= (CARD32
*)mach64AllocDmaLow( mmesa
, vbsiz
* sizeof(CARD32
) );
174 COPY_VERTEX( vb
, vertsize
, v0
, 1 );
175 COPY_VERTEX( vb
, vertsize
, v1
, 2 );
176 COPY_VERTEX_OOA( vb
, vertsize
, v3
, 3 );
177 LE32_OUT( vb
++, *(CARD32
*)&ooa
);
179 xy
= LE32_IN( &v2
->ui
[xyoffset
] );
180 xx
[0] = (GLshort
)( xy
>> 16 );
181 yy
[0] = (GLshort
)( xy
& 0xffff );
183 a
= (xx
[0] - xx
[2]) * (yy
[1] - yy
[2]) -
184 (yy
[0] - yy
[2]) * (xx
[1] - xx
[2]);
188 COPY_VERTEX_OOA( vb
, vertsize
, v2
, 1 );
189 LE32_OUT( vb
++, *(CARD32
*)&ooa
);
191 assert( vb
== vbchk
);
193 #if MACH64_PRINT_BUFFER
196 fprintf(stderr
, "quad:\n");
197 for (i
= 0; i
< vbsiz
; i
++)
198 fprintf(stderr
, " %08lx\n", *(vb
- vbsiz
+ i
));
199 fprintf(stderr
, "\n");
203 GLuint vertsize
= mmesa
->vertex_size
;
206 GLint xx
[3], yy
[3]; /* 2 fractional bits for hardware */
210 (vertsize
> 6 ? 2 : 0) +
211 (vertsize
> 4 ? 2 : 0) +
213 (mmesa
->multitex
? 4 : 0)
218 if ( MACH64_DEBUG
& DEBUG_VERBOSE_PRIMS
) {
219 fprintf(stderr
, "%s:\n", __FUNCTION__
);
220 fprintf(stderr
,"Vertex 1: x: %.2f, y: %.2f, z: %.2f, w: %f\n\ts0: %f, t0: %f\n\ts1: %f, t1: %f\n",
221 v0
->v
.x
, v0
->v
.y
, v0
->v
.z
, v0
->v
.w
, v0
->v
.u0
, v0
->v
.v0
, v0
->v
.u1
, v0
->v
.v1
);
222 fprintf(stderr
,"Vertex 2: x: %.2f, y: %.2f, z: %.2f, w: %f\n\ts0: %f, t0: %f\n\ts1: %f, t1: %f\n",
223 v1
->v
.x
, v1
->v
.y
, v1
->v
.z
, v1
->v
.w
, v1
->v
.u0
, v1
->v
.v0
, v1
->v
.u1
, v1
->v
.v1
);
224 fprintf(stderr
,"Vertex 3: x: %.2f, y: %.2f, z: %.2f, w: %f\n\ts0: %f, t0: %f\n\ts1: %f, t1: %f\n",
225 v2
->v
.x
, v2
->v
.y
, v2
->v
.z
, v2
->v
.w
, v2
->v
.u0
, v2
->v
.v0
, v2
->v
.u1
, v2
->v
.v1
);
226 fprintf(stderr
,"Vertex 4: x: %.2f, y: %.2f, z: %.2f, w: %f\n\ts0: %f, t0: %f\n\ts1: %f, t1: %f\n",
227 v3
->v
.x
, v3
->v
.y
, v3
->v
.z
, v3
->v
.w
, v3
->v
.u0
, v3
->v
.v0
, v3
->v
.u1
, v3
->v
.v1
);
230 #if MACH64_CLIENT_STATE_EMITS
231 /* Enable for interleaved client-side state emits */
232 LOCK_HARDWARE( mmesa
);
233 if ( mmesa
->dirty
) {
234 mach64EmitHwStateLocked( mmesa
);
236 if ( mmesa
->sarea
->dirty
) {
237 mach64UploadHwStateLocked( mmesa
);
239 UNLOCK_HARDWARE( mmesa
);
242 xx
[0] = (GLint
)(v0
->v
.x
* 4);
243 yy
[0] = (GLint
)(v0
->v
.y
* 4);
245 xx
[1] = (GLint
)(v1
->v
.x
* 4);
246 yy
[1] = (GLint
)(v1
->v
.y
* 4);
248 xx
[2] = (GLint
)(v3
->v
.x
* 4);
249 yy
[2] = (GLint
)(v3
->v
.y
* 4);
251 ooa
= 0.25 * 0.25 * ((xx
[0] - xx
[2]) * (yy
[1] - yy
[2]) -
252 (yy
[0] - yy
[2]) * (xx
[1] - xx
[2]));
254 if ( ooa
* mmesa
->backface_sign
< 0 ) {
256 if ( MACH64_DEBUG
& DEBUG_VERBOSE_PRIMS
)
257 fprintf(stderr
,"Quad culled\n");
261 vb
= (CARD32
*)mach64AllocDmaLow( mmesa
, vbsiz
* 4 );
265 coloridx
= (vertsize
> 4) ? 4: 3;
267 /* setup for 3,5, or 7 sequential reg writes based on vertex format */
270 LE32_OUT( &vb
[vbidx
++], (4 << 16) | ADRINDEX(MACH64_VERTEX_1_W
) );
273 LE32_OUT( &vb
[vbidx
++], (2 << 16) | ADRINDEX(MACH64_VERTEX_1_Z
) );
275 default: /* vertsize >= 8 */
276 LE32_OUT( &vb
[vbidx
++], (6 << 16) | ADRINDEX(MACH64_VERTEX_1_S
) );
280 LE32_OUT( &vb
[vbidx
++], v0
->ui
[6] ); /* MACH64_VERTEX_1_S */
281 LE32_OUT( &vb
[vbidx
++], v0
->ui
[7] ); /* MACH64_VERTEX_1_T */
284 LE32_OUT( &vb
[vbidx
++], v0
->ui
[3] ); /* MACH64_VERTEX_1_W */
285 LE32_OUT( &vb
[vbidx
++], v0
->ui
[5] ); /* MACH64_VERTEX_1_SPEC_ARGB */
287 LE32_OUT( &vb
[vbidx
++], ((GLint
)(v0
->v
.z
) << 15) ); /* MACH64_VERTEX_1_Z */
288 vb
[vbidx
++] = v0
->ui
[coloridx
]; /* MACH64_VERTEX_1_ARGB */
289 LE32_OUT( &vb
[vbidx
++], (xx
[0] << 16) | (yy
[0] & 0xffff) ); /* MACH64_VERTEX_1_X_Y */
291 if (mmesa
->multitex
) {
292 /* setup for 3 sequential reg writes */
293 LE32_OUT( &vb
[vbidx
++], (2 << 16) | ADRINDEX(MACH64_VERTEX_1_SECONDARY_S
) );
294 LE32_OUT( &vb
[vbidx
++], v0
->ui
[8] ); /* MACH64_VERTEX_1_SECONDARY_S */
295 LE32_OUT( &vb
[vbidx
++], v0
->ui
[9] ); /* MACH64_VERTEX_1_SECONDARY_T */
296 LE32_OUT( &vb
[vbidx
++], v0
->ui
[3] ); /* MACH64_VERTEX_1_SECONDARY_W */
299 /* setup for 3,5, or 7 sequential reg writes based on vertex format */
302 LE32_OUT( &vb
[vbidx
++], (4 << 16) | ADRINDEX(MACH64_VERTEX_2_W
) );
305 LE32_OUT( &vb
[vbidx
++], (2 << 16) | ADRINDEX(MACH64_VERTEX_2_Z
) );
307 default: /* vertsize >= 8 */
308 LE32_OUT( &vb
[vbidx
++], (6 << 16) | ADRINDEX(MACH64_VERTEX_2_S
) );
312 LE32_OUT( &vb
[vbidx
++], v1
->ui
[6] ); /* MACH64_VERTEX_2_S */
313 LE32_OUT( &vb
[vbidx
++], v1
->ui
[7] ); /* MACH64_VERTEX_2_T */
316 LE32_OUT( &vb
[vbidx
++], v1
->ui
[3] ); /* MACH64_VERTEX_2_W */
317 LE32_OUT( &vb
[vbidx
++], v1
->ui
[5] ); /* MACH64_VERTEX_2_SPEC_ARGB */
319 LE32_OUT( &vb
[vbidx
++], ((GLint
)(v1
->v
.z
) << 15) ); /* MACH64_VERTEX_2_Z */
320 vb
[vbidx
++] = v1
->ui
[coloridx
]; /* MACH64_VERTEX_2_ARGB */
321 LE32_OUT( &vb
[vbidx
++], (xx
[1] << 16) | (yy
[1] & 0xffff) ); /* MACH64_VERTEX_2_X_Y */
323 if (mmesa
->multitex
) {
324 /* setup for 3 sequential reg writes */
325 LE32_OUT( &vb
[vbidx
++], (2 << 16) | ADRINDEX(MACH64_VERTEX_2_SECONDARY_S
) );
326 LE32_OUT( &vb
[vbidx
++], v1
->ui
[8] ); /* MACH64_VERTEX_2_SECONDARY_S */
327 LE32_OUT( &vb
[vbidx
++], v1
->ui
[9] ); /* MACH64_VERTEX_2_SECONDARY_T */
328 LE32_OUT( &vb
[vbidx
++], v1
->ui
[3] ); /* MACH64_VERTEX_2_SECONDARY_W */
331 /* setup for 3,5, or 7 sequential reg writes based on vertex format */
334 LE32_OUT( &vb
[vbidx
++], (4 << 16) | ADRINDEX(MACH64_VERTEX_3_W
) );
337 LE32_OUT( &vb
[vbidx
++], (2 << 16) | ADRINDEX(MACH64_VERTEX_3_Z
) );
339 default: /* vertsize >= 8 */
340 LE32_OUT( &vb
[vbidx
++], (6 << 16) | ADRINDEX(MACH64_VERTEX_3_S
) );
344 LE32_OUT( &vb
[vbidx
++], v3
->ui
[6] ); /* MACH64_VERTEX_3_S */
345 LE32_OUT( &vb
[vbidx
++], v3
->ui
[7] ); /* MACH64_VERTEX_3_T */
348 LE32_OUT( &vb
[vbidx
++], v3
->ui
[3] ); /* MACH64_VERTEX_3_W */
349 LE32_OUT( &vb
[vbidx
++], v3
->ui
[5] ); /* MACH64_VERTEX_3_SPEC_ARGB */
351 LE32_OUT( &vb
[vbidx
++], ((GLint
)(v3
->v
.z
) << 15) ); /* MACH64_VERTEX_3_Z */
352 vb
[vbidx
++] = v3
->ui
[coloridx
]; /* MACH64_VERTEX_3_ARGB */
353 LE32_OUT( &vb
[vbidx
++], (xx
[2] << 16) | (yy
[2] & 0xffff) ); /* MACH64_VERTEX_3_X_Y */
355 if (mmesa
->multitex
) {
356 /* setup for 3 sequential reg writes */
357 LE32_OUT( &vb
[vbidx
++], (2 << 16) | ADRINDEX(MACH64_VERTEX_3_SECONDARY_S
) );
358 LE32_OUT( &vb
[vbidx
++], v3
->ui
[8] ); /* MACH64_VERTEX_3_SECONDARY_S */
359 LE32_OUT( &vb
[vbidx
++], v3
->ui
[9] ); /* MACH64_VERTEX_3_SECONDARY_T */
360 LE32_OUT( &vb
[vbidx
++], v3
->ui
[3] ); /* MACH64_VERTEX_3_SECONDARY_W */
363 LE32_OUT( &vb
[vbidx
++], ADRINDEX(MACH64_ONE_OVER_AREA_UC
) );
364 LE32_OUT( &vb
[vbidx
++], *(GLuint
*)&ooa
);
366 xx
[0] = (GLint
)(v2
->v
.x
* 4);
367 yy
[0] = (GLint
)(v2
->v
.y
* 4);
369 ooa
= 0.25 * 0.25 * ((xx
[0] - xx
[2]) * (yy
[1] - yy
[2]) -
370 (yy
[0] - yy
[2]) * (xx
[1] - xx
[2]));
373 /* setup for 3,5, or 7 sequential reg writes based on vertex format */
376 LE32_OUT( &vb
[vbidx
++], (4 << 16) | ADRINDEX(MACH64_VERTEX_1_W
) );
379 LE32_OUT( &vb
[vbidx
++], (2 << 16) | ADRINDEX(MACH64_VERTEX_1_Z
) );
381 default: /* vertsize >= 8 */
382 LE32_OUT( &vb
[vbidx
++], (6 << 16) | ADRINDEX(MACH64_VERTEX_1_S
) );
386 LE32_OUT( &vb
[vbidx
++], v2
->ui
[6] ); /* MACH64_VERTEX_1_S */
387 LE32_OUT( &vb
[vbidx
++], v2
->ui
[7] ); /* MACH64_VERTEX_1_T */
390 LE32_OUT( &vb
[vbidx
++], v2
->ui
[3] ); /* MACH64_VERTEX_1_W */
391 LE32_OUT( &vb
[vbidx
++], v2
->ui
[5] ); /* MACH64_VERTEX_1_SPEC_ARGB */
393 LE32_OUT( &vb
[vbidx
++], ((GLint
)(v2
->v
.z
) << 15) ); /* MACH64_VERTEX_1_Z */
394 vb
[vbidx
++] = v2
->ui
[coloridx
]; /* MACH64_VERTEX_1_ARGB */
395 LE32_OUT( &vb
[vbidx
++], (xx
[0] << 16) | (yy
[0] & 0xffff) ); /* MACH64_VERTEX_1_X_Y */
397 if (mmesa
->multitex
) {
398 /* setup for 3 sequential reg writes */
399 LE32_OUT( &vb
[vbidx
++], (2 << 16) | ADRINDEX(MACH64_VERTEX_1_SECONDARY_S
) );
400 LE32_OUT( &vb
[vbidx
++], v2
->ui
[8] ); /* MACH64_VERTEX_1_SECONDARY_S */
401 LE32_OUT( &vb
[vbidx
++], v2
->ui
[9] ); /* MACH64_VERTEX_1_SECONDARY_T */
402 LE32_OUT( &vb
[vbidx
++], v2
->ui
[3] ); /* MACH64_VERTEX_1_SECONDARY_W */
405 LE32_OUT( &vb
[vbidx
++], ADRINDEX(MACH64_ONE_OVER_AREA_UC
) );
406 LE32_OUT( &vb
[vbidx
++], *(GLuint
*)&ooa
);
408 assert(vbsiz
== vbidx
);
410 #if MACH64_PRINT_BUFFER
413 fprintf(stderr
, "quad:\n");
414 for (i
= 0; i
< vbsiz
; i
++)
415 fprintf(stderr
, " %08lx\n", *(vb
+ i
));
416 fprintf(stderr
, "\n");
422 static INLINE
void mach64_draw_triangle( mach64ContextPtr mmesa
,
427 #if MACH64_NATIVE_VTXFMT
428 struct gl_context
*ctx
= mmesa
->glCtx
;
429 GLuint vertsize
= mmesa
->vertex_size
;
433 const GLuint xyoffset
= 9;
434 GLint xx
[3], yy
[3]; /* 2 fractional bits for hardware */
435 unsigned vbsiz
= (vertsize
+ (vertsize
> 7 ? 2 : 1)) * 3 + 1;
438 if ( MACH64_DEBUG
& DEBUG_VERBOSE_PRIMS
) {
439 fprintf(stderr
, "%s:\n", __FUNCTION__
);
440 fprintf(stderr
,"Vertex 1:\n");
441 mach64_print_vertex( ctx
, v0
);
442 fprintf(stderr
,"Vertex 2:\n");
443 mach64_print_vertex( ctx
, v1
);
444 fprintf(stderr
,"Vertex 3:\n");
445 mach64_print_vertex( ctx
, v2
);
448 xy
= LE32_IN( &v0
->ui
[xyoffset
] );
449 xx
[0] = (GLshort
)( xy
>> 16 );
450 yy
[0] = (GLshort
)( xy
& 0xffff );
452 xy
= LE32_IN( &v1
->ui
[xyoffset
] );
453 xx
[1] = (GLshort
)( xy
>> 16 );
454 yy
[1] = (GLshort
)( xy
& 0xffff );
456 xy
= LE32_IN( &v2
->ui
[xyoffset
] );
457 xx
[2] = (GLshort
)( xy
>> 16 );
458 yy
[2] = (GLshort
)( xy
& 0xffff );
460 a
= (xx
[0] - xx
[2]) * (yy
[1] - yy
[2]) -
461 (yy
[0] - yy
[2]) * (xx
[1] - xx
[2]);
463 if ( mmesa
->backface_sign
&&
464 ((a
< 0 && !signbit( mmesa
->backface_sign
)) ||
465 (a
> 0 && signbit( mmesa
->backface_sign
))) ) {
467 if ( MACH64_DEBUG
& DEBUG_VERBOSE_PRIMS
)
468 fprintf(stderr
,"Triangle culled\n");
474 vb
= (CARD32
*)mach64AllocDmaLow( mmesa
, vbsiz
* sizeof(CARD32
) );
477 COPY_VERTEX( vb
, vertsize
, v0
, 1 );
478 COPY_VERTEX( vb
, vertsize
, v1
, 2 );
479 COPY_VERTEX_OOA( vb
, vertsize
, v2
, 3 );
480 LE32_OUT( vb
++, *(CARD32
*)&ooa
);
482 assert( vb
== vbchk
);
484 #if MACH64_PRINT_BUFFER
487 fprintf(stderr
, "tri:\n");
488 for (i
= 0; i
< vbsiz
; i
++)
489 fprintf(stderr
, " %08lx\n", *(vb
- vbsiz
+ i
));
490 fprintf(stderr
, "\n");
494 GLuint vertsize
= mmesa
->vertex_size
;
497 GLint xx
[3], yy
[3]; /* 2 fractional bits for hardware */
501 (vertsize
> 6 ? 2 : 0) +
502 (vertsize
> 4 ? 2 : 0) +
504 (mmesa
->multitex
? 4 : 0)
509 if ( MACH64_DEBUG
& DEBUG_VERBOSE_PRIMS
) {
510 fprintf(stderr
, "%s:\n", __FUNCTION__
);
511 fprintf(stderr
,"Vertex 1: x: %.2f, y: %.2f, z: %.2f, w: %f\n\ts0: %f, t0: %f\n\ts1: %f, t1: %f\n",
512 v0
->v
.x
, v0
->v
.y
, v0
->v
.z
, v0
->v
.w
, v0
->v
.u0
, v0
->v
.v0
, v0
->v
.u1
, v0
->v
.v1
);
513 fprintf(stderr
,"Vertex 2: x: %.2f, y: %.2f, z: %.2f, w: %f\n\ts0: %f, t0: %f\n\ts1: %f, t1: %f\n",
514 v1
->v
.x
, v1
->v
.y
, v1
->v
.z
, v1
->v
.w
, v1
->v
.u0
, v1
->v
.v0
, v1
->v
.u1
, v1
->v
.v1
);
515 fprintf(stderr
,"Vertex 3: x: %.2f, y: %.2f, z: %.2f, w: %f\n\ts0: %f, t0: %f\n\ts1: %f, t1: %f\n",
516 v2
->v
.x
, v2
->v
.y
, v2
->v
.z
, v2
->v
.w
, v2
->v
.u0
, v2
->v
.v0
, v2
->v
.u1
, v2
->v
.v1
);
519 #if MACH64_CLIENT_STATE_EMITS
520 /* Enable for interleaved client-side state emits */
521 LOCK_HARDWARE( mmesa
);
522 if ( mmesa
->dirty
) {
523 mach64EmitHwStateLocked( mmesa
);
525 if ( mmesa
->sarea
->dirty
) {
526 mach64UploadHwStateLocked( mmesa
);
528 UNLOCK_HARDWARE( mmesa
);
531 xx
[0] = (GLint
)(v0
->v
.x
* 4);
532 yy
[0] = (GLint
)(v0
->v
.y
* 4);
534 xx
[1] = (GLint
)(v1
->v
.x
* 4);
535 yy
[1] = (GLint
)(v1
->v
.y
* 4);
537 xx
[2] = (GLint
)(v2
->v
.x
* 4);
538 yy
[2] = (GLint
)(v2
->v
.y
* 4);
540 ooa
= 0.25 * 0.25 * ((xx
[0] - xx
[2]) * (yy
[1] - yy
[2]) -
541 (yy
[0] - yy
[2]) * (xx
[1] - xx
[2]));
543 if ( ooa
* mmesa
->backface_sign
< 0 ) {
545 if ( MACH64_DEBUG
& DEBUG_VERBOSE_PRIMS
)
546 fprintf(stderr
,"Triangle culled\n");
550 vb
= (CARD32
*)mach64AllocDmaLow( mmesa
, vbsiz
* 4 );
554 coloridx
= (vertsize
> 4) ? 4: 3;
556 /* setup for 3,5, or 7 sequential reg writes based on vertex format */
559 LE32_OUT( &vb
[vbidx
++], (4 << 16) | ADRINDEX(MACH64_VERTEX_1_W
) );
562 LE32_OUT( &vb
[vbidx
++], (2 << 16) | ADRINDEX(MACH64_VERTEX_1_Z
) );
564 default: /* vertsize >= 8 */
565 LE32_OUT( &vb
[vbidx
++], (6 << 16) | ADRINDEX(MACH64_VERTEX_1_S
) );
569 LE32_OUT( &vb
[vbidx
++], v0
->ui
[6] ); /* MACH64_VERTEX_1_S */
570 LE32_OUT( &vb
[vbidx
++], v0
->ui
[7] ); /* MACH64_VERTEX_1_T */
573 LE32_OUT( &vb
[vbidx
++], v0
->ui
[3] ); /* MACH64_VERTEX_1_W */
574 LE32_OUT( &vb
[vbidx
++], v0
->ui
[5] ); /* MACH64_VERTEX_1_SPEC_ARGB */
576 LE32_OUT( &vb
[vbidx
++], ((GLint
)(v0
->v
.z
) << 15) ); /* MACH64_VERTEX_1_Z */
577 vb
[vbidx
++] = v0
->ui
[coloridx
]; /* MACH64_VERTEX_1_ARGB */
578 LE32_OUT( &vb
[vbidx
++], (xx
[0] << 16) | (yy
[0] & 0xffff) ); /* MACH64_VERTEX_1_X_Y */
580 if (mmesa
->multitex
) {
581 /* setup for 3 sequential reg writes */
582 LE32_OUT( &vb
[vbidx
++], (2 << 16) | ADRINDEX(MACH64_VERTEX_1_SECONDARY_S
) );
583 LE32_OUT( &vb
[vbidx
++], v0
->ui
[8] ); /* MACH64_VERTEX_1_SECONDARY_S */
584 LE32_OUT( &vb
[vbidx
++], v0
->ui
[9] ); /* MACH64_VERTEX_1_SECONDARY_T */
585 LE32_OUT( &vb
[vbidx
++], v0
->ui
[3] ); /* MACH64_VERTEX_1_SECONDARY_W */
588 /* setup for 3,5, or 7 sequential reg writes based on vertex format */
591 LE32_OUT( &vb
[vbidx
++], (4 << 16) | ADRINDEX(MACH64_VERTEX_2_W
) );
594 LE32_OUT( &vb
[vbidx
++], (2 << 16) | ADRINDEX(MACH64_VERTEX_2_Z
) );
596 default: /* vertsize >= 8 */
597 LE32_OUT( &vb
[vbidx
++], (6 << 16) | ADRINDEX(MACH64_VERTEX_2_S
) );
601 LE32_OUT( &vb
[vbidx
++], v1
->ui
[6] ); /* MACH64_VERTEX_2_S */
602 LE32_OUT( &vb
[vbidx
++], v1
->ui
[7] ); /* MACH64_VERTEX_2_T */
605 LE32_OUT( &vb
[vbidx
++], v1
->ui
[3] ); /* MACH64_VERTEX_2_W */
606 LE32_OUT( &vb
[vbidx
++], v1
->ui
[5] ); /* MACH64_VERTEX_2_SPEC_ARGB */
608 LE32_OUT( &vb
[vbidx
++], ((GLint
)(v1
->v
.z
) << 15) ); /* MACH64_VERTEX_2_Z */
609 vb
[vbidx
++] = v1
->ui
[coloridx
]; /* MACH64_VERTEX_2_ARGB */
610 LE32_OUT( &vb
[vbidx
++], (xx
[1] << 16) | (yy
[1] & 0xffff) ); /* MACH64_VERTEX_2_X_Y */
612 if (mmesa
->multitex
) {
613 /* setup for 3 sequential reg writes */
614 LE32_OUT( &vb
[vbidx
++], (2 << 16) | ADRINDEX(MACH64_VERTEX_2_SECONDARY_S
) );
615 LE32_OUT( &vb
[vbidx
++], v1
->ui
[8] ); /* MACH64_VERTEX_2_SECONDARY_S */
616 LE32_OUT( &vb
[vbidx
++], v1
->ui
[9] ); /* MACH64_VERTEX_2_SECONDARY_T */
617 LE32_OUT( &vb
[vbidx
++], v1
->ui
[3] ); /* MACH64_VERTEX_2_SECONDARY_W */
620 /* setup for 3,5, or 7 sequential reg writes based on vertex format */
623 LE32_OUT( &vb
[vbidx
++], (4 << 16) | ADRINDEX(MACH64_VERTEX_3_W
) );
626 LE32_OUT( &vb
[vbidx
++], (2 << 16) | ADRINDEX(MACH64_VERTEX_3_Z
) );
628 default: /* vertsize >= 8 */
629 LE32_OUT( &vb
[vbidx
++], (6 << 16) | ADRINDEX(MACH64_VERTEX_3_S
) );
633 LE32_OUT( &vb
[vbidx
++], v2
->ui
[6] ); /* MACH64_VERTEX_3_S */
634 LE32_OUT( &vb
[vbidx
++], v2
->ui
[7] ); /* MACH64_VERTEX_3_T */
637 LE32_OUT( &vb
[vbidx
++], v2
->ui
[3] ); /* MACH64_VERTEX_3_W */
638 LE32_OUT( &vb
[vbidx
++], v2
->ui
[5] ); /* MACH64_VERTEX_3_SPEC_ARGB */
640 LE32_OUT( &vb
[vbidx
++], ((GLint
)(v2
->v
.z
) << 15) ); /* MACH64_VERTEX_3_Z */
641 vb
[vbidx
++] = v2
->ui
[coloridx
]; /* MACH64_VERTEX_3_ARGB */
642 LE32_OUT( &vb
[vbidx
++], (xx
[2] << 16) | (yy
[2] & 0xffff) ); /* MACH64_VERTEX_3_X_Y */
644 if (mmesa
->multitex
) {
645 /* setup for 3 sequential reg writes */
646 LE32_OUT( &vb
[vbidx
++], (2 << 16) | ADRINDEX(MACH64_VERTEX_3_SECONDARY_S
) );
647 LE32_OUT( &vb
[vbidx
++], v2
->ui
[8] ); /* MACH64_VERTEX_3_SECONDARY_S */
648 LE32_OUT( &vb
[vbidx
++], v2
->ui
[9] ); /* MACH64_VERTEX_3_SECONDARY_T */
649 LE32_OUT( &vb
[vbidx
++], v2
->ui
[3] ); /* MACH64_VERTEX_3_SECONDARY_W */
652 LE32_OUT( &vb
[vbidx
++], ADRINDEX(MACH64_ONE_OVER_AREA_UC
) );
653 LE32_OUT( &vb
[vbidx
++], *(GLuint
*)&ooa
);
655 assert(vbsiz
== vbidx
);
657 #if MACH64_PRINT_BUFFER
660 fprintf(stderr
, "tri:\n");
661 for (i
= 0; i
< vbsiz
; ++i
)
662 fprintf(stderr
, " %08lx\n", *(vb
+ i
));
663 fprintf(stderr
, "\n");
669 static INLINE
void mach64_draw_line( mach64ContextPtr mmesa
,
673 #if MACH64_NATIVE_VTXFMT
674 struct gl_context
*ctx
= mmesa
->glCtx
;
675 const GLuint vertsize
= mmesa
->vertex_size
;
676 /* 2 fractional bits for hardware: */
677 const int width
= (int) (2.0 * CLAMP(mmesa
->glCtx
->Line
.Width
,
678 mmesa
->glCtx
->Const
.MinLineWidth
,
679 mmesa
->glCtx
->Const
.MaxLineWidth
));
682 GLuint xy0old
, xy0
, xy1old
, xy1
;
683 const GLuint xyoffset
= 9;
684 GLint x0
, y0
, x1
, y1
;
685 GLint dx
, dy
, ix
, iy
;
686 unsigned vbsiz
= (vertsize
+ (vertsize
> 7 ? 2 : 1)) * 4 + 2;
689 if ( MACH64_DEBUG
& DEBUG_VERBOSE_PRIMS
) {
690 fprintf(stderr
, "%s:\n", __FUNCTION__
);
691 fprintf(stderr
,"Vertex 1:\n");
692 mach64_print_vertex( ctx
, v0
);
693 fprintf(stderr
,"Vertex 2:\n");
694 mach64_print_vertex( ctx
, v1
);
697 pxy0
= &v0
->ui
[xyoffset
];
699 xy0
= LE32_IN( &xy0old
);
700 x0
= (GLshort
)( xy0
>> 16 );
701 y0
= (GLshort
)( xy0
& 0xffff );
703 pxy1
= &v1
->ui
[xyoffset
];
705 xy1
= LE32_IN( &xy1old
);
706 x1
= (GLshort
)( xy1
>> 16 );
707 y1
= (GLshort
)( xy1
& 0xffff );
709 if ( (dx
= x1
- x0
) < 0 ) {
712 if ( (dy
= y1
- y0
) < 0 ) {
716 /* adjust vertices depending on line direction */
720 ooa
= 8.0 / ((x1
- x0
) * width
);
724 ooa
= 8.0 / ((y0
- y1
) * width
);
727 vb
= (CARD32
*)mach64AllocDmaLow( mmesa
, vbsiz
* sizeof(CARD32
) );
730 LE32_OUT( pxy0
, (( x0
- ix
) << 16) | (( y0
- iy
) & 0xffff) );
731 COPY_VERTEX( vb
, vertsize
, v0
, 1 );
732 LE32_OUT( pxy1
, (( x1
- ix
) << 16) | (( y1
- iy
) & 0xffff) );
733 COPY_VERTEX( vb
, vertsize
, v1
, 2 );
734 LE32_OUT( pxy0
, (( x0
+ ix
) << 16) | (( y0
+ iy
) & 0xffff) );
735 COPY_VERTEX_OOA( vb
, vertsize
, v0
, 3 );
736 LE32_OUT( vb
++, *(CARD32
*)&ooa
);
740 LE32_OUT( pxy1
, (( x1
+ ix
) << 16) | (( y1
+ iy
) & 0xffff) );
741 COPY_VERTEX_OOA( vb
, vertsize
, v1
, 1 );
742 LE32_OUT( vb
++, *(CARD32
*)&ooa
);
746 #else /* !MACH64_NATIVE_VTXFMT */
747 GLuint vertsize
= mmesa
->vertex_size
;
749 float width
= 1.0; /* Only support 1 pix lines now */
751 GLint xx
[3], yy
[3]; /* 2 fractional bits for hardware */
755 (vertsize
> 6 ? 2 : 0) +
756 (vertsize
> 4 ? 2 : 0) +
758 (mmesa
->multitex
? 4 : 0)
763 GLfloat hw
, dx
, dy
, ix
, iy
;
764 GLfloat x0
= v0
->v
.x
;
765 GLfloat y0
= v0
->v
.y
;
766 GLfloat x1
= v1
->v
.x
;
767 GLfloat y1
= v1
->v
.y
;
769 #if MACH64_CLIENT_STATE_EMITS
770 /* Enable for interleaved client-side state emits */
771 LOCK_HARDWARE( mmesa
);
772 if ( mmesa
->dirty
) {
773 mach64EmitHwStateLocked( mmesa
);
775 if ( mmesa
->sarea
->dirty
) {
776 mach64UploadHwStateLocked( mmesa
);
778 UNLOCK_HARDWARE( mmesa
);
781 if ( MACH64_DEBUG
& DEBUG_VERBOSE_PRIMS
) {
782 fprintf(stderr
, "%s:\n", __FUNCTION__
);
783 fprintf(stderr
,"Vertex 1: x: %.2f, y: %.2f, z: %.2f, w: %f\n",
784 v0
->v
.x
, v0
->v
.y
, v0
->v
.z
, v0
->v
.w
);
785 fprintf(stderr
,"Vertex 2: x: %.2f, y: %.2f, z: %.2f, w: %f\n",
786 v1
->v
.x
, v1
->v
.y
, v1
->v
.z
, v1
->v
.w
);
790 if (hw
> 0.1F
&& hw
< 0.5F
) {
794 /* adjust vertices depending on line direction */
795 dx
= v0
->v
.x
- v1
->v
.x
;
796 dy
= v0
->v
.y
- v1
->v
.y
;
797 if (dx
* dx
> dy
* dy
) {
820 xx
[0] = (GLint
)((x0
- ix
) * 4);
821 yy
[0] = (GLint
)((y0
- iy
) * 4);
823 xx
[1] = (GLint
)((x1
- ix
) * 4);
824 yy
[1] = (GLint
)((y1
- iy
) * 4);
826 xx
[2] = (GLint
)((x0
+ ix
) * 4);
827 yy
[2] = (GLint
)((y0
+ iy
) * 4);
829 ooa
= 0.25 * 0.25 * ((xx
[0] - xx
[2]) * (yy
[1] - yy
[2]) -
830 (yy
[0] - yy
[2]) * (xx
[1] - xx
[2]));
832 if ( ooa
* mmesa
->backface_sign
< 0 ) {
834 if ( MACH64_DEBUG
& DEBUG_VERBOSE_PRIMS
)
835 fprintf(stderr
,"Line culled\n");
839 vb
= (CARD32
*)mach64AllocDmaLow( mmesa
, vbsiz
* 4 );
843 coloridx
= (vertsize
> 4) ? 4: 3;
845 /* setup for 3,5, or 7 sequential reg writes based on vertex format */
848 LE32_OUT( &vb
[vbidx
++], (4 << 16) | ADRINDEX(MACH64_VERTEX_1_W
) );
851 LE32_OUT( &vb
[vbidx
++], (2 << 16) | ADRINDEX(MACH64_VERTEX_1_Z
) );
853 default: /* vertsize >= 8 */
854 LE32_OUT( &vb
[vbidx
++], (6 << 16) | ADRINDEX(MACH64_VERTEX_1_S
) );
858 LE32_OUT( &vb
[vbidx
++], v0
->ui
[6] ); /* MACH64_VERTEX_1_S */
859 LE32_OUT( &vb
[vbidx
++], v0
->ui
[7] ); /* MACH64_VERTEX_1_T */
862 LE32_OUT( &vb
[vbidx
++], v0
->ui
[3] ); /* MACH64_VERTEX_1_W */
863 LE32_OUT( &vb
[vbidx
++], v0
->ui
[5] ); /* MACH64_VERTEX_1_SPEC_ARGB */
865 LE32_OUT( &vb
[vbidx
++], ((GLint
)(v0
->v
.z
) << 15) ); /* MACH64_VERTEX_1_Z */
866 vb
[vbidx
++] = v0
->ui
[coloridx
]; /* MACH64_VERTEX_1_ARGB */
867 LE32_OUT( &vb
[vbidx
++], (xx
[0] << 16) | (yy
[0] & 0xffff) ); /* MACH64_VERTEX_1_X_Y */
869 /* setup for 3,5, or 7 sequential reg writes based on vertex format */
872 LE32_OUT( &vb
[vbidx
++], (4 << 16) | ADRINDEX(MACH64_VERTEX_2_W
) );
875 LE32_OUT( &vb
[vbidx
++], (2 << 16) | ADRINDEX(MACH64_VERTEX_2_Z
) );
877 default: /* vertsize >= 8 */
878 LE32_OUT( &vb
[vbidx
++], (6 << 16) | ADRINDEX(MACH64_VERTEX_2_S
) );
882 LE32_OUT( &vb
[vbidx
++], v1
->ui
[6] ); /* MACH64_VERTEX_2_S */
883 LE32_OUT( &vb
[vbidx
++], v1
->ui
[7] ); /* MACH64_VERTEX_2_T */
886 LE32_OUT( &vb
[vbidx
++], v1
->ui
[3] ); /* MACH64_VERTEX_2_W */
887 LE32_OUT( &vb
[vbidx
++], v1
->ui
[5] ); /* MACH64_VERTEX_2_SPEC_ARGB */
889 LE32_OUT( &vb
[vbidx
++], ((GLint
)(v1
->v
.z
) << 15) ); /* MACH64_VERTEX_2_Z */
890 vb
[vbidx
++] = v1
->ui
[coloridx
]; /* MACH64_VERTEX_2_ARGB */
891 LE32_OUT( &vb
[vbidx
++], (xx
[1] << 16) | (yy
[1] & 0xffff) ); /* MACH64_VERTEX_2_X_Y */
893 /* setup for 3,5, or 7 sequential reg writes based on vertex format */
896 LE32_OUT( &vb
[vbidx
++], (4 << 16) | ADRINDEX(MACH64_VERTEX_3_W
) );
899 LE32_OUT( &vb
[vbidx
++], (2 << 16) | ADRINDEX(MACH64_VERTEX_3_Z
) );
901 default: /* vertsize >= 8 */
902 LE32_OUT( &vb
[vbidx
++], (6 << 16) | ADRINDEX(MACH64_VERTEX_3_S
) );
906 LE32_OUT( &vb
[vbidx
++], v0
->ui
[6] ); /* MACH64_VERTEX_3_S */
907 LE32_OUT( &vb
[vbidx
++], v0
->ui
[7] ); /* MACH64_VERTEX_3_T */
910 LE32_OUT( &vb
[vbidx
++], v0
->ui
[3] ); /* MACH64_VERTEX_3_W */
911 LE32_OUT( &vb
[vbidx
++], v0
->ui
[5] ); /* MACH64_VERTEX_3_SPEC_ARGB */
913 LE32_OUT( &vb
[vbidx
++], ((GLint
)(v0
->v
.z
) << 15) ); /* MACH64_VERTEX_3_Z */
914 vb
[vbidx
++] = v0
->ui
[coloridx
]; /* MACH64_VERTEX_3_ARGB */
915 LE32_OUT( &vb
[vbidx
++], (xx
[2] << 16) | (yy
[2] & 0xffff) ); /* MACH64_VERTEX_3_X_Y */
917 LE32_OUT( &vb
[vbidx
++], ADRINDEX(MACH64_ONE_OVER_AREA_UC
) );
918 LE32_OUT( &vb
[vbidx
++], *(GLuint
*)&ooa
);
920 xx
[0] = (GLint
)((x1
+ ix
) * 4);
921 yy
[0] = (GLint
)((y1
+ iy
) * 4);
923 ooa
= 0.25 * 0.25 * ((xx
[0] - xx
[2]) * (yy
[1] - yy
[2]) -
924 (yy
[0] - yy
[2]) * (xx
[1] - xx
[2]));
927 /* setup for 3,5, or 7 sequential reg writes based on vertex format */
930 LE32_OUT( &vb
[vbidx
++], (4 << 16) | ADRINDEX(MACH64_VERTEX_1_W
) );
933 LE32_OUT( &vb
[vbidx
++], (2 << 16) | ADRINDEX(MACH64_VERTEX_1_Z
) );
935 default: /* vertsize >= 8 */
936 LE32_OUT( &vb
[vbidx
++], (6 << 16) | ADRINDEX(MACH64_VERTEX_1_S
) );
940 LE32_OUT( &vb
[vbidx
++], v1
->ui
[6] ); /* MACH64_VERTEX_1_S */
941 LE32_OUT( &vb
[vbidx
++], v1
->ui
[7] ); /* MACH64_VERTEX_1_T */
944 LE32_OUT( &vb
[vbidx
++], v1
->ui
[3] ); /* MACH64_VERTEX_1_W */
945 LE32_OUT( &vb
[vbidx
++], v1
->ui
[5] ); /* MACH64_VERTEX_1_SPEC_ARGB */
947 LE32_OUT( &vb
[vbidx
++], ((GLint
)(v1
->v
.z
) << 15) ); /* MACH64_VERTEX_1_Z */
948 vb
[vbidx
++] = v1
->ui
[coloridx
]; /* MACH64_VERTEX_1_ARGB */
949 LE32_OUT( &vb
[vbidx
++], (xx
[0] << 16) | (yy
[0] & 0xffff) ); /* MACH64_VERTEX_1_X_Y */
951 LE32_OUT( &vb
[vbidx
++], ADRINDEX(MACH64_ONE_OVER_AREA_UC
) );
952 LE32_OUT( &vb
[vbidx
++], *(GLuint
*)&ooa
);
954 assert(vbsiz
== vbidx
);
958 static INLINE
void mach64_draw_point( mach64ContextPtr mmesa
,
961 #if MACH64_NATIVE_VTXFMT
962 struct gl_context
*ctx
= mmesa
->glCtx
;
963 const GLuint vertsize
= mmesa
->vertex_size
;
964 /* 2 fractional bits for hardware: */
965 GLint sz
= (GLint
) (2.0 * CLAMP(mmesa
->glCtx
->Point
.Size
,
966 ctx
->Const
.MinPointSize
,
967 ctx
->Const
.MaxPointSize
));
971 const GLuint xyoffset
= 9;
973 unsigned vbsiz
= (vertsize
+ (vertsize
> 7 ? 2 : 1)) * 4 + 2;
976 if ( MACH64_DEBUG
& DEBUG_VERBOSE_PRIMS
) {
977 fprintf(stderr
, "%s:\n", __FUNCTION__
);
978 fprintf(stderr
,"Vertex 1:\n");
979 mach64_print_vertex( ctx
, v0
);
983 sz
= 1; /* round to the nearest supported size */
985 pxy
= &v0
->ui
[xyoffset
];
987 xy
= LE32_IN( &xyold
);
988 x
= (GLshort
)( xy
>> 16 );
989 y
= (GLshort
)( xy
& 0xffff );
991 ooa
= 4.0 / (sz
* sz
);
993 vb
= (CARD32
*)mach64AllocDmaLow( mmesa
, vbsiz
* sizeof(CARD32
) );
996 LE32_OUT( pxy
, (( x
- sz
) << 16) | (( y
- sz
) & 0xffff) );
997 COPY_VERTEX( vb
, vertsize
, v0
, 1 );
998 LE32_OUT( pxy
, (( x
+ sz
) << 16) | (( y
- sz
) & 0xffff) );
999 COPY_VERTEX( vb
, vertsize
, v0
, 2 );
1000 LE32_OUT( pxy
, (( x
- sz
) << 16) | (( y
+ sz
) & 0xffff) );
1001 COPY_VERTEX_OOA( vb
, vertsize
, v0
, 3 );
1002 LE32_OUT( vb
++, *(CARD32
*)&ooa
);
1006 LE32_OUT( pxy
, (( x
+ sz
) << 16) | (( y
+ sz
) & 0xffff) );
1007 COPY_VERTEX_OOA( vb
, vertsize
, v0
, 1 );
1008 LE32_OUT( vb
++, *(CARD32
*)&ooa
);
1011 #else /* !MACH64_NATIVE_VTXFMT */
1012 GLuint vertsize
= mmesa
->vertex_size
;
1014 float sz
= 1.0; /* Only support 1 pix points now */
1016 GLint xx
[3], yy
[3]; /* 2 fractional bits for hardware */
1020 (vertsize
> 6 ? 2 : 0) +
1021 (vertsize
> 4 ? 2 : 0) +
1023 (mmesa
->multitex
? 4 : 0)
1028 if ( MACH64_DEBUG
& DEBUG_VERBOSE_PRIMS
) {
1029 fprintf(stderr
, "%s:\n", __FUNCTION__
);
1030 fprintf(stderr
,"Vertex 1: x: %.2f, y: %.2f, z: %.2f, w: %f\n",
1031 v0
->v
.x
, v0
->v
.y
, v0
->v
.z
, v0
->v
.w
);
1034 #if MACH64_CLIENT_STATE_EMITS
1035 /* Enable for interleaved client-side state emits */
1036 LOCK_HARDWARE( mmesa
);
1037 if ( mmesa
->dirty
) {
1038 mach64EmitHwStateLocked( mmesa
);
1040 if ( mmesa
->sarea
->dirty
) {
1041 mach64UploadHwStateLocked( mmesa
);
1043 UNLOCK_HARDWARE( mmesa
);
1046 xx
[0] = (GLint
)((v0
->v
.x
- sz
) * 4);
1047 yy
[0] = (GLint
)((v0
->v
.y
- sz
) * 4);
1049 xx
[1] = (GLint
)((v0
->v
.x
+ sz
) * 4);
1050 yy
[1] = (GLint
)((v0
->v
.y
- sz
) * 4);
1052 xx
[2] = (GLint
)((v0
->v
.x
- sz
) * 4);
1053 yy
[2] = (GLint
)((v0
->v
.y
+ sz
) * 4);
1055 ooa
= 0.25 * 0.25 * ((xx
[0] - xx
[2]) * (yy
[1] - yy
[2]) -
1056 (yy
[0] - yy
[2]) * (xx
[1] - xx
[2]));
1058 if ( ooa
* mmesa
->backface_sign
< 0 ) {
1060 if ( MACH64_DEBUG
& DEBUG_VERBOSE_PRIMS
)
1061 fprintf(stderr
,"Point culled\n");
1065 vb
= (CARD32
*)mach64AllocDmaLow( mmesa
, vbsiz
* 4 );
1069 coloridx
= (vertsize
> 4) ? 4: 3;
1071 /* setup for 3,5, or 7 sequential reg writes based on vertex format */
1074 LE32_OUT( &vb
[vbidx
++], (4 << 16) | ADRINDEX(MACH64_VERTEX_1_W
) );
1077 LE32_OUT( &vb
[vbidx
++], (2 << 16) | ADRINDEX(MACH64_VERTEX_1_Z
) );
1079 default: /* vertsize >= 8 */
1080 LE32_OUT( &vb
[vbidx
++], (6 << 16) | ADRINDEX(MACH64_VERTEX_1_S
) );
1084 LE32_OUT( &vb
[vbidx
++], v0
->ui
[6] ); /* MACH64_VERTEX_1_S */
1085 LE32_OUT( &vb
[vbidx
++], v0
->ui
[7] ); /* MACH64_VERTEX_1_T */
1088 LE32_OUT( &vb
[vbidx
++], v0
->ui
[3] ); /* MACH64_VERTEX_1_W */
1089 LE32_OUT( &vb
[vbidx
++], v0
->ui
[5] ); /* MACH64_VERTEX_1_SPEC_ARGB */
1091 LE32_OUT( &vb
[vbidx
++], ((GLint
)(v0
->v
.z
) << 15) ); /* MACH64_VERTEX_1_Z */
1092 vb
[vbidx
++] = v0
->ui
[coloridx
]; /* MACH64_VERTEX_1_ARGB */
1093 LE32_OUT( &vb
[vbidx
++], (xx
[0] << 16) | (yy
[0] & 0xffff) ); /* MACH64_VERTEX_1_X_Y */
1095 /* setup for 3,5, or 7 sequential reg writes based on vertex format */
1098 LE32_OUT( &vb
[vbidx
++], (4 << 16) | ADRINDEX(MACH64_VERTEX_2_W
) );
1101 LE32_OUT( &vb
[vbidx
++], (2 << 16) | ADRINDEX(MACH64_VERTEX_2_Z
) );
1103 default: /* vertsize >= 8 */
1104 LE32_OUT( &vb
[vbidx
++], (6 << 16) | ADRINDEX(MACH64_VERTEX_2_S
) );
1108 LE32_OUT( &vb
[vbidx
++], v0
->ui
[6] ); /* MACH64_VERTEX_2_S */
1109 LE32_OUT( &vb
[vbidx
++], v0
->ui
[7] ); /* MACH64_VERTEX_2_T */
1112 LE32_OUT( &vb
[vbidx
++], v0
->ui
[3] ); /* MACH64_VERTEX_2_W */
1113 LE32_OUT( &vb
[vbidx
++], v0
->ui
[5] ); /* MACH64_VERTEX_2_SPEC_ARGB */
1115 LE32_OUT( &vb
[vbidx
++], ((GLint
)(v0
->v
.z
) << 15) ); /* MACH64_VERTEX_2_Z */
1116 vb
[vbidx
++] = v0
->ui
[coloridx
]; /* MACH64_VERTEX_2_ARGB */
1117 LE32_OUT( &vb
[vbidx
++], (xx
[1] << 16) | (yy
[1] & 0xffff) ); /* MACH64_VERTEX_2_X_Y */
1119 /* setup for 3,5, or 7 sequential reg writes based on vertex format */
1122 LE32_OUT( &vb
[vbidx
++], (4 << 16) | ADRINDEX(MACH64_VERTEX_3_W
) );
1125 LE32_OUT( &vb
[vbidx
++], (2 << 16) | ADRINDEX(MACH64_VERTEX_3_Z
) );
1127 default: /* vertsize >= 8 */
1128 LE32_OUT( &vb
[vbidx
++], (6 << 16) | ADRINDEX(MACH64_VERTEX_3_S
) );
1132 LE32_OUT( &vb
[vbidx
++], v0
->ui
[6] ); /* MACH64_VERTEX_3_S */
1133 LE32_OUT( &vb
[vbidx
++], v0
->ui
[7] ); /* MACH64_VERTEX_3_T */
1136 LE32_OUT( &vb
[vbidx
++], v0
->ui
[3] ); /* MACH64_VERTEX_3_W */
1137 LE32_OUT( &vb
[vbidx
++], v0
->ui
[5] ); /* MACH64_VERTEX_3_SPEC_ARGB */
1139 LE32_OUT( &vb
[vbidx
++], ((GLint
)(v0
->v
.z
) << 15) ); /* MACH64_VERTEX_3_Z */
1140 vb
[vbidx
++] = v0
->ui
[coloridx
]; /* MACH64_VERTEX_3_ARGB */
1141 LE32_OUT( &vb
[vbidx
++], (xx
[2] << 16) | (yy
[2] & 0xffff) ); /* MACH64_VERTEX_3_X_Y */
1143 LE32_OUT( &vb
[vbidx
++], ADRINDEX(MACH64_ONE_OVER_AREA_UC
) );
1144 LE32_OUT( &vb
[vbidx
++], *(GLuint
*)&ooa
);
1146 xx
[0] = (GLint
)((v0
->v
.x
+ sz
) * 4);
1147 yy
[0] = (GLint
)((v0
->v
.y
+ sz
) * 4);
1149 ooa
= 0.25 * 0.25 * ((xx
[0] - xx
[2]) * (yy
[1] - yy
[2]) -
1150 (yy
[0] - yy
[2]) * (xx
[1] - xx
[2]));
1153 /* setup for 3,5, or 7 sequential reg writes based on vertex format */
1156 LE32_OUT( &vb
[vbidx
++], (4 << 16) | ADRINDEX(MACH64_VERTEX_1_W
) );
1159 LE32_OUT( &vb
[vbidx
++], (2 << 16) | ADRINDEX(MACH64_VERTEX_1_Z
) );
1161 default: /* vertsize >= 8 */
1162 LE32_OUT( &vb
[vbidx
++], (6 << 16) | ADRINDEX(MACH64_VERTEX_1_S
) );
1166 LE32_OUT( &vb
[vbidx
++], v0
->ui
[6] ); /* MACH64_VERTEX_1_S */
1167 LE32_OUT( &vb
[vbidx
++], v0
->ui
[7] ); /* MACH64_VERTEX_1_T */
1170 LE32_OUT( &vb
[vbidx
++], v0
->ui
[3] ); /* MACH64_VERTEX_1_W */
1171 LE32_OUT( &vb
[vbidx
++], v0
->ui
[5] ); /* MACH64_VERTEX_1_SPEC_ARGB */
1173 LE32_OUT( &vb
[vbidx
++], ((GLint
)(v0
->v
.z
) << 15) ); /* MACH64_VERTEX_1_Z */
1174 vb
[vbidx
++] = v0
->ui
[coloridx
]; /* MACH64_VERTEX_1_ARGB */
1175 LE32_OUT( &vb
[vbidx
++], (xx
[0] << 16) | (yy
[0] & 0xffff) ); /* MACH64_VERTEX_1_X_Y */
1177 LE32_OUT( &vb
[vbidx
++], ADRINDEX(MACH64_ONE_OVER_AREA_UC
) );
1178 LE32_OUT( &vb
[vbidx
++], *(GLuint
*)&ooa
);
1180 assert(vbsiz
== vbidx
);
1184 /***********************************************************************
1185 * Macros for t_dd_tritmp.h to draw basic primitives *
1186 ***********************************************************************/
1188 #define TRI( a, b, c ) \
1191 mmesa->draw_tri( mmesa, a, b, c ); \
1193 mach64_draw_triangle( mmesa, a, b, c ); \
1196 #define QUAD( a, b, c, d ) \
1198 if (DO_FALLBACK) { \
1199 mmesa->draw_tri( mmesa, a, b, d ); \
1200 mmesa->draw_tri( mmesa, b, c, d ); \
1202 mach64_draw_quad( mmesa, a, b, c, d ); \
1205 #define LINE( v0, v1 ) \
1208 mmesa->draw_line( mmesa, v0, v1 ); \
1210 mach64_draw_line( mmesa, v0, v1 ); \
1213 #define POINT( v0 ) \
1216 mmesa->draw_point( mmesa, v0 ); \
1218 mach64_draw_point( mmesa, v0 ); \
1222 /***********************************************************************
1223 * Build render functions from dd templates *
1224 ***********************************************************************/
1226 #define MACH64_OFFSET_BIT 0x01
1227 #define MACH64_TWOSIDE_BIT 0x02
1228 #define MACH64_UNFILLED_BIT 0x04
1229 #define MACH64_FALLBACK_BIT 0x08
1230 #define MACH64_MAX_TRIFUNC 0x10
1233 tnl_points_func points
;
1235 tnl_triangle_func triangle
;
1237 } rast_tab
[MACH64_MAX_TRIFUNC
];
1240 #define DO_FALLBACK (IND & MACH64_FALLBACK_BIT)
1241 #define DO_OFFSET (IND & MACH64_OFFSET_BIT)
1242 #define DO_UNFILLED (IND & MACH64_UNFILLED_BIT)
1243 #define DO_TWOSIDE (IND & MACH64_TWOSIDE_BIT)
1249 #define DO_FULL_QUAD 1
1252 #define HAVE_BACK_COLORS 0
1253 #define HAVE_HW_FLATSHADE 1
1254 #define VERTEX mach64Vertex
1255 #define TAB rast_tab
1257 #if MACH64_NATIVE_VTXFMT
1259 /* #define DEPTH_SCALE 65536.0 */
1260 #define DEPTH_SCALE 1
1261 #define UNFILLED_TRI unfilled_tri
1262 #define UNFILLED_QUAD unfilled_quad
1263 #define VERT_X(_v) ((GLfloat)(GLshort)(LE32_IN( &(_v)->ui[xyoffset] ) & 0xffff) / 4.0)
1264 #define VERT_Y(_v) ((GLfloat)(GLshort)(LE32_IN( &(_v)->ui[xyoffset] ) >> 16) / 4.0)
1265 #define VERT_Z(_v) ((GLfloat) LE32_IN( &(_v)->ui[zoffset] ))
1266 #define INSANE_VERTICES
1267 #define VERT_SET_Z(_v,val) LE32_OUT( &(_v)->ui[zoffset], (GLuint)(val) )
1268 #define VERT_Z_ADD(_v,val) LE32_OUT( &(_v)->ui[zoffset], LE32_IN( &(_v)->ui[zoffset] ) + (GLuint)(val) )
1269 #define AREA_IS_CCW( a ) ((a) < 0)
1270 #define GET_VERTEX(e) (mmesa->verts + ((e) * mmesa->vertex_size * sizeof(int)))
1272 #define MACH64_COLOR( dst, src ) \
1274 UNCLAMPED_FLOAT_TO_UBYTE(dst[0], src[2]); \
1275 UNCLAMPED_FLOAT_TO_UBYTE(dst[1], src[1]); \
1276 UNCLAMPED_FLOAT_TO_UBYTE(dst[2], src[0]); \
1277 UNCLAMPED_FLOAT_TO_UBYTE(dst[3], src[3]); \
1280 #define MACH64_SPEC( dst, src ) \
1282 UNCLAMPED_FLOAT_TO_UBYTE(dst[0], src[2]); \
1283 UNCLAMPED_FLOAT_TO_UBYTE(dst[1], src[1]); \
1284 UNCLAMPED_FLOAT_TO_UBYTE(dst[2], src[0]); \
1287 #define VERT_SET_RGBA( v, c ) MACH64_COLOR( v->ub4[coloroffset], c )
1288 #define VERT_COPY_RGBA( v0, v1 ) v0->ui[coloroffset] = v1->ui[coloroffset]
1289 #define VERT_SAVE_RGBA( idx ) color[idx] = v[idx]->ui[coloroffset]
1290 #define VERT_RESTORE_RGBA( idx ) v[idx]->ui[coloroffset] = color[idx]
1292 #define VERT_SET_SPEC( v, c ) if (havespec) MACH64_SPEC( v->ub4[specoffset], c )
1293 #define VERT_COPY_SPEC( v0, v1 ) if (havespec) COPY_3V( v0->ub4[specoffset], v1->ub4[specoffset] )
1294 #define VERT_SAVE_SPEC( idx ) if (havespec) spec[idx] = v[idx]->ui[specoffset]
1295 #define VERT_RESTORE_SPEC( idx ) if (havespec) v[idx]->ui[specoffset] = spec[idx]
1297 #define LOCAL_VARS(n) \
1298 mach64ContextPtr mmesa = MACH64_CONTEXT(ctx); \
1299 GLuint color[n] = { 0 }; \
1300 GLuint spec[n] = { 0 }; \
1301 GLuint vertex_size = mmesa->vertex_size; \
1302 const GLuint xyoffset = 9; \
1303 const GLuint coloroffset = 8; \
1304 const GLuint zoffset = 7; \
1305 const GLuint specoffset = 6; \
1306 GLboolean havespec = vertex_size >= 4 ? 1 : 0; \
1307 (void) color; (void) spec; (void) vertex_size; \
1308 (void) xyoffset; (void) coloroffset; (void) zoffset; \
1309 (void) specoffset; (void) havespec;
1313 #define DEPTH_SCALE 1.0
1314 #define UNFILLED_TRI unfilled_tri
1315 #define UNFILLED_QUAD unfilled_quad
1316 #define VERT_X(_v) _v->v.x
1317 #define VERT_Y(_v) _v->v.y
1318 #define VERT_Z(_v) _v->v.z
1319 #define AREA_IS_CCW( a ) (a > 0)
1320 #define GET_VERTEX(e) (mmesa->verts + ((e) * mmesa->vertex_size * sizeof(int)))
1322 #define MACH64_COLOR( dst, src ) \
1324 UNCLAMPED_FLOAT_TO_UBYTE(dst[0], src[2]); \
1325 UNCLAMPED_FLOAT_TO_UBYTE(dst[1], src[1]); \
1326 UNCLAMPED_FLOAT_TO_UBYTE(dst[2], src[0]); \
1327 UNCLAMPED_FLOAT_TO_UBYTE(dst[3], src[3]); \
1330 #define MACH64_SPEC( dst, src ) \
1332 UNCLAMPED_FLOAT_TO_UBYTE(dst[0], src[2]); \
1333 UNCLAMPED_FLOAT_TO_UBYTE(dst[1], src[1]); \
1334 UNCLAMPED_FLOAT_TO_UBYTE(dst[2], src[0]); \
1337 #define VERT_SET_RGBA( v, c ) MACH64_COLOR( v->ub4[coloroffset], c )
1338 #define VERT_COPY_RGBA( v0, v1 ) v0->ui[coloroffset] = v1->ui[coloroffset]
1339 #define VERT_SAVE_RGBA( idx ) color[idx] = v[idx]->ui[coloroffset]
1340 #define VERT_RESTORE_RGBA( idx ) v[idx]->ui[coloroffset] = color[idx]
1342 #define VERT_SET_SPEC( v, c ) if (havespec) MACH64_SPEC( v->ub4[5], c )
1343 #define VERT_COPY_SPEC( v0, v1 ) if (havespec) COPY_3V(v0->ub4[5], v1->ub4[5])
1344 #define VERT_SAVE_SPEC( idx ) if (havespec) spec[idx] = v[idx]->ui[5]
1345 #define VERT_RESTORE_SPEC( idx ) if (havespec) v[idx]->ui[5] = spec[idx]
1347 #define LOCAL_VARS(n) \
1348 mach64ContextPtr mmesa = MACH64_CONTEXT(ctx); \
1349 GLuint color[n], spec[n]; \
1350 GLuint coloroffset = (mmesa->vertex_size == 4 ? 3 : 4); \
1351 GLboolean havespec = (mmesa->vertex_size == 4 ? 0 : 1); \
1352 (void) color; (void) spec; (void) coloroffset; (void) havespec;
1356 /***********************************************************************
1357 * Helpers for rendering unfilled primitives *
1358 ***********************************************************************/
1360 #define RASTERIZE(x) if (mmesa->hw_primitive != hw_prim[x]) \
1361 mach64RasterPrimitive( ctx, hw_prim[x] )
1362 #define RENDER_PRIMITIVE mmesa->render_primitive
1363 #define IND MACH64_FALLBACK_BIT
1365 #include "tnl_dd/t_dd_unfilled.h"
1369 /***********************************************************************
1370 * Generate GL render functions *
1371 ***********************************************************************/
1376 #include "tnl_dd/t_dd_tritmp.h"
1378 #define IND (MACH64_OFFSET_BIT)
1379 #define TAG(x) x##_offset
1380 #include "tnl_dd/t_dd_tritmp.h"
1382 #define IND (MACH64_TWOSIDE_BIT)
1383 #define TAG(x) x##_twoside
1384 #include "tnl_dd/t_dd_tritmp.h"
1386 #define IND (MACH64_TWOSIDE_BIT|MACH64_OFFSET_BIT)
1387 #define TAG(x) x##_twoside_offset
1388 #include "tnl_dd/t_dd_tritmp.h"
1390 #define IND (MACH64_UNFILLED_BIT)
1391 #define TAG(x) x##_unfilled
1392 #include "tnl_dd/t_dd_tritmp.h"
1394 #define IND (MACH64_OFFSET_BIT|MACH64_UNFILLED_BIT)
1395 #define TAG(x) x##_offset_unfilled
1396 #include "tnl_dd/t_dd_tritmp.h"
1398 #define IND (MACH64_TWOSIDE_BIT|MACH64_UNFILLED_BIT)
1399 #define TAG(x) x##_twoside_unfilled
1400 #include "tnl_dd/t_dd_tritmp.h"
1402 #define IND (MACH64_TWOSIDE_BIT|MACH64_OFFSET_BIT|MACH64_UNFILLED_BIT)
1403 #define TAG(x) x##_twoside_offset_unfilled
1404 #include "tnl_dd/t_dd_tritmp.h"
1406 #define IND (MACH64_FALLBACK_BIT)
1407 #define TAG(x) x##_fallback
1408 #include "tnl_dd/t_dd_tritmp.h"
1410 #define IND (MACH64_OFFSET_BIT|MACH64_FALLBACK_BIT)
1411 #define TAG(x) x##_offset_fallback
1412 #include "tnl_dd/t_dd_tritmp.h"
1414 #define IND (MACH64_TWOSIDE_BIT|MACH64_FALLBACK_BIT)
1415 #define TAG(x) x##_twoside_fallback
1416 #include "tnl_dd/t_dd_tritmp.h"
1418 #define IND (MACH64_TWOSIDE_BIT|MACH64_OFFSET_BIT|MACH64_FALLBACK_BIT)
1419 #define TAG(x) x##_twoside_offset_fallback
1420 #include "tnl_dd/t_dd_tritmp.h"
1422 #define IND (MACH64_UNFILLED_BIT|MACH64_FALLBACK_BIT)
1423 #define TAG(x) x##_unfilled_fallback
1424 #include "tnl_dd/t_dd_tritmp.h"
1426 #define IND (MACH64_OFFSET_BIT|MACH64_UNFILLED_BIT|MACH64_FALLBACK_BIT)
1427 #define TAG(x) x##_offset_unfilled_fallback
1428 #include "tnl_dd/t_dd_tritmp.h"
1430 #define IND (MACH64_TWOSIDE_BIT|MACH64_UNFILLED_BIT|MACH64_FALLBACK_BIT)
1431 #define TAG(x) x##_twoside_unfilled_fallback
1432 #include "tnl_dd/t_dd_tritmp.h"
1434 #define IND (MACH64_TWOSIDE_BIT|MACH64_OFFSET_BIT|MACH64_UNFILLED_BIT| \
1435 MACH64_FALLBACK_BIT)
1436 #define TAG(x) x##_twoside_offset_unfilled_fallback
1437 #include "tnl_dd/t_dd_tritmp.h"
1440 static void init_rast_tab( void )
1445 init_twoside_offset();
1447 init_offset_unfilled();
1448 init_twoside_unfilled();
1449 init_twoside_offset_unfilled();
1451 init_offset_fallback();
1452 init_twoside_fallback();
1453 init_twoside_offset_fallback();
1454 init_unfilled_fallback();
1455 init_offset_unfilled_fallback();
1456 init_twoside_unfilled_fallback();
1457 init_twoside_offset_unfilled_fallback();
1461 /***********************************************************************
1462 * Rasterization fallback helpers *
1463 ***********************************************************************/
1466 /* This code is hit only when a mix of accelerated and unaccelerated
1467 * primitives are being drawn, and only for the unaccelerated
1471 mach64_fallback_tri( mach64ContextPtr mmesa
,
1476 struct gl_context
*ctx
= mmesa
->glCtx
;
1478 mach64_translate_vertex( ctx
, v0
, &v
[0] );
1479 mach64_translate_vertex( ctx
, v1
, &v
[1] );
1480 mach64_translate_vertex( ctx
, v2
, &v
[2] );
1481 _swrast_Triangle( ctx
, &v
[0], &v
[1], &v
[2] );
1486 mach64_fallback_line( mach64ContextPtr mmesa
,
1490 struct gl_context
*ctx
= mmesa
->glCtx
;
1492 mach64_translate_vertex( ctx
, v0
, &v
[0] );
1493 mach64_translate_vertex( ctx
, v1
, &v
[1] );
1494 _swrast_Line( ctx
, &v
[0], &v
[1] );
1499 mach64_fallback_point( mach64ContextPtr mmesa
,
1502 struct gl_context
*ctx
= mmesa
->glCtx
;
1504 mach64_translate_vertex( ctx
, v0
, &v
[0] );
1505 _swrast_Point( ctx
, &v
[0] );
1510 /**********************************************************************/
1511 /* Render unclipped begin/end objects */
1512 /**********************************************************************/
1514 #define VERT(x) (mach64Vertex *)(mach64verts + ((x) * vertsize * sizeof(int)))
1515 #define RENDER_POINTS( start, count ) \
1516 for ( ; start < count ; start++) \
1517 mach64_draw_point( mmesa, VERT(start) )
1518 #define RENDER_LINE( v0, v1 ) \
1519 mach64_draw_line( mmesa, VERT(v0), VERT(v1) )
1520 #define RENDER_TRI( v0, v1, v2 ) \
1521 mach64_draw_triangle( mmesa, VERT(v0), VERT(v1), VERT(v2) )
1522 #define RENDER_QUAD( v0, v1, v2, v3 ) \
1523 mach64_draw_quad( mmesa, VERT(v0), VERT(v1), VERT(v2), VERT(v3) )
1524 #define INIT(x) do { \
1525 if (0) fprintf(stderr, "%s\n", __FUNCTION__); \
1526 mach64RenderPrimitive( ctx, x ); \
1529 #define LOCAL_VARS \
1530 mach64ContextPtr mmesa = MACH64_CONTEXT(ctx); \
1531 const GLuint vertsize = mmesa->vertex_size; \
1532 const char *mach64verts = (char *)mmesa->verts; \
1533 const GLuint * const elt = TNL_CONTEXT(ctx)->vb.Elts; \
1535 #define RESET_STIPPLE
1536 #define RESET_OCCLUSION
1537 #define PRESERVE_VB_DEFS
1539 #define TAG(x) mach64_##x##_verts
1540 #include "tnl/t_vb_rendertmp.h"
1543 #define TAG(x) mach64_##x##_elts
1544 #define ELT(x) elt[x]
1545 #include "tnl/t_vb_rendertmp.h"
1548 /**********************************************************************/
1549 /* Render clipped primitives */
1550 /**********************************************************************/
1552 static void mach64RenderClippedPoly( struct gl_context
*ctx
, const GLuint
*elts
,
1555 mach64ContextPtr mmesa
= MACH64_CONTEXT( ctx
);
1556 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
1557 struct vertex_buffer
*VB
= &TNL_CONTEXT(ctx
)->vb
;
1558 GLuint prim
= mmesa
->render_primitive
;
1560 /* Render the new vertices as an unclipped polygon.
1563 GLuint
*tmp
= VB
->Elts
;
1564 VB
->Elts
= (GLuint
*)elts
;
1565 tnl
->Driver
.Render
.PrimTabElts
[GL_POLYGON
]( ctx
, 0, n
, PRIM_BEGIN
|PRIM_END
);
1569 /* Restore the render primitive
1571 if (prim
!= GL_POLYGON
)
1572 tnl
->Driver
.Render
.PrimitiveNotify( ctx
, prim
);
1576 static void mach64RenderClippedLine( struct gl_context
*ctx
, GLuint ii
, GLuint jj
)
1578 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
1579 tnl
->Driver
.Render
.Line( ctx
, ii
, jj
);
1582 #if MACH64_NATIVE_VTXFMT
1583 static void mach64FastRenderClippedPoly( struct gl_context
*ctx
, const GLuint
*elts
,
1586 mach64ContextPtr mmesa
= MACH64_CONTEXT( ctx
);
1587 const GLuint vertsize
= mmesa
->vertex_size
;
1594 const GLuint xyoffset
= 9;
1595 GLint xx
[3], yy
[3]; /* 2 fractional bits for hardware */
1596 unsigned vbsiz
= (vertsize
+ (vertsize
> 7 ? 2 : 1)) * n
+ (n
-2);
1598 GLubyte
*mach64verts
= (GLubyte
*)mmesa
->verts
;
1599 mach64VertexPtr v0
, v1
, v2
;
1602 v0
= (mach64VertexPtr
)VERT(elts
[1]);
1603 v1
= (mach64VertexPtr
)VERT(elts
[2]);
1604 v2
= (mach64VertexPtr
)VERT(elts
[0]);
1606 xy
= LE32_IN( &v0
->ui
[xyoffset
] );
1607 xx
[0] = (GLshort
)( xy
>> 16 );
1608 yy
[0] = (GLshort
)( xy
& 0xffff );
1610 xy
= LE32_IN( &v1
->ui
[xyoffset
] );
1611 xx
[1] = (GLshort
)( xy
>> 16 );
1612 yy
[1] = (GLshort
)( xy
& 0xffff );
1614 xy
= LE32_IN( &v2
->ui
[xyoffset
] );
1615 xx
[2] = (GLshort
)( xy
>> 16 );
1616 yy
[2] = (GLshort
)( xy
& 0xffff );
1618 a
= (xx
[0] - xx
[2]) * (yy
[1] - yy
[2]) -
1619 (yy
[0] - yy
[2]) * (xx
[1] - xx
[2]);
1621 if ( (mmesa
->backface_sign
&&
1622 ((a
< 0 && !signbit( mmesa
->backface_sign
)) ||
1623 (a
> 0 && signbit( mmesa
->backface_sign
)))) ) {
1625 if ( MACH64_DEBUG
& DEBUG_VERBOSE_PRIMS
)
1626 fprintf(stderr
,"Polygon culled\n");
1632 vb
= (CARD32
*)mach64AllocDmaLow( mmesa
, vbsiz
* sizeof(CARD32
) );
1635 COPY_VERTEX( vb
, vertsize
, v0
, 1 );
1636 COPY_VERTEX( vb
, vertsize
, v1
, 2 );
1637 COPY_VERTEX_OOA( vb
, vertsize
, v2
, 3 );
1638 LE32_OUT( vb
++, ooa
.u
);
1644 v0
= (mach64VertexPtr
)VERT(elts
[i
]);
1647 xy
= LE32_IN( &v0
->ui
[xyoffset
] );
1648 xx
[0] = (GLshort
)( xy
>> 16 );
1649 yy
[0] = (GLshort
)( xy
& 0xffff );
1651 a
= (xx
[0] - xx
[2]) * (yy
[1] - yy
[2]) -
1652 (yy
[0] - yy
[2]) * (xx
[1] - xx
[2]);
1655 COPY_VERTEX_OOA( vb
, vertsize
, v0
, 1 );
1656 LE32_OUT( vb
++, ooa
.u
);
1660 v1
= (mach64VertexPtr
)VERT(elts
[i
]);
1663 xy
= LE32_IN( &v1
->ui
[xyoffset
] );
1664 xx
[1] = (GLshort
)( xy
>> 16 );
1665 yy
[1] = (GLshort
)( xy
& 0xffff );
1667 a
= (xx
[0] - xx
[2]) * (yy
[1] - yy
[2]) -
1668 (yy
[0] - yy
[2]) * (xx
[1] - xx
[2]);
1671 COPY_VERTEX_OOA( vb
, vertsize
, v1
, 2 );
1672 LE32_OUT( vb
++, ooa
.u
);
1675 assert( vb
== vbchk
);
1678 static void mach64FastRenderClippedPoly( struct gl_context
*ctx
, const GLuint
*elts
,
1681 mach64ContextPtr mmesa
= MACH64_CONTEXT( ctx
);
1682 const GLuint vertsize
= mmesa
->vertex_size
;
1683 GLubyte
*mach64verts
= (GLubyte
*)mmesa
->verts
;
1684 const GLuint
*start
= (const GLuint
*)VERT(elts
[0]);
1687 for (i
= 2 ; i
< n
; i
++) {
1688 mach64_draw_triangle( mmesa
,
1691 (mach64VertexPtr
) start
1695 #endif /* MACH64_NATIVE_VTXFMT */
1697 /**********************************************************************/
1698 /* Choose render functions */
1699 /**********************************************************************/
1701 #define _MACH64_NEW_RENDER_STATE (_DD_NEW_POINT_SMOOTH | \
1702 _DD_NEW_LINE_SMOOTH | \
1703 _DD_NEW_LINE_STIPPLE | \
1704 _DD_NEW_TRI_SMOOTH | \
1705 _DD_NEW_TRI_STIPPLE | \
1706 _NEW_POLYGONSTIPPLE | \
1707 _DD_NEW_TRI_UNFILLED | \
1708 _DD_NEW_TRI_LIGHT_TWOSIDE | \
1709 _DD_NEW_TRI_OFFSET) \
1711 #define POINT_FALLBACK (DD_POINT_SMOOTH)
1712 #define LINE_FALLBACK (DD_LINE_SMOOTH|DD_LINE_STIPPLE)
1713 #define TRI_FALLBACK (DD_TRI_SMOOTH|DD_TRI_STIPPLE)
1714 #define ANY_FALLBACK_FLAGS (POINT_FALLBACK|LINE_FALLBACK|TRI_FALLBACK)
1715 #define ANY_RASTER_FLAGS (DD_TRI_LIGHT_TWOSIDE|DD_TRI_OFFSET|DD_TRI_UNFILLED)
1718 static void mach64ChooseRenderState(struct gl_context
*ctx
)
1720 mach64ContextPtr mmesa
= MACH64_CONTEXT(ctx
);
1721 GLuint flags
= ctx
->_TriangleCaps
;
1724 if (flags
& (ANY_RASTER_FLAGS
|ANY_FALLBACK_FLAGS
)) {
1725 mmesa
->draw_point
= mach64_draw_point
;
1726 mmesa
->draw_line
= mach64_draw_line
;
1727 mmesa
->draw_tri
= mach64_draw_triangle
;
1729 if (flags
& ANY_RASTER_FLAGS
) {
1730 if (flags
& DD_TRI_LIGHT_TWOSIDE
) index
|= MACH64_TWOSIDE_BIT
;
1731 if (flags
& DD_TRI_OFFSET
) index
|= MACH64_OFFSET_BIT
;
1732 if (flags
& DD_TRI_UNFILLED
) index
|= MACH64_UNFILLED_BIT
;
1735 /* Hook in fallbacks for specific primitives.
1737 if (flags
& (POINT_FALLBACK
|LINE_FALLBACK
|TRI_FALLBACK
)) {
1738 if (flags
& POINT_FALLBACK
) mmesa
->draw_point
= mach64_fallback_point
;
1739 if (flags
& LINE_FALLBACK
) mmesa
->draw_line
= mach64_fallback_line
;
1740 if (flags
& TRI_FALLBACK
) mmesa
->draw_tri
= mach64_fallback_tri
;
1741 index
|= MACH64_FALLBACK_BIT
;
1745 if (index
!= mmesa
->RenderIndex
) {
1746 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
1747 tnl
->Driver
.Render
.Points
= rast_tab
[index
].points
;
1748 tnl
->Driver
.Render
.Line
= rast_tab
[index
].line
;
1749 tnl
->Driver
.Render
.Triangle
= rast_tab
[index
].triangle
;
1750 tnl
->Driver
.Render
.Quad
= rast_tab
[index
].quad
;
1753 tnl
->Driver
.Render
.PrimTabVerts
= mach64_render_tab_verts
;
1754 tnl
->Driver
.Render
.PrimTabElts
= mach64_render_tab_elts
;
1755 tnl
->Driver
.Render
.ClippedLine
= rast_tab
[index
].line
;
1756 tnl
->Driver
.Render
.ClippedPolygon
= mach64FastRenderClippedPoly
;
1758 tnl
->Driver
.Render
.PrimTabVerts
= _tnl_render_tab_verts
;
1759 tnl
->Driver
.Render
.PrimTabElts
= _tnl_render_tab_elts
;
1760 tnl
->Driver
.Render
.ClippedLine
= mach64RenderClippedLine
;
1761 tnl
->Driver
.Render
.ClippedPolygon
= mach64RenderClippedPoly
;
1764 mmesa
->RenderIndex
= index
;
1768 /**********************************************************************/
1769 /* Validate state at pipeline start */
1770 /**********************************************************************/
1772 static void mach64RunPipeline( struct gl_context
*ctx
)
1774 mach64ContextPtr mmesa
= MACH64_CONTEXT(ctx
);
1776 if (mmesa
->new_state
)
1777 mach64DDUpdateHWState( ctx
);
1779 if (!mmesa
->Fallback
&& mmesa
->NewGLState
) {
1780 if (mmesa
->NewGLState
& _MACH64_NEW_VERTEX_STATE
)
1781 mach64ChooseVertexState( ctx
);
1783 if (mmesa
->NewGLState
& _MACH64_NEW_RENDER_STATE
)
1784 mach64ChooseRenderState( ctx
);
1786 mmesa
->NewGLState
= 0;
1789 _tnl_run_pipeline( ctx
);
1792 /**********************************************************************/
1793 /* High level hooks for t_vb_render.c */
1794 /**********************************************************************/
1796 /* This is called when Mesa switches between rendering triangle
1797 * primitives (such as GL_POLYGON, GL_QUADS, GL_TRIANGLE_STRIP, etc),
1798 * and lines, points and bitmaps.
1801 static void mach64RasterPrimitive( struct gl_context
*ctx
, GLuint hwprim
)
1803 mach64ContextPtr mmesa
= MACH64_CONTEXT(ctx
);
1805 mmesa
->new_state
|= MACH64_NEW_CONTEXT
;
1806 mmesa
->dirty
|= MACH64_UPLOAD_CONTEXT
;
1808 if (mmesa
->hw_primitive
!= hwprim
) {
1809 FLUSH_BATCH( mmesa
);
1810 mmesa
->hw_primitive
= hwprim
;
1814 static void mach64RenderPrimitive( struct gl_context
*ctx
, GLenum prim
)
1816 mach64ContextPtr mmesa
= MACH64_CONTEXT(ctx
);
1817 GLuint hw
= hw_prim
[prim
];
1819 mmesa
->render_primitive
= prim
;
1821 if (prim
>= GL_TRIANGLES
&& (ctx
->_TriangleCaps
& DD_TRI_UNFILLED
))
1824 mach64RasterPrimitive( ctx
, hw
);
1828 static void mach64RenderStart( struct gl_context
*ctx
)
1830 /* Check for projective texturing. Make sure all texcoord
1831 * pointers point to something. (fix in mesa?)
1833 mach64CheckTexSizes( ctx
);
1836 static void mach64RenderFinish( struct gl_context
*ctx
)
1838 if (MACH64_CONTEXT(ctx
)->RenderIndex
& MACH64_FALLBACK_BIT
)
1839 _swrast_flush( ctx
);
1843 /**********************************************************************/
1844 /* Transition to/from hardware rasterization. */
1845 /**********************************************************************/
1847 static const char * const fallbackStrings
[] = {
1849 "glDrawBuffer(GL_FRONT_AND_BACK)",
1851 "glEnable(GL_STENCIL) without hw stencil buffer",
1852 "glRenderMode(selection or feedback)",
1853 "glLogicOp (mode != GL_COPY)",
1854 "GL_SEPARATE_SPECULAR_COLOR",
1855 "glBlendEquation (mode != ADD)",
1857 "Rasterization disable",
1861 static const char *getFallbackString(GLuint bit
)
1868 return fallbackStrings
[i
];
1871 void mach64Fallback( struct gl_context
*ctx
, GLuint bit
, GLboolean mode
)
1873 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
1874 mach64ContextPtr mmesa
= MACH64_CONTEXT(ctx
);
1875 GLuint oldfallback
= mmesa
->Fallback
;
1878 mmesa
->Fallback
|= bit
;
1879 if (oldfallback
== 0) {
1880 FLUSH_BATCH( mmesa
);
1881 _swsetup_Wakeup( ctx
);
1882 mmesa
->RenderIndex
= ~0;
1883 if (MACH64_DEBUG
& DEBUG_VERBOSE_FALLBACK
) {
1884 fprintf(stderr
, "Mach64 begin rasterization fallback: 0x%x %s\n",
1885 bit
, getFallbackString(bit
));
1890 mmesa
->Fallback
&= ~bit
;
1891 if (oldfallback
== bit
) {
1892 _swrast_flush( ctx
);
1893 tnl
->Driver
.Render
.Start
= mach64RenderStart
;
1894 tnl
->Driver
.Render
.PrimitiveNotify
= mach64RenderPrimitive
;
1895 tnl
->Driver
.Render
.Finish
= mach64RenderFinish
;
1896 tnl
->Driver
.Render
.BuildVertices
= mach64BuildVertices
;
1897 mmesa
->NewGLState
|= (_MACH64_NEW_RENDER_STATE
|
1898 _MACH64_NEW_VERTEX_STATE
);
1899 if (MACH64_DEBUG
& DEBUG_VERBOSE_FALLBACK
) {
1900 fprintf(stderr
, "Mach64 end rasterization fallback: 0x%x %s\n",
1901 bit
, getFallbackString(bit
));
1907 /**********************************************************************/
1908 /* Initialization. */
1909 /**********************************************************************/
1911 void mach64InitTriFuncs( struct gl_context
*ctx
)
1913 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
1914 static int firsttime
= 1;
1921 tnl
->Driver
.RunPipeline
= mach64RunPipeline
;
1922 tnl
->Driver
.Render
.Start
= mach64RenderStart
;
1923 tnl
->Driver
.Render
.Finish
= mach64RenderFinish
;
1924 tnl
->Driver
.Render
.PrimitiveNotify
= mach64RenderPrimitive
;
1925 tnl
->Driver
.Render
.ResetLineStipple
= _swrast_ResetLineStipple
;
1926 tnl
->Driver
.Render
.BuildVertices
= mach64BuildVertices
;