projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
uint*t -> u_int*t changes
[mesa.git] / src / mesa / drivers / dri / unichrome / via_state.c
1 /*
2 * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.
3 * Copyright 2001-2003 S3 Graphics, Inc. All Rights Reserved.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sub license,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the
13 * next paragraph) shall be included in all copies or substantial portions
14 * of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
19 * VIA, S3 GRAPHICS, AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 */
24
25 #include <stdio.h>
26
27 #include "glheader.h"
28 #include "buffers.h"
29 #include "context.h"
30 #include "macros.h"
31 #include "colormac.h"
32 #include "enums.h"
33 #include "dd.h"
34
35 #include "mm.h"
36 #include "via_context.h"
37 #include "via_state.h"
38 #include "via_tex.h"
39 #include "via_vb.h"
40 #include "via_tris.h"
41 #include "via_ioctl.h"
42
43 #include "swrast/swrast.h"
44 #include "array_cache/acache.h"
45 #include "tnl/tnl.h"
46 #include "swrast_setup/swrast_setup.h"
47
48 #include "tnl/t_pipeline.h"
49
50
51 static GLuint ROP[16] = {
52 HC_HROP_BLACK, /* GL_CLEAR 0 */
53 HC_HROP_DPa, /* GL_AND s & d */
54 HC_HROP_PDna, /* GL_AND_REVERSE s & ~d */
55 HC_HROP_P, /* GL_COPY s */
56 HC_HROP_DPna, /* GL_AND_INVERTED ~s & d */
57 HC_HROP_D, /* GL_NOOP d */
58 HC_HROP_DPx, /* GL_XOR s ^ d */
59 HC_HROP_DPo, /* GL_OR s | d */
60 HC_HROP_DPon, /* GL_NOR ~(s | d) */
61 HC_HROP_DPxn, /* GL_EQUIV ~(s ^ d) */
62 HC_HROP_Dn, /* GL_INVERT ~d */
63 HC_HROP_PDno, /* GL_OR_REVERSE s | ~d */
64 HC_HROP_Pn, /* GL_COPY_INVERTED ~s */
65 HC_HROP_DPno, /* GL_OR_INVERTED ~s | d */
66 HC_HROP_DPan, /* GL_NAND ~(s & d) */
67 HC_HROP_WHITE /* GL_SET 1 */
68 };
69
70 static __inline__ GLuint viaPackColor(GLuint format,
71 GLubyte r, GLubyte g,
72 GLubyte b, GLubyte a)
73 {
74 switch (format) {
75 case 0x10:
76 return PACK_COLOR_565(r, g, b);
77 case 0x20:
78 return PACK_COLOR_8888(a, r, g, b);
79 default:
80 #ifdef DEBUG
81 if (VIA_DEBUG) fprintf(stderr, "unknown format %d\n", (int)format);
82 #endif
83 return PACK_COLOR_8888(a, r, g, b);
84 }
85 }
86
87 static void viaAlphaFunc(GLcontext *ctx, GLenum func, GLfloat ref)
88 {
89 viaContextPtr vmesa = VIA_CONTEXT(ctx);
90 vmesa = vmesa;
91 }
92
93 static void viaBlendEquationSeparate(GLcontext *ctx, GLenum rgbMode, GLenum aMode)
94 {
95 #ifdef DEBUG
96 if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__);
97 #endif
98
99 /* GL_EXT_blend_equation_separate not supported */
100 ASSERT(rgbMode == aMode);
101
102 /* Can only do GL_ADD equation in hardware */
103 FALLBACK(VIA_CONTEXT(ctx), VIA_FALLBACK_BLEND_EQ, rgbMode != GL_FUNC_ADD_EXT);
104
105 /* BlendEquation sets ColorLogicOpEnabled in an unexpected
106 * manner.
107 */
108 FALLBACK(VIA_CONTEXT(ctx), VIA_FALLBACK_LOGICOP,
109 (ctx->Color.ColorLogicOpEnabled &&
110 ctx->Color.LogicOp != GL_COPY));
111 #ifdef DEBUG
112 if (VIA_DEBUG) fprintf(stderr, "%s out\n", __FUNCTION__);
113 #endif
114 }
115
116 static void viaBlendFunc(GLcontext *ctx, GLenum sfactor, GLenum dfactor)
117 {
118 viaContextPtr vmesa = VIA_CONTEXT(ctx);
119 GLboolean fallback = GL_FALSE;
120 #ifdef DEBUG
121 if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__);
122 #endif
123 switch (ctx->Color.BlendSrcRGB) {
124 case GL_ZERO: break;
125 case GL_SRC_ALPHA: break;
126 case GL_ONE: break;
127 case GL_DST_COLOR: break;
128 case GL_ONE_MINUS_DST_COLOR: break;
129 case GL_ONE_MINUS_SRC_ALPHA: break;
130 case GL_DST_ALPHA: break;
131 case GL_ONE_MINUS_DST_ALPHA: break;
132 case GL_SRC_ALPHA_SATURATE: /*a |= SDM_SRC_SRC_ALPHA; break;*/
133 case GL_CONSTANT_COLOR:
134 case GL_ONE_MINUS_CONSTANT_COLOR:
135 case GL_CONSTANT_ALPHA:
136 case GL_ONE_MINUS_CONSTANT_ALPHA:
137 fallback = GL_TRUE;
138 break;
139 default:
140 return;
141 }
142
143 switch (ctx->Color.BlendDstRGB) {
144 case GL_SRC_ALPHA: break;
145 case GL_ONE_MINUS_SRC_ALPHA: break;
146 case GL_ZERO: break;
147 case GL_ONE: break;
148 case GL_SRC_COLOR: break;
149 case GL_ONE_MINUS_SRC_COLOR: break;
150 case GL_DST_ALPHA: break;
151 case GL_ONE_MINUS_DST_ALPHA: break;
152 case GL_CONSTANT_COLOR:
153 case GL_ONE_MINUS_CONSTANT_COLOR:
154 case GL_CONSTANT_ALPHA:
155 case GL_ONE_MINUS_CONSTANT_ALPHA:
156 fallback = GL_TRUE;
157 break;
158 default:
159 return;
160 }
161
162 FALLBACK(vmesa, VIA_FALLBACK_BLEND_FUNC, fallback);
163 #ifdef DEBUG
164 if (VIA_DEBUG) fprintf(stderr, "%s out\n", __FUNCTION__);
165 #endif
166 }
167
168 /* Shouldn't be called as the extension is disabled.
169 */
170 static void viaBlendFuncSeparate(GLcontext *ctx, GLenum sfactorRGB,
171 GLenum dfactorRGB, GLenum sfactorA,
172 GLenum dfactorA)
173 {
174 if (dfactorRGB != dfactorA || sfactorRGB != sfactorA) {
175 _mesa_error(ctx, GL_INVALID_OPERATION, "glBlendEquation (disabled)");
176 }
177
178 viaBlendFunc(ctx, sfactorRGB, dfactorRGB);
179 }
180
181
182 static void viaDepthFunc(GLcontext *ctx, GLenum func)
183 {
184 viaContextPtr vmesa = VIA_CONTEXT(ctx);
185 vmesa = vmesa;
186 }
187
188 static void viaDepthMask(GLcontext *ctx, GLboolean flag)
189 {
190 viaContextPtr vmesa = VIA_CONTEXT(ctx);
191 vmesa = vmesa;
192 }
193
194 static void viaPolygonStipple(GLcontext *ctx, const GLubyte *mask)
195 {
196 viaContextPtr vmesa = VIA_CONTEXT(ctx);
197 vmesa = vmesa;
198 }
199
200
201 /* =============================================================
202 * Hardware clipping
203 */
204 static void viaScissor(GLcontext *ctx, GLint x, GLint y,
205 GLsizei w, GLsizei h)
206 {
207 viaContextPtr vmesa = VIA_CONTEXT(ctx);
208 #ifdef DEBUG
209 if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__);
210 #endif
211 if (ctx->Scissor.Enabled) {
212 VIA_FIREVERTICES(vmesa); /* don't pipeline cliprect changes */
213 vmesa->uploadCliprects = GL_TRUE;
214 }
215
216 vmesa->scissorRect.x1 = x;
217 vmesa->scissorRect.y1 = vmesa->driDrawable->h - (y + h);
218 vmesa->scissorRect.x2 = x + w;
219 vmesa->scissorRect.y2 = vmesa->driDrawable->h - y;
220 #ifdef DEBUG
221 if (VIA_DEBUG) fprintf(stderr, "%s out\n", __FUNCTION__);
222 #endif
223 }
224
225
226 static void viaLogicOp(GLcontext *ctx, GLenum opcode)
227 {
228 #ifdef DEBUG
229 if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__);
230 if (VIA_DEBUG) fprintf(stderr, "opcode = %x\n", opcode);
231 if (VIA_DEBUG) fprintf(stderr, "%s out\n", __FUNCTION__);
232 #endif
233 }
234
235 /* Fallback to swrast for select and feedback.
236 */
237 static void viaRenderMode(GLcontext *ctx, GLenum mode)
238 {
239 viaContextPtr vmesa = VIA_CONTEXT(ctx);
240 #ifdef DEBUG
241 if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__);
242 #endif
243 FALLBACK(vmesa, VIA_FALLBACK_RENDERMODE, (mode != GL_RENDER));
244 #ifdef DEBUG
245 if (VIA_DEBUG) fprintf(stderr, "%s out\n", __FUNCTION__);
246 #endif
247 }
248
249
250 static void viaDrawBuffer(GLcontext *ctx, GLenum mode)
251 {
252 viaContextPtr vmesa = VIA_CONTEXT(ctx);
253 #ifdef DEBUG
254 if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__);
255 #endif
256 if (mode == GL_FRONT) {
257 VIA_FIREVERTICES(vmesa);
258 VIA_STATECHANGE(vmesa, VIA_UPLOAD_BUFFERS);
259 vmesa->drawMap = (char *)vmesa->driScreen->pFB;
260 vmesa->readMap = (char *)vmesa->driScreen->pFB;
261 vmesa->drawPitch = vmesa->front.pitch;
262 vmesa->readPitch = vmesa->front.pitch;
263 viaXMesaSetFrontClipRects(vmesa);
264 FALLBACK(vmesa, VIA_FALLBACK_DRAW_BUFFER, GL_FALSE);
265 return;
266 }
267 else if (mode == GL_BACK) {
268 VIA_FIREVERTICES(vmesa);
269 VIA_STATECHANGE(vmesa, VIA_UPLOAD_BUFFERS);
270 vmesa->drawMap = vmesa->back.map;
271 vmesa->readMap = vmesa->back.map;
272 vmesa->drawPitch = vmesa->back.pitch;
273 vmesa->readPitch = vmesa->back.pitch;
274 viaXMesaSetBackClipRects(vmesa);
275 FALLBACK(vmesa, VIA_FALLBACK_DRAW_BUFFER, GL_FALSE);
276 return;
277 }
278 else {
279 FALLBACK(vmesa, VIA_FALLBACK_DRAW_BUFFER, GL_TRUE);
280 return;
281 }
282 #ifdef DEBUG
283 if (VIA_DEBUG) fprintf(stderr, "%s out\n", __FUNCTION__);
284 #endif
285 }
286
287 static void viaClearColor(GLcontext *ctx, const GLfloat color[4])
288 {
289 viaContextPtr vmesa = VIA_CONTEXT(ctx);
290 GLubyte pcolor[4];
291 pcolor[0] = (GLubyte) (255 * color[0]);
292 pcolor[1] = (GLubyte) (255 * color[1]);
293 pcolor[2] = (GLubyte) (255 * color[2]);
294 pcolor[3] = (GLubyte) (255 * color[3]);
295 vmesa->ClearColor = viaPackColor(vmesa->viaScreen->bitsPerPixel,
296 pcolor[0], pcolor[1],
297 pcolor[2], pcolor[3]);
298
299 }
300
301 /* =============================================================
302 * Culling - the via isn't quite as clean here as the rest of
303 * its interfaces, but it's not bad.
304 */
305 static void viaCullFaceFrontFace(GLcontext *ctx, GLenum unused)
306 {
307 viaContextPtr vmesa = VIA_CONTEXT(ctx);
308 vmesa = vmesa;
309 }
310
311 static void viaLineWidth(GLcontext *ctx, GLfloat widthf)
312 {
313 viaContextPtr vmesa = VIA_CONTEXT(ctx);
314 vmesa = vmesa;
315 }
316
317 static void viaPointSize(GLcontext *ctx, GLfloat sz)
318 {
319 viaContextPtr vmesa = VIA_CONTEXT(ctx);
320 vmesa = vmesa;
321 }
322
323 static void viaBitmap( GLcontext *ctx, GLint px, GLint py,
324 GLsizei width, GLsizei height,
325 const struct gl_pixelstore_attrib *unpack,
326 const GLubyte *bitmap )
327 {
328 viaContextPtr vmesa = VIA_CONTEXT(ctx);
329
330 /*=* [DBG] csmash : fix background overlap option menu *=*/
331 LOCK_HARDWARE(vmesa);
332 viaFlushPrimsLocked(vmesa);
333 UNLOCK_HARDWARE(vmesa);
334
335 WAIT_IDLE
336 /*=* [DBG] csmash : fix segmentation fault *=*/
337 /*=* John Sheng [2003.7.18] texenv *=*/
338 /*if (!vmesa->drawMap && !vmesa->readMap) {*/
339 if (1) {
340 if (vmesa->glCtx->Color._DrawDestMask[0] == __GL_BACK_BUFFER_MASK) {
341 viaDrawBuffer(ctx, GL_BACK);
342 }
343 else {
344 viaDrawBuffer(ctx, GL_FRONT);
345 }
346 }
347 /*=* [DBG] csmash : white option words become brown *=*/
348 /*_swrast_Bitmap(ctx, px, py, width, height, unpack, bitmap );*/
349 {
350 GLboolean fog;
351 fog = ctx->Fog.Enabled;
352 ctx->Fog.Enabled = GL_FALSE;
353 _swrast_Bitmap(ctx, px, py, width, height, unpack, bitmap );
354 ctx->Fog.Enabled = fog;
355 }
356 }
357
358 /* =============================================================
359 * Color masks
360 */
361 static void viaColorMask(GLcontext *ctx,
362 GLboolean r, GLboolean g,
363 GLboolean b, GLboolean a)
364 {
365 viaContextPtr vmesa = VIA_CONTEXT(ctx);
366 vmesa = vmesa;
367 }
368
369 /* Seperate specular not fully implemented on the via.
370 */
371 static void viaLightModelfv(GLcontext *ctx, GLenum pname,
372 const GLfloat *param)
373 {
374 viaContextPtr vmesa = VIA_CONTEXT(ctx);
375 vmesa = vmesa;
376 }
377
378
379 /* In Mesa 3.5 we can reliably do native flatshading.
380 */
381 static void viaShadeModel(GLcontext *ctx, GLenum mode)
382 {
383 viaContextPtr vmesa = VIA_CONTEXT(ctx);
384 vmesa = vmesa;
385 }
386
387 /* =============================================================
388 * Fog
389 */
390 static void viaFogfv(GLcontext *ctx, GLenum pname, const GLfloat *param)
391 {
392 viaContextPtr vmesa = VIA_CONTEXT(ctx);
393 vmesa = vmesa;
394 }
395
396 /* =============================================================
397 */
398 static void viaEnable(GLcontext *ctx, GLenum cap, GLboolean state)
399 {
400 viaContextPtr vmesa = VIA_CONTEXT(ctx);
401 vmesa = vmesa;
402 }
403
404 /* =============================================================
405 */
406 void viaEmitDrawingRectangle(viaContextPtr vmesa)
407 {
408 __DRIdrawablePrivate *dPriv = vmesa->driDrawable;
409 viaScreenPrivate *viaScreen = vmesa->viaScreen;
410 int x0 = vmesa->drawX;
411 int y0 = vmesa->drawY;
412 int x1 = x0 + dPriv->w;
413 int y1 = y0 + dPriv->h;
414 /* GLuint dr2, dr3, dr4;
415 */
416
417 /* Coordinate origin of the window - may be offscreen.
418 */
419 /* dr4 = vmesa->BufferSetup[VIA_DESTREG_DR4] = ((y0 << 16) |
420 (((unsigned)x0) & 0xFFFF));
421 */
422
423 /* Clip to screen.
424 */
425 if (x0 < 0) x0 = 0;
426 if (y0 < 0) y0 = 0;
427 if (x1 > viaScreen->width - 1) x1 = viaScreen->width - 1;
428 if (y1 > viaScreen->height - 1) y1 = viaScreen->height - 1;
429
430 /* Onscreen drawing rectangle.
431 */
432 /* dr2 = vmesa->BufferSetup[VIA_DESTREG_DR2] = ((y0 << 16) | x0);
433 dr3 = vmesa->BufferSetup[VIA_DESTREG_DR3] = (((y1 + 1) << 16) | (x1 + 1));
434 */
435
436 vmesa->dirty |= VIA_UPLOAD_BUFFERS;
437 }
438
439
440 void viaCalcViewport(GLcontext *ctx)
441 {
442 viaContextPtr vmesa = VIA_CONTEXT(ctx);
443 const GLfloat *v = ctx->Viewport._WindowMap.m;
444 GLfloat *m = vmesa->ViewportMatrix.m;
445
446 /* See also via_translate_vertex. SUBPIXEL adjustments can be done
447 * via state vars, too.
448 */
449 m[MAT_SX] = v[MAT_SX];
450 m[MAT_TX] = v[MAT_TX] + vmesa->drawXoff;
451 m[MAT_SY] = - v[MAT_SY];
452 m[MAT_TY] = - v[MAT_TY] + vmesa->driDrawable->h;
453 /*=* John Sheng [2003.7.2] for visual config & viewperf drv-08 *=*/
454 if (vmesa->depth.bpp == 16) {
455 m[MAT_SZ] = v[MAT_SZ] * (1.0 / 0xffff);
456 m[MAT_TZ] = v[MAT_TZ] * (1.0 / 0xffff);
457 }
458 else {
459 m[MAT_SZ] = v[MAT_SZ] * (1.0 / 0xffffffff);
460 m[MAT_TZ] = v[MAT_TZ] * (1.0 / 0xffffffff);
461 }
462 }
463
464 static void viaViewport(GLcontext *ctx,
465 GLint x, GLint y,
466 GLsizei width, GLsizei height)
467 {
468 /* update size of Mesa/software ancillary buffers */
469 _mesa_ResizeBuffersMESA();
470 viaCalcViewport(ctx);
471 }
472
473 static void viaDepthRange(GLcontext *ctx,
474 GLclampd nearval, GLclampd farval)
475 {
476 viaCalcViewport(ctx);
477 }
478
479 void viaPrintDirty(const char *msg, GLuint state)
480 {
481 #ifdef DEBUG
482 if (VIA_DEBUG)
483 fprintf(stderr, "%s (0x%x): %s%s%s%s\n",
484 msg,
485 (unsigned int) state,
486 (state & VIA_UPLOAD_TEX0) ? "upload-tex0, " : "",
487 (state & VIA_UPLOAD_TEX1) ? "upload-tex1, " : "",
488 (state & VIA_UPLOAD_CTX) ? "upload-ctx, " : "",
489 (state & VIA_UPLOAD_BUFFERS) ? "upload-bufs, " : ""
490 );
491 #endif
492 }
493
494
495 void viaInitState(GLcontext *ctx)
496 {
497 viaContextPtr vmesa = VIA_CONTEXT(ctx);
498
499 vmesa->regCmdA = HC_ACMD_HCmdA;
500 vmesa->regCmdB = HC_ACMD_HCmdB | HC_HVPMSK_X | HC_HVPMSK_Y | HC_HVPMSK_Z;
501 vmesa->regEnable = HC_HenCW_MASK;
502
503 if (vmesa->glCtx->Color._DrawDestMask[0] == __GL_BACK_BUFFER_MASK) {
504 vmesa->drawMap = vmesa->back.map;
505 vmesa->readMap = vmesa->back.map;
506 }
507 else {
508 vmesa->drawMap = (char *)vmesa->driScreen->pFB;
509 vmesa->readMap = (char *)vmesa->driScreen->pFB;
510 }
511 }
512
513 /**
514 * Convert S and T texture coordinate wrap modes to hardware bits.
515 */
516 static u_int32_t
517 get_wrap_mode( GLenum sWrap, GLenum tWrap )
518 {
519 u_int32_t v = 0;
520
521
522 switch( sWrap ) {
523 case GL_REPEAT:
524 v |= HC_HTXnMPMD_Srepeat;
525 break;
526 case GL_CLAMP:
527 case GL_CLAMP_TO_EDGE:
528 v |= HC_HTXnMPMD_Sclamp;
529 break;
530 case GL_MIRRORED_REPEAT:
531 v |= HC_HTXnMPMD_Smirror;
532 break;
533 }
534
535 switch( tWrap ) {
536 case GL_REPEAT:
537 v |= HC_HTXnMPMD_Trepeat;
538 break;
539 case GL_CLAMP:
540 case GL_CLAMP_TO_EDGE:
541 v |= HC_HTXnMPMD_Tclamp;
542 break;
543 case GL_MIRRORED_REPEAT:
544 v |= HC_HTXnMPMD_Tmirror;
545 break;
546 }
547
548 return v;
549 }
550
551
552 void viaChooseTextureState(GLcontext *ctx)
553 {
554 viaContextPtr vmesa = VIA_CONTEXT(ctx);
555 struct gl_texture_unit *texUnit0 = &ctx->Texture.Unit[0];
556 struct gl_texture_unit *texUnit1 = &ctx->Texture.Unit[1];
557 /*=* John Sheng [2003.7.18] texture combine *=*/
558
559 #ifdef DEBUG
560 if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__);
561 #endif
562 if (texUnit0->_ReallyEnabled || texUnit1->_ReallyEnabled) {
563 #ifdef DEBUG
564 if (VIA_DEBUG) {
565 fprintf(stderr, "Texture._ReallyEnabled - in\n");
566 fprintf(stderr, "texUnit0->_ReallyEnabled = %x\n",texUnit0->_ReallyEnabled);
567 }
568 #endif
569
570 #ifdef DEBUG
571 if (VIA_DEBUG) {
572 struct gl_texture_object *texObj0 = texUnit0->_Current;
573 struct gl_texture_object *texObj1 = texUnit1->_Current;
574
575 fprintf(stderr, "env mode: 0x%04x / 0x%04x\n", texUnit0->EnvMode, texUnit1->EnvMode);
576
577 if ( (texObj0 != NULL) && (texObj0->Image[0][0] != NULL) )
578 fprintf(stderr, "format 0: 0x%04x\n", texObj0->Image[0][0]->Format);
579
580 if ( (texObj1 != NULL) && (texObj1->Image[0][0] != NULL) )
581 fprintf(stderr, "format 1: 0x%04x\n", texObj1->Image[0][0]->Format);
582 }
583 #endif
584
585
586 if (texUnit0->_ReallyEnabled) {
587 struct gl_texture_object *texObj = texUnit0->_Current;
588 struct gl_texture_image *texImage = texObj->Image[0][0];
589
590 #ifdef DEBUG
591 if (VIA_DEBUG) fprintf(stderr, "texUnit0->_ReallyEnabled\n");
592 #endif
593 if (texImage->Border) {
594 FALLBACK(vmesa, VIA_FALLBACK_TEXTURE, GL_TRUE);
595 return;
596 }
597 vmesa->regCmdB |= HC_HVPMSK_S | HC_HVPMSK_T | HC_HVPMSK_W | HC_HVPMSK_Cs;
598 vmesa->regEnable |= HC_HenTXMP_MASK | HC_HenTXCH_MASK | HC_HenTXPP_MASK;
599
600 switch (texObj->MinFilter) {
601 case GL_NEAREST:
602 vmesa->regHTXnTB_0 = HC_HTXnFLSs_Nearest |
603 HC_HTXnFLTs_Nearest;
604 break;
605 case GL_LINEAR:
606 vmesa->regHTXnTB_0 = HC_HTXnFLSs_Linear |
607 HC_HTXnFLTs_Linear;
608 break;
609 case GL_NEAREST_MIPMAP_NEAREST:
610 vmesa->regHTXnTB_0 = HC_HTXnFLSs_Nearest |
611 HC_HTXnFLTs_Nearest;
612 vmesa->regHTXnTB_0 |= HC_HTXnFLDs_Nearest;
613 break;
614 case GL_LINEAR_MIPMAP_NEAREST:
615 vmesa->regHTXnTB_0 = HC_HTXnFLSs_Linear |
616 HC_HTXnFLTs_Linear;
617 vmesa->regHTXnTB_0 |= HC_HTXnFLDs_Nearest;
618 break;
619 case GL_NEAREST_MIPMAP_LINEAR:
620 vmesa->regHTXnTB_0 = HC_HTXnFLSs_Nearest |
621 HC_HTXnFLTs_Nearest;
622 vmesa->regHTXnTB_0 |= HC_HTXnFLDs_Linear;
623 break;
624 case GL_LINEAR_MIPMAP_LINEAR:
625 vmesa->regHTXnTB_0 = HC_HTXnFLSs_Linear |
626 HC_HTXnFLTs_Linear;
627 vmesa->regHTXnTB_0 |= HC_HTXnFLDs_Linear;
628 break;
629 default:
630 break;
631 }
632
633 if (texObj->MagFilter) {
634 vmesa->regHTXnTB_0 |= HC_HTXnFLSe_Linear |
635 HC_HTXnFLTe_Linear;
636 }
637 else {
638 vmesa->regHTXnTB_0 |= HC_HTXnFLSe_Nearest |
639 HC_HTXnFLTe_Nearest;
640 }
641
642 vmesa->regHTXnMPMD_0 &= ~(HC_HTXnMPMD_SMASK | HC_HTXnMPMD_TMASK);
643 vmesa->regHTXnMPMD_0 |= get_wrap_mode( texObj->WrapS,
644 texObj->WrapT );
645
646 #ifdef DEBUG
647 if (VIA_DEBUG) fprintf(stderr, "texUnit0->EnvMode %x\n",texUnit0->EnvMode);
648 #endif
649
650 viaTexCombineState( vmesa, texUnit0->_CurrentCombine, 0 );
651 }
652 else {
653 /* Should turn Cs off if actually no Cs */
654 }
655
656 if (texUnit1->_ReallyEnabled) {
657 struct gl_texture_object *texObj = texUnit1->_Current;
658 struct gl_texture_image *texImage = texObj->Image[0][0];
659
660 if (texImage->Border) {
661 FALLBACK(vmesa, VIA_FALLBACK_TEXTURE, GL_TRUE);
662 return;
663 }
664
665 switch (texObj->MinFilter) {
666 case GL_NEAREST:
667 vmesa->regHTXnTB_1 = HC_HTXnFLSs_Nearest |
668 HC_HTXnFLTs_Nearest;
669 break;
670 case GL_LINEAR:
671 vmesa->regHTXnTB_1 = HC_HTXnFLSs_Linear |
672 HC_HTXnFLTs_Linear;
673 break;
674 case GL_NEAREST_MIPMAP_NEAREST:
675 vmesa->regHTXnTB_1 = HC_HTXnFLSs_Nearest |
676 HC_HTXnFLTs_Nearest;
677 vmesa->regHTXnTB_1 |= HC_HTXnFLDs_Nearest;
678 break ;
679 case GL_LINEAR_MIPMAP_NEAREST:
680 vmesa->regHTXnTB_1 = HC_HTXnFLSs_Linear |
681 HC_HTXnFLTs_Linear;
682 vmesa->regHTXnTB_1 |= HC_HTXnFLDs_Nearest;
683 break ;
684 case GL_NEAREST_MIPMAP_LINEAR:
685 vmesa->regHTXnTB_1 = HC_HTXnFLSs_Nearest |
686 HC_HTXnFLTs_Nearest;
687 vmesa->regHTXnTB_1 |= HC_HTXnFLDs_Linear;
688 break ;
689 case GL_LINEAR_MIPMAP_LINEAR:
690 vmesa->regHTXnTB_1 = HC_HTXnFLSs_Linear |
691 HC_HTXnFLTs_Linear;
692 vmesa->regHTXnTB_1 |= HC_HTXnFLDs_Linear;
693 break ;
694 default:
695 break;
696 }
697
698 switch(texObj->MagFilter) {
699 case GL_NEAREST:
700 vmesa->regHTXnTB_1 |= HC_HTXnFLSs_Nearest |
701 HC_HTXnFLTs_Nearest;
702 break;
703 case GL_LINEAR:
704 vmesa->regHTXnTB_1 |= HC_HTXnFLSs_Linear |
705 HC_HTXnFLTs_Linear;
706 break;
707 }
708
709 vmesa->regHTXnMPMD_1 &= ~(HC_HTXnMPMD_SMASK | HC_HTXnMPMD_TMASK);
710 vmesa->regHTXnMPMD_1 |= get_wrap_mode( texObj->WrapS,
711 texObj->WrapT );
712
713 viaTexCombineState( vmesa, texUnit1->_CurrentCombine, 1 );
714 }
715 vmesa->dirty |= VIA_UPLOAD_TEXTURE;
716
717 #ifdef DEBUG
718 if (VIA_DEBUG) {
719 fprintf( stderr, "Csat_0 / Cop_0 = 0x%08x / 0x%08x\n",
720 vmesa->regHTXnTBLCsat_0, vmesa->regHTXnTBLCop_0 );
721 fprintf( stderr, "Asat_0 = 0x%08x\n",
722 vmesa->regHTXnTBLAsat_0 );
723 fprintf( stderr, "RCb_0 / RAa_0 = 0x%08x / 0x%08x\n",
724 vmesa->regHTXnTBLRCb_0, vmesa->regHTXnTBLRAa_0 );
725 fprintf( stderr, "RCa_0 / RCc_0 = 0x%08x / 0x%08x\n",
726 vmesa->regHTXnTBLRCa_0, vmesa->regHTXnTBLRCc_0 );
727 fprintf( stderr, "RCbias_0 = 0x%08x\n",
728 vmesa->regHTXnTBLRCbias_0 );
729 }
730 #endif
731 }
732 else {
733 if (ctx->Fog.Enabled)
734 vmesa->regCmdB &= (~(HC_HVPMSK_S | HC_HVPMSK_T));
735 else
736 vmesa->regCmdB &= (~(HC_HVPMSK_S | HC_HVPMSK_T | HC_HVPMSK_W));
737 vmesa->regEnable &= (~(HC_HenTXMP_MASK | HC_HenTXCH_MASK | HC_HenTXPP_MASK));
738 vmesa->dirty |= VIA_UPLOAD_ENABLE;
739 }
740 #ifdef DEBUG
741 if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__);
742 #endif
743
744 }
745
746 void viaChooseColorState(GLcontext *ctx)
747 {
748 viaContextPtr vmesa = VIA_CONTEXT(ctx);
749 GLenum s = ctx->Color.BlendSrcRGB;
750 GLenum d = ctx->Color.BlendDstRGB;
751
752 /* The HW's blending equation is:
753 * (Ca * FCa + Cbias + Cb * FCb) << Cshift
754 */
755 #ifdef DEBUG
756 if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__);
757 #endif
758
759 if (ctx->Color.BlendEnabled) {
760 vmesa->regEnable |= HC_HenABL_MASK;
761 /* Ca -- always from source color.
762 */
763 vmesa->regHABLCsat = HC_HABLCsat_MASK | HC_HABLCa_OPC |
764 HC_HABLCa_Csrc;
765 /* Aa -- always from source alpha.
766 */
767 vmesa->regHABLAsat = HC_HABLAsat_MASK | HC_HABLAa_OPA |
768 HC_HABLAa_Asrc;
769 /* FCa -- depend on following condition.
770 * FAa -- depend on following condition.
771 */
772 switch (s) {
773 case GL_ZERO:
774 /* (0, 0, 0, 0)
775 */
776 vmesa->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_HABLRCa;
777 vmesa->regHABLAsat |= HC_HABLFAa_OPA | HC_HABLFAa_HABLFRA;
778 vmesa->regHABLRFCa = 0x0;
779 vmesa->regHABLRAa = 0x0;
780 break;
781 case GL_ONE:
782 /* (1, 1, 1, 1)
783 */
784 vmesa->regHABLCsat |= HC_HABLFCa_InvOPC | HC_HABLFCa_HABLRCa;
785 vmesa->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_HABLFRA;
786 vmesa->regHABLRFCa = 0x0;
787 vmesa->regHABLRAa = 0x0;
788 break;
789 case GL_SRC_COLOR:
790 /* (Rs, Gs, Bs, As)
791 */
792 vmesa->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_Csrc;
793 vmesa->regHABLAsat |= HC_HABLFAa_OPA | HC_HABLFAa_Asrc;
794 break;
795 case GL_ONE_MINUS_SRC_COLOR:
796 /* (1, 1, 1, 1) - (Rs, Gs, Bs, As)
797 */
798 vmesa->regHABLCsat |= HC_HABLFCa_InvOPC | HC_HABLFCa_Csrc;
799 vmesa->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_Asrc;
800 break;
801 case GL_DST_COLOR:
802 /* (Rd, Gd, Bd, Ad)
803 */
804 vmesa->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_Cdst;
805 vmesa->regHABLAsat |= HC_HABLFAa_OPA | HC_HABLFAa_Adst;
806 break;
807 case GL_ONE_MINUS_DST_COLOR:
808 /* (1, 1, 1, 1) - (Rd, Gd, Bd, Ad)
809 */
810 vmesa->regHABLCsat |= HC_HABLFCa_InvOPC | HC_HABLFCa_Cdst;
811 vmesa->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_Adst;
812 break;
813 case GL_SRC_ALPHA:
814 /* (As, As, As, As)
815 */
816 vmesa->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_Asrc;
817 vmesa->regHABLAsat |= HC_HABLFAa_OPA | HC_HABLFAa_Asrc;
818 break;
819 case GL_ONE_MINUS_SRC_ALPHA:
820 /* (1, 1, 1, 1) - (As, As, As, As)
821 */
822 vmesa->regHABLCsat |= HC_HABLFCa_InvOPC | HC_HABLFCa_Asrc;
823 vmesa->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_Asrc;
824 break;
825 case GL_DST_ALPHA:
826 {
827 if (vmesa->viaScreen->bitsPerPixel == 16) {
828 /* (1, 1, 1, 1)
829 */
830 vmesa->regHABLCsat |= HC_HABLFCa_InvOPC | HC_HABLFCa_HABLRCa;
831 vmesa->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_HABLFRA;
832 vmesa->regHABLRFCa = 0x0;
833 vmesa->regHABLRAa = 0x0;
834 }
835 else {
836 /* (Ad, Ad, Ad, Ad)
837 */
838 vmesa->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_Adst;
839 vmesa->regHABLAsat |= HC_HABLFAa_OPA | HC_HABLFAa_Adst;
840 }
841 }
842 break;
843 case GL_ONE_MINUS_DST_ALPHA:
844 {
845 if (vmesa->viaScreen->bitsPerPixel == 16) {
846 /* (1, 1, 1, 1) - (1, 1, 1, 1) = (0, 0, 0, 0)
847 */
848 vmesa->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_HABLRCa;
849 vmesa->regHABLAsat |= HC_HABLFAa_OPA | HC_HABLFAa_HABLFRA;
850 vmesa->regHABLRFCa = 0x0;
851 vmesa->regHABLRAa = 0x0;
852 }
853 else {
854 /* (1, 1, 1, 1) - (Ad, Ad, Ad, Ad)
855 */
856 vmesa->regHABLCsat |= HC_HABLFCa_InvOPC | HC_HABLFCa_Adst;
857 vmesa->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_Adst;
858 }
859 }
860 break;
861 case GL_SRC_ALPHA_SATURATE:
862 {
863 if (vmesa->viaScreen->bitsPerPixel == 16) {
864 /* (f, f, f, 1), f = min(As, 1 - Ad) = min(As, 1 - 1) = 0
865 * So (f, f, f, 1) = (0, 0, 0, 1)
866 */
867 vmesa->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_HABLRCa;
868 vmesa->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_HABLFRA;
869 vmesa->regHABLRFCa = 0x0;
870 vmesa->regHABLRAa = 0x0;
871 }
872 else {
873 /* (f, f, f, 1), f = min(As, 1 - Ad)
874 */
875 vmesa->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_mimAsrcInvAdst;
876 vmesa->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_HABLFRA;
877 vmesa->regHABLRFCa = 0x0;
878 vmesa->regHABLRAa = 0x0;
879 }
880 }
881 break;
882 }
883
884 /* Op is add.
885 */
886
887 /* bias is 0.
888 */
889 vmesa->regHABLCsat |= HC_HABLCbias_HABLRCbias;
890 vmesa->regHABLAsat |= HC_HABLAbias_HABLRAbias;
891
892 /* Cb -- always from destination color.
893 */
894 vmesa->regHABLCop = HC_HABLCb_OPC | HC_HABLCb_Cdst;
895 /* Ab -- always from destination alpha.
896 */
897 vmesa->regHABLAop = HC_HABLAb_OPA | HC_HABLAb_Adst;
898 /* FCb -- depend on following condition.
899 */
900 switch (d) {
901 case GL_ZERO:
902 /* (0, 0, 0, 0)
903 */
904 vmesa->regHABLCop |= HC_HABLFCb_OPC | HC_HABLFCb_HABLRCb;
905 vmesa->regHABLAop |= HC_HABLFAb_OPA | HC_HABLFAb_HABLFRA;
906 vmesa->regHABLRFCb = 0x0;
907 vmesa->regHABLRAb = 0x0;
908 break;
909 case GL_ONE:
910 /* (1, 1, 1, 1)
911 */
912 vmesa->regHABLCop |= HC_HABLFCb_InvOPC | HC_HABLFCb_HABLRCb;
913 vmesa->regHABLAop |= HC_HABLFAb_InvOPA | HC_HABLFAb_HABLFRA;
914 vmesa->regHABLRFCb = 0x0;
915 vmesa->regHABLRAb = 0x0;
916 break;
917 case GL_SRC_COLOR:
918 /* (Rs, Gs, Bs, As)
919 */
920 vmesa->regHABLCop |= HC_HABLFCb_OPC | HC_HABLFCb_Csrc;
921 vmesa->regHABLAop |= HC_HABLFAb_OPA | HC_HABLFAb_Asrc;
922 break;
923 case GL_ONE_MINUS_SRC_COLOR:
924 /* (1, 1, 1, 1) - (Rs, Gs, Bs, As)
925 */
926 vmesa->regHABLCop |= HC_HABLFCb_InvOPC | HC_HABLFCb_Csrc;
927 vmesa->regHABLAop |= HC_HABLFAb_InvOPA | HC_HABLFAb_Asrc;
928 break;
929 case GL_DST_COLOR:
930 /* (Rd, Gd, Bd, Ad)
931 */
932 vmesa->regHABLCop |= HC_HABLFCb_OPC | HC_HABLFCb_Cdst;
933 vmesa->regHABLAop |= HC_HABLFAb_OPA | HC_HABLFAb_Adst;
934 break;
935 case GL_ONE_MINUS_DST_COLOR:
936 /* (1, 1, 1, 1) - (Rd, Gd, Bd, Ad)
937 */
938 vmesa->regHABLCop |= HC_HABLFCb_InvOPC | HC_HABLFCb_Cdst;
939 vmesa->regHABLAop |= HC_HABLFAb_InvOPA | HC_HABLFAb_Adst;
940 break;
941 case GL_SRC_ALPHA:
942 /* (As, As, As, As)
943 */
944 vmesa->regHABLCop |= HC_HABLFCb_OPC | HC_HABLFCb_Asrc;
945 vmesa->regHABLAop |= HC_HABLFAb_OPA | HC_HABLFAb_Asrc;
946 break;
947 case GL_ONE_MINUS_SRC_ALPHA:
948 /* (1, 1, 1, 1) - (As, As, As, As)
949 */
950 vmesa->regHABLCop |= HC_HABLFCb_InvOPC | HC_HABLFCb_Asrc;
951 vmesa->regHABLAop |= HC_HABLFAb_InvOPA | HC_HABLFAb_Asrc;
952 break;
953 case GL_DST_ALPHA:
954 {
955 if (vmesa->viaScreen->bitsPerPixel == 16) {
956 /* (1, 1, 1, 1)
957 */
958 vmesa->regHABLCop |= HC_HABLFCb_InvOPC | HC_HABLFCb_HABLRCb;
959 vmesa->regHABLAop |= HC_HABLFAb_InvOPA | HC_HABLFAb_HABLFRA;
960 vmesa->regHABLRFCb = 0x0;
961 vmesa->regHABLRAb = 0x0;
962 }
963 else {
964 /* (Ad, Ad, Ad, Ad)
965 */
966 vmesa->regHABLCop |= HC_HABLFCb_OPC | HC_HABLFCb_Adst;
967 vmesa->regHABLAop |= HC_HABLFAb_OPA | HC_HABLFAb_Adst;
968 }
969 }
970 break;
971 case GL_ONE_MINUS_DST_ALPHA:
972 {
973 if (vmesa->viaScreen->bitsPerPixel == 16) {
974 /* (1, 1, 1, 1) - (1, 1, 1, 1) = (0, 0, 0, 0)
975 */
976 vmesa->regHABLCop |= HC_HABLFCb_OPC | HC_HABLFCb_HABLRCb;
977 vmesa->regHABLAop |= HC_HABLFAb_OPA | HC_HABLFAb_HABLFRA;
978 vmesa->regHABLRFCb = 0x0;
979 vmesa->regHABLRAb = 0x0;
980 }
981 else {
982 /* (1, 1, 1, 1) - (Ad, Ad, Ad, Ad)
983 */
984 vmesa->regHABLCop |= HC_HABLFCb_InvOPC | HC_HABLFCb_Adst;
985 vmesa->regHABLAop |= HC_HABLFAb_InvOPA | HC_HABLFAb_Adst;
986 }
987 }
988 break;
989 default:
990 vmesa->regHABLCop |= HC_HABLFCb_OPC | HC_HABLFCb_HABLRCb;
991 vmesa->regHABLAop |= HC_HABLFAb_OPA | HC_HABLFAb_HABLFRA;
992 vmesa->regHABLRFCb = 0x0;
993 vmesa->regHABLRAb = 0x0;
994 break;
995 }
996
997 if (vmesa->viaScreen->bitsPerPixel <= 16)
998 vmesa->regEnable &= ~HC_HenDT_MASK;
999
1000 vmesa->dirty |= (VIA_UPLOAD_BLEND | VIA_UPLOAD_ENABLE);
1001 }
1002 else {
1003 vmesa->regEnable &= (~HC_HenABL_MASK);
1004 vmesa->dirty |= VIA_UPLOAD_ENABLE;
1005 }
1006
1007 if (ctx->Color.AlphaEnabled) {
1008 vmesa->regEnable |= HC_HenAT_MASK;
1009 vmesa->regHATMD = (((GLchan)ctx->Color.AlphaRef) & 0xFF) |
1010 ((ctx->Color.AlphaFunc - GL_NEVER) << 8);
1011 vmesa->dirty |= (VIA_UPLOAD_ALPHATEST | VIA_UPLOAD_ENABLE);
1012 }
1013 else {
1014 vmesa->regEnable &= (~HC_HenAT_MASK);
1015 vmesa->dirty |= VIA_UPLOAD_ENABLE;
1016 }
1017
1018 if (ctx->Color.DitherFlag && (vmesa->viaScreen->bitsPerPixel < 32)) {
1019 if (ctx->Color.BlendEnabled) {
1020 vmesa->regEnable &= ~HC_HenDT_MASK;
1021 }
1022 else {
1023 vmesa->regEnable |= HC_HenDT_MASK;
1024 }
1025 vmesa->dirty |= VIA_UPLOAD_ENABLE;
1026 }
1027
1028 if (ctx->Color.ColorLogicOpEnabled)
1029 vmesa->regHROP = ROP[ctx->Color.LogicOp & 0xF];
1030 else
1031 vmesa->regHROP = HC_HROP_P;
1032
1033 vmesa->regHFBBMSKL = (*(GLuint *)&ctx->Color.ColorMask[0]) & 0xFFFFFF;
1034 vmesa->regHROP |= ((*(GLuint *)&ctx->Color.ColorMask[0]) >> 24) & 0xFF;
1035 vmesa->dirty |= VIA_UPLOAD_MASK_ROP;
1036
1037 if ((GLuint)((GLuint *)&ctx->Color.ColorMask[0]) & 0xFF000000)
1038 vmesa->regEnable |= HC_HenAW_MASK;
1039 else
1040 vmesa->regEnable &= (~HC_HenAW_MASK);
1041 vmesa->dirty |= VIA_UPLOAD_ENABLE;
1042 #ifdef DEBUG
1043 if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__);
1044 #endif
1045 }
1046
1047 void viaChooseFogState(GLcontext *ctx)
1048 {
1049 viaContextPtr vmesa = VIA_CONTEXT(ctx);
1050
1051 if (ctx->Fog.Enabled) {
1052 GLubyte r, g, b, a;
1053
1054 vmesa->regCmdB |= (HC_HVPMSK_Cd | HC_HVPMSK_Cs | HC_HVPMSK_W);
1055 vmesa->regEnable |= HC_HenFOG_MASK;
1056
1057 /* Use fog equation 0 (OpenGL's default) & local fog.
1058 */
1059 vmesa->regHFogLF = 0x0;
1060
1061 r = (GLubyte)(ctx->Fog.Color[0] * 255.0F);
1062 g = (GLubyte)(ctx->Fog.Color[1] * 255.0F);
1063 b = (GLubyte)(ctx->Fog.Color[2] * 255.0F);
1064 a = (GLubyte)(ctx->Fog.Color[3] * 255.0F);
1065 vmesa->regHFogCL = (r << 16) | (g << 8) | b;
1066 vmesa->regHFogCH = a;
1067 vmesa->dirty |= (VIA_UPLOAD_FOG | VIA_UPLOAD_ENABLE);
1068 }
1069 else {
1070 if (!ctx->Texture._EnabledUnits) {
1071 vmesa->regCmdB &= ~ HC_HVPMSK_W;
1072 vmesa->regCmdB &= ~ HC_HVPMSK_Cs;
1073 }
1074 vmesa->regEnable &= ~HC_HenFOG_MASK;
1075 vmesa->dirty |= VIA_UPLOAD_ENABLE;
1076 }
1077 }
1078
1079 void viaChooseDepthState(GLcontext *ctx)
1080 {
1081 viaContextPtr vmesa = VIA_CONTEXT(ctx);
1082 if (ctx->Depth.Test) {
1083 vmesa->regCmdB |= HC_HVPMSK_Z;
1084 vmesa->regEnable |= HC_HenZT_MASK;
1085 if (ctx->Depth.Mask)
1086 vmesa->regEnable |= HC_HenZW_MASK;
1087 else
1088 vmesa->regEnable &= (~HC_HenZW_MASK);
1089 vmesa->regHZWTMD = (ctx->Depth.Func - GL_NEVER) << 16;
1090 vmesa->dirty |= (VIA_UPLOAD_DEPTH | VIA_UPLOAD_ENABLE);
1091
1092 }
1093 else {
1094 /* Still need to send parameter Z.
1095 */
1096
1097 vmesa->regCmdB |= HC_HVPMSK_Z;
1098 vmesa->regEnable &= ~HC_HenZT_MASK;
1099
1100 /*=* [DBG] racer : can't display cars in car selection menu *=*/
1101 /*if (ctx->Depth.Mask)
1102 vmesa->regEnable |= HC_HenZW_MASK;
1103 else
1104 vmesa->regEnable &= (~HC_HenZW_MASK);*/
1105 vmesa->regEnable &= (~HC_HenZW_MASK);
1106
1107 vmesa->dirty |= VIA_UPLOAD_ENABLE;
1108 }
1109 }
1110
1111 void viaChooseLightState(GLcontext *ctx)
1112 {
1113 viaContextPtr vmesa = VIA_CONTEXT(ctx);
1114
1115 if (ctx->Light.ShadeModel == GL_SMOOTH) {
1116 vmesa->regCmdA |= HC_HShading_Gouraud;
1117 vmesa->regCmdB |= HC_HVPMSK_Cd;
1118 }
1119 else {
1120 vmesa->regCmdA &= ~HC_HShading_Gouraud;
1121 vmesa->regCmdB |= HC_HVPMSK_Cd;
1122 }
1123 }
1124
1125 void viaChooseLineState(GLcontext *ctx)
1126 {
1127 viaContextPtr vmesa = VIA_CONTEXT(ctx);
1128
1129 if (ctx->Line.SmoothFlag) {
1130 vmesa->regEnable |= HC_HenAA_MASK;
1131 }
1132 else {
1133 if (!ctx->Polygon.SmoothFlag) {
1134 vmesa->regEnable &= ~HC_HenAA_MASK;
1135 }
1136 }
1137
1138 if (ctx->Line.StippleFlag) {
1139 vmesa->regEnable |= HC_HenLP_MASK;
1140 vmesa->regHLP = ctx->Line.StipplePattern;
1141 vmesa->regHLPRF = ctx->Line.StippleFactor;
1142 vmesa->dirty |= VIA_UPLOAD_LINESTIPPLE;
1143 }
1144 else {
1145 vmesa->regEnable &= ~HC_HenLP_MASK;
1146 }
1147 vmesa->dirty |= VIA_UPLOAD_ENABLE;
1148 }
1149
1150 void viaChoosePolygonState(GLcontext *ctx)
1151 {
1152 viaContextPtr vmesa = VIA_CONTEXT(ctx);
1153
1154 if (ctx->Polygon.SmoothFlag) {
1155 vmesa->regEnable |= HC_HenAA_MASK;
1156 }
1157 else {
1158 if (!ctx->Line.SmoothFlag) {
1159 vmesa->regEnable &= ~HC_HenAA_MASK;
1160 }
1161 }
1162
1163 if (ctx->Polygon.StippleFlag) {
1164 vmesa->regEnable |= HC_HenSP_MASK;
1165 vmesa->dirty |= VIA_UPLOAD_POLYGONSTIPPLE;
1166 }
1167 else {
1168 vmesa->regEnable &= ~HC_HenSP_MASK;
1169 }
1170
1171 if (ctx->Polygon.CullFlag) {
1172 vmesa->regEnable |= HC_HenFBCull_MASK;
1173 }
1174 else {
1175 vmesa->regEnable &= ~HC_HenFBCull_MASK;
1176 }
1177 vmesa->dirty |= VIA_UPLOAD_ENABLE;
1178 }
1179
1180 void viaChooseStencilState(GLcontext *ctx)
1181 {
1182 viaContextPtr vmesa = VIA_CONTEXT(ctx);
1183 #ifdef DEBUG
1184 if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__);
1185 #endif
1186
1187 if (ctx->Stencil.Enabled) {
1188 GLuint temp;
1189
1190 vmesa->regEnable |= HC_HenST_MASK;
1191 temp = (ctx->Stencil.Ref[0] & 0xFF) << HC_HSTREF_SHIFT;
1192 temp |= 0xFF << HC_HSTOPMSK_SHIFT;
1193 temp |= (ctx->Stencil.ValueMask[0] & 0xFF);
1194 vmesa->regHSTREF = temp;
1195
1196 temp = (ctx->Stencil.Function[0] - GL_NEVER) << 16;
1197
1198 switch (ctx->Stencil.FailFunc[0]) {
1199 case GL_KEEP:
1200 temp |= HC_HSTOPSF_KEEP;
1201 break;
1202 case GL_ZERO:
1203 temp |= HC_HSTOPSF_ZERO;
1204 break;
1205 case GL_REPLACE:
1206 temp |= HC_HSTOPSF_REPLACE;
1207 break;
1208 case GL_INVERT:
1209 temp |= HC_HSTOPSF_INVERT;
1210 break;
1211 case GL_INCR:
1212 temp |= HC_HSTOPSF_INCR;
1213 break;
1214 case GL_DECR:
1215 temp |= HC_HSTOPSF_DECR;
1216 break;
1217 }
1218
1219 switch (ctx->Stencil.ZFailFunc[0]) {
1220 case GL_KEEP:
1221 temp |= HC_HSTOPSPZF_KEEP;
1222 break;
1223 case GL_ZERO:
1224 temp |= HC_HSTOPSPZF_ZERO;
1225 break;
1226 case GL_REPLACE:
1227 temp |= HC_HSTOPSPZF_REPLACE;
1228 break;
1229 case GL_INVERT:
1230 temp |= HC_HSTOPSPZF_INVERT;
1231 break;
1232 case GL_INCR:
1233 temp |= HC_HSTOPSPZF_INCR;
1234 break;
1235 case GL_DECR:
1236 temp |= HC_HSTOPSPZF_DECR;
1237 break;
1238 }
1239
1240 switch (ctx->Stencil.ZPassFunc[0]) {
1241 case GL_KEEP:
1242 temp |= HC_HSTOPSPZP_KEEP;
1243 break;
1244 case GL_ZERO:
1245 temp |= HC_HSTOPSPZP_ZERO;
1246 break;
1247 case GL_REPLACE:
1248 temp |= HC_HSTOPSPZP_REPLACE;
1249 break;
1250 case GL_INVERT:
1251 temp |= HC_HSTOPSPZP_INVERT;
1252 break;
1253 case GL_INCR:
1254 temp |= HC_HSTOPSPZP_INCR;
1255 break;
1256 case GL_DECR:
1257 temp |= HC_HSTOPSPZP_DECR;
1258 break;
1259 }
1260 vmesa->regHSTMD = temp;
1261
1262 vmesa->dirty |= (VIA_UPLOAD_STENCIL | VIA_UPLOAD_STENCIL);
1263 }
1264 else {
1265 vmesa->regEnable &= ~HC_HenST_MASK;
1266 vmesa->dirty |= VIA_UPLOAD_ENABLE;
1267 }
1268 #ifdef DEBUG
1269 if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__);
1270 #endif
1271 }
1272
1273 void viaChoosePoint(GLcontext *ctx)
1274 {
1275 ctx = ctx;
1276 }
1277
1278 void viaChooseLine(GLcontext *ctx)
1279 {
1280 ctx = ctx;
1281 }
1282
1283 void viaChooseTriangle(GLcontext *ctx)
1284 {
1285 viaContextPtr vmesa = VIA_CONTEXT(ctx);
1286 #ifdef DEBUG
1287 if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__);
1288
1289 if (VIA_DEBUG) fprintf(stderr, "GL_CULL_FACE = %x\n", GL_CULL_FACE);
1290 if (VIA_DEBUG) fprintf(stderr, "ctx->Polygon.CullFlag = %x\n", ctx->Polygon.CullFlag);
1291
1292 if (VIA_DEBUG) fprintf(stderr, "GL_FRONT = %x\n", GL_FRONT);
1293 if (VIA_DEBUG) fprintf(stderr, "ctx->Polygon.CullFaceMode = %x\n", ctx->Polygon.CullFaceMode);
1294 if (VIA_DEBUG) fprintf(stderr, "GL_CCW = %x\n", GL_CCW);
1295 if (VIA_DEBUG) fprintf(stderr, "ctx->Polygon.FrontFace = %x\n", ctx->Polygon.FrontFace);
1296 #endif
1297 if (ctx->Polygon.CullFlag == GL_TRUE) {
1298 switch (ctx->Polygon.CullFaceMode) {
1299 case GL_FRONT:
1300 if (ctx->Polygon.FrontFace == GL_CCW)
1301 vmesa->regCmdB |= HC_HBFace_MASK;
1302 else
1303 vmesa->regCmdB &= ~HC_HBFace_MASK;
1304 break;
1305 case GL_BACK:
1306 if (ctx->Polygon.FrontFace == GL_CW)
1307 vmesa->regCmdB |= HC_HBFace_MASK;
1308 else
1309 vmesa->regCmdB &= ~HC_HBFace_MASK;
1310 break;
1311 case GL_FRONT_AND_BACK:
1312 return;
1313 }
1314 }
1315 #ifdef DEBUG
1316 if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__);
1317 #endif
1318 }
1319
1320 static void viaChooseState(GLcontext *ctx, GLuint newState)
1321 {
1322 viaContextPtr vmesa = VIA_CONTEXT(ctx);
1323 struct gl_texture_unit *texUnit0 = &ctx->Texture.Unit[0];
1324 struct gl_texture_unit *texUnit1 = &ctx->Texture.Unit[1];
1325 #ifdef DEBUG
1326 if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__);
1327
1328 if (VIA_DEBUG) fprintf(stderr, "newState = %x\n", newState);
1329 #endif
1330 if (!(newState & (_NEW_COLOR |
1331 _NEW_TEXTURE |
1332 _NEW_DEPTH |
1333 _NEW_FOG |
1334 _NEW_LIGHT |
1335 _NEW_LINE |
1336 _NEW_POLYGON |
1337 _NEW_POLYGONSTIPPLE |
1338 _NEW_STENCIL)))
1339 return;
1340
1341 vmesa->dirty = 0;
1342 vmesa->newState = newState;
1343
1344 if (texUnit0->_ReallyEnabled || texUnit1->_ReallyEnabled || ctx->Fog.Enabled) {
1345 vmesa->regCmdB |= HC_HVPMSK_Cs;
1346 }
1347 else {
1348 vmesa->regCmdB &= ~ HC_HVPMSK_Cs;
1349 }
1350
1351 if (newState & _NEW_TEXTURE)
1352 viaChooseTextureState(ctx);
1353
1354 if (newState & _NEW_COLOR)
1355 viaChooseColorState(ctx);
1356
1357 if (newState & _NEW_DEPTH)
1358 viaChooseDepthState(ctx);
1359
1360 if (newState & _NEW_FOG)
1361 viaChooseFogState(ctx);
1362
1363 if (newState & _NEW_LIGHT)
1364 viaChooseLightState(ctx);
1365
1366 if (newState & _NEW_LINE)
1367 viaChooseLineState(ctx);
1368
1369 if (newState & (_NEW_POLYGON | _NEW_POLYGONSTIPPLE))
1370 viaChoosePolygonState(ctx);
1371
1372 if (newState & _NEW_STENCIL)
1373 viaChooseStencilState(ctx);
1374
1375 viaChooseTriangle(ctx);
1376
1377 #ifdef DEBUG
1378 if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__);
1379 #endif
1380 }
1381
1382 static void viaInvalidateState(GLcontext *ctx, GLuint newState)
1383 {
1384 _swrast_InvalidateState(ctx, newState);
1385 _swsetup_InvalidateState(ctx, newState);
1386 _ac_InvalidateState(ctx, newState);
1387 _tnl_InvalidateState(ctx, newState);
1388 viaChooseState(ctx, newState);
1389 }
1390
1391 void viaInitStateFuncs(GLcontext *ctx)
1392 {
1393 /* Callbacks for internal Mesa events.
1394 */
1395 ctx->Driver.UpdateState = viaInvalidateState;
1396
1397 /* API callbacks
1398 */
1399 ctx->Driver.AlphaFunc = viaAlphaFunc;
1400 ctx->Driver.BlendEquationSeparate = viaBlendEquationSeparate;
1401 ctx->Driver.BlendFuncSeparate = viaBlendFuncSeparate;
1402 ctx->Driver.ClearColor = viaClearColor;
1403 ctx->Driver.ColorMask = viaColorMask;
1404 ctx->Driver.CullFace = viaCullFaceFrontFace;
1405 ctx->Driver.DepthFunc = viaDepthFunc;
1406 ctx->Driver.DepthMask = viaDepthMask;
1407 ctx->Driver.DrawBuffer = viaDrawBuffer;
1408 ctx->Driver.Enable = viaEnable;
1409 ctx->Driver.Fogfv = viaFogfv;
1410 ctx->Driver.FrontFace = viaCullFaceFrontFace;
1411 ctx->Driver.LineWidth = viaLineWidth;
1412 ctx->Driver.LogicOpcode = viaLogicOp;
1413 ctx->Driver.PolygonStipple = viaPolygonStipple;
1414 ctx->Driver.RenderMode = viaRenderMode;
1415 ctx->Driver.Scissor = viaScissor;
1416 ctx->Driver.ShadeModel = viaShadeModel;
1417 ctx->Driver.DepthRange = viaDepthRange;
1418 ctx->Driver.Viewport = viaViewport;
1419 ctx->Driver.PointSize = viaPointSize;
1420 ctx->Driver.LightModelfv = viaLightModelfv;
1421
1422 /* Pixel path fallbacks.
1423 */
1424 ctx->Driver.Accum = _swrast_Accum;
1425 ctx->Driver.Bitmap = viaBitmap;
1426
1427 ctx->Driver.CopyPixels = _swrast_CopyPixels;
1428 ctx->Driver.DrawPixels = _swrast_DrawPixels;
1429 ctx->Driver.ReadPixels = _swrast_ReadPixels;
1430 ctx->Driver.ResizeBuffers = viaReAllocateBuffers;
1431
1432 /* Swrast hooks for imaging extensions:
1433 */
1434 ctx->Driver.CopyColorTable = _swrast_CopyColorTable;
1435 ctx->Driver.CopyColorSubTable = _swrast_CopyColorSubTable;
1436 ctx->Driver.CopyConvolutionFilter1D = _swrast_CopyConvolutionFilter1D;
1437 ctx->Driver.CopyConvolutionFilter2D = _swrast_CopyConvolutionFilter2D;
1438 }