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