projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Emit constant colors for texunit 1 blending.
[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_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
70
71 void viaEmitState(viaContextPtr vmesa)
72 {
73 GLcontext *ctx = vmesa->glCtx;
74 GLuint i = 0;
75 GLuint j = 0;
76 RING_VARS;
77
78 if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__);
79
80 viaCheckDma(vmesa, 0x110);
81
82 BEGIN_RING(5);
83 OUT_RING( HC_HEADER2 );
84 OUT_RING( (HC_ParaType_NotTex << 16) );
85 OUT_RING( ((HC_SubA_HEnable << 24) | vmesa->regEnable) );
86 OUT_RING( ((HC_SubA_HFBBMSKL << 24) | vmesa->regHFBBMSKL) );
87 OUT_RING( ((HC_SubA_HROP << 24) | vmesa->regHROP) );
88 ADVANCE_RING();
89
90 if (vmesa->have_hw_stencil) {
91 GLuint pitch, format, offset;
92
93 format = HC_HZWBFM_24;
94 offset = vmesa->depth.offset;
95 pitch = vmesa->depth.pitch;
96
97 BEGIN_RING(6);
98 OUT_RING( ((HC_SubA_HZWBBasL << 24) | (offset & 0xFFFFFF)) );
99 OUT_RING( ((HC_SubA_HZWBBasH << 24) | ((offset & 0xFF000000) >> 24)) );
100 OUT_RING( ((HC_SubA_HZWBType << 24) | HC_HDBLoc_Local | HC_HZONEasFF_MASK |
101 format | pitch) );
102 OUT_RING( ((HC_SubA_HZWTMD << 24) | vmesa->regHZWTMD) );
103 OUT_RING( ((HC_SubA_HSTREF << 24) | vmesa->regHSTREF) );
104 OUT_RING( ((HC_SubA_HSTMD << 24) | vmesa->regHSTMD) );
105 ADVANCE_RING();
106 }
107 else if (vmesa->hasDepth) {
108 GLuint pitch, format, offset;
109
110 if (vmesa->depthBits == 16) {
111 /* We haven't support 16bit depth yet */
112 format = HC_HZWBFM_16;
113 /*format = HC_HZWBFM_32;*/
114 if (VIA_DEBUG) fprintf(stderr, "z format = 16\n");
115 }
116 else {
117 format = HC_HZWBFM_32;
118 if (VIA_DEBUG) fprintf(stderr, "z format = 32\n");
119 }
120
121
122 offset = vmesa->depth.offset;
123 pitch = vmesa->depth.pitch;
124
125 BEGIN_RING(4);
126 OUT_RING( ((HC_SubA_HZWBBasL << 24) | (offset & 0xFFFFFF)) );
127 OUT_RING( ((HC_SubA_HZWBBasH << 24) | ((offset & 0xFF000000) >> 24)) );
128 OUT_RING( ((HC_SubA_HZWBType << 24) | HC_HDBLoc_Local | HC_HZONEasFF_MASK |
129 format | pitch) );
130 OUT_RING( ((HC_SubA_HZWTMD << 24) | vmesa->regHZWTMD) );
131 ADVANCE_RING();
132 }
133
134 if (ctx->Color.AlphaEnabled) {
135 BEGIN_RING(1);
136 OUT_RING( ((HC_SubA_HATMD << 24) | vmesa->regHATMD) );
137 ADVANCE_RING();
138 i++;
139 }
140
141 if (ctx->Color.BlendEnabled) {
142 BEGIN_RING(11);
143 OUT_RING( ((HC_SubA_HABLCsat << 24) | vmesa->regHABLCsat) );
144 OUT_RING( ((HC_SubA_HABLCop << 24) | vmesa->regHABLCop) );
145 OUT_RING( ((HC_SubA_HABLAsat << 24) | vmesa->regHABLAsat) );
146 OUT_RING( ((HC_SubA_HABLAop << 24) | vmesa->regHABLAop) );
147 OUT_RING( ((HC_SubA_HABLRCa << 24) | vmesa->regHABLRCa) );
148 OUT_RING( ((HC_SubA_HABLRFCa << 24) | vmesa->regHABLRFCa) );
149 OUT_RING( ((HC_SubA_HABLRCbias << 24) | vmesa->regHABLRCbias) );
150 OUT_RING( ((HC_SubA_HABLRCb << 24) | vmesa->regHABLRCb) );
151 OUT_RING( ((HC_SubA_HABLRFCb << 24) | vmesa->regHABLRFCb) );
152 OUT_RING( ((HC_SubA_HABLRAa << 24) | vmesa->regHABLRAa) );
153 OUT_RING( ((HC_SubA_HABLRAb << 24) | vmesa->regHABLRAb) );
154 ADVANCE_RING();
155 }
156
157 if (ctx->Fog.Enabled) {
158 BEGIN_RING(3);
159 OUT_RING( ((HC_SubA_HFogLF << 24) | vmesa->regHFogLF) );
160 OUT_RING( ((HC_SubA_HFogCL << 24) | vmesa->regHFogCL) );
161 OUT_RING( ((HC_SubA_HFogCH << 24) | vmesa->regHFogCH) );
162 ADVANCE_RING();
163 }
164
165 if (0 && ctx->Line.StippleFlag) {
166 BEGIN_RING(2);
167 OUT_RING( ((HC_SubA_HLP << 24) | ctx->Line.StipplePattern) );
168 OUT_RING( ((HC_SubA_HLPRF << 24) | ctx->Line.StippleFactor) );
169 ADVANCE_RING();
170 }
171 else {
172 BEGIN_RING(2);
173 OUT_RING( ((HC_SubA_HLP << 24) | 0xFFFF) );
174 OUT_RING( ((HC_SubA_HLPRF << 24) | 0x1) );
175 ADVANCE_RING();
176 }
177
178 BEGIN_RING(1);
179 OUT_RING( ((HC_SubA_HPixGC << 24) | 0x0) );
180 ADVANCE_RING();
181
182 QWORD_PAD_RING();
183
184
185 if (ctx->Texture._EnabledUnits) {
186
187 struct gl_texture_unit *texUnit0 = &ctx->Texture.Unit[0];
188 struct gl_texture_unit *texUnit1 = &ctx->Texture.Unit[1];
189
190 {
191 GLuint nDummyValue = 0;
192
193 BEGIN_RING( 8 );
194 OUT_RING( HC_HEADER2 );
195 OUT_RING( (HC_ParaType_Tex << 16) | (HC_SubType_TexGeneral << 24) );
196
197 if (texUnit0->Enabled && texUnit1->Enabled) {
198 if (VIA_DEBUG) fprintf(stderr, "multi texture\n");
199 nDummyValue = (HC_SubA_HTXSMD << 24) | (1 << 3);
200
201 }
202 else {
203 if (VIA_DEBUG) fprintf(stderr, "single texture\n");
204 nDummyValue = (HC_SubA_HTXSMD << 24) | 0;
205 }
206
207 /* Clear cache flag never set:
208 */
209 if (vmesa->clearTexCache) {
210 vmesa->clearTexCache = 0;
211 OUT_RING( nDummyValue | HC_HTXCHCLR_MASK );
212 OUT_RING( nDummyValue );
213 }
214 else {
215 OUT_RING( nDummyValue );
216 OUT_RING( nDummyValue );
217 }
218
219 OUT_RING( HC_HEADER2 );
220 OUT_RING( HC_ParaType_NotTex << 16 );
221 OUT_RING( (HC_SubA_HEnable << 24) | vmesa->regEnable );
222 OUT_RING( (HC_SubA_HEnable << 24) | vmesa->regEnable );
223 ADVANCE_RING();
224 }
225
226 if (texUnit0->Enabled) {
227 struct gl_texture_object *texObj = texUnit0->_Current;
228 viaTextureObjectPtr t = (viaTextureObjectPtr)texObj->DriverData;
229 GLuint numLevels = t->lastLevel - t->firstLevel + 1;
230 if (VIA_DEBUG) {
231 fprintf(stderr, "texture0 enabled\n");
232 fprintf(stderr, "texture level %d\n", t->actualLevel);
233 }
234 if (numLevels == 8) {
235 BEGIN_RING(27);
236 OUT_RING( HC_HEADER2 );
237 OUT_RING( (HC_ParaType_Tex << 16) | (0 << 24) );
238 OUT_RING( t->regTexFM );
239 OUT_RING( (HC_SubA_HTXnL0OS << 24) |
240 ((t->lastLevel) << HC_HTXnLVmax_SHIFT) | t->firstLevel );
241 OUT_RING( t->regTexWidthLog2[0] );
242 OUT_RING( t->regTexWidthLog2[1] );
243 OUT_RING( t->regTexHeightLog2[0] );
244 OUT_RING( t->regTexHeightLog2[1] );
245 OUT_RING( t->regTexBaseH[0] );
246 OUT_RING( t->regTexBaseH[1] );
247 OUT_RING( t->regTexBaseH[2] );
248 OUT_RING( t->regTexBaseAndPitch[0].baseL );
249 OUT_RING( t->regTexBaseAndPitch[0].pitchLog2 );
250 OUT_RING( t->regTexBaseAndPitch[1].baseL );
251 OUT_RING( t->regTexBaseAndPitch[1].pitchLog2 );
252 OUT_RING( t->regTexBaseAndPitch[2].baseL );
253 OUT_RING( t->regTexBaseAndPitch[2].pitchLog2 );
254 OUT_RING( t->regTexBaseAndPitch[3].baseL );
255 OUT_RING( t->regTexBaseAndPitch[3].pitchLog2 );
256 OUT_RING( t->regTexBaseAndPitch[4].baseL );
257 OUT_RING( t->regTexBaseAndPitch[4].pitchLog2 );
258 OUT_RING( t->regTexBaseAndPitch[5].baseL );
259 OUT_RING( t->regTexBaseAndPitch[5].pitchLog2 );
260 OUT_RING( t->regTexBaseAndPitch[6].baseL );
261 OUT_RING( t->regTexBaseAndPitch[6].pitchLog2 );
262 OUT_RING( t->regTexBaseAndPitch[7].baseL );
263 OUT_RING( t->regTexBaseAndPitch[7].pitchLog2 );
264 ADVANCE_RING();
265 }
266 else if (numLevels > 1) {
267
268 BEGIN_RING(12 + numLevels * 2);
269 OUT_RING( HC_HEADER2 );
270 OUT_RING( (HC_ParaType_Tex << 16) | (0 << 24) );
271 OUT_RING( t->regTexFM );
272 OUT_RING( (HC_SubA_HTXnL0OS << 24) |
273 ((t->lastLevel) << HC_HTXnLVmax_SHIFT) | t->firstLevel );
274 OUT_RING( t->regTexWidthLog2[0] );
275 OUT_RING( t->regTexHeightLog2[0] );
276
277 if (numLevels > 6) {
278 OUT_RING( t->regTexWidthLog2[1] );
279 OUT_RING( t->regTexHeightLog2[1] );
280 }
281
282 OUT_RING( t->regTexBaseH[0] );
283
284 if (numLevels > 3) {
285 OUT_RING( t->regTexBaseH[1] );
286 }
287 if (numLevels > 6) {
288 OUT_RING( t->regTexBaseH[2] );
289 }
290 if (numLevels > 9) {
291 OUT_RING( t->regTexBaseH[3] );
292 }
293
294 for (j = 0; j < numLevels; j++) {
295 OUT_RING( t->regTexBaseAndPitch[j].baseL );
296 OUT_RING( t->regTexBaseAndPitch[j].pitchLog2 );
297 }
298
299 ADVANCE_RING_VARIABLE();
300 }
301 else {
302
303 BEGIN_RING(9);
304 OUT_RING( HC_HEADER2 );
305 OUT_RING( (HC_ParaType_Tex << 16) | (0 << 24) );
306 OUT_RING( t->regTexFM );
307 OUT_RING( (HC_SubA_HTXnL0OS << 24) |
308 ((t->lastLevel) << HC_HTXnLVmax_SHIFT) | t->firstLevel );
309 OUT_RING( t->regTexWidthLog2[0] );
310 OUT_RING( t->regTexHeightLog2[0] );
311 OUT_RING( t->regTexBaseH[0] );
312 OUT_RING( t->regTexBaseAndPitch[0].baseL );
313 OUT_RING( t->regTexBaseAndPitch[0].pitchLog2 );
314 ADVANCE_RING();
315 }
316
317 BEGIN_RING(12);
318 OUT_RING( (HC_SubA_HTXnTB << 24) | vmesa->regHTXnTB_0 );
319 OUT_RING( (HC_SubA_HTXnMPMD << 24) | vmesa->regHTXnMPMD_0 );
320 OUT_RING( (HC_SubA_HTXnTBLCsat << 24) | vmesa->regHTXnTBLCsat_0 );
321 OUT_RING( (HC_SubA_HTXnTBLCop << 24) | vmesa->regHTXnTBLCop_0 );
322 OUT_RING( (HC_SubA_HTXnTBLMPfog << 24) | vmesa->regHTXnTBLMPfog_0 );
323 OUT_RING( (HC_SubA_HTXnTBLAsat << 24) | vmesa->regHTXnTBLAsat_0 );
324 OUT_RING( (HC_SubA_HTXnTBLRCb << 24) | vmesa->regHTXnTBLRCb_0 );
325 OUT_RING( (HC_SubA_HTXnTBLRAa << 24) | vmesa->regHTXnTBLRAa_0 );
326 OUT_RING( (HC_SubA_HTXnTBLRFog << 24) | vmesa->regHTXnTBLRFog_0 );
327 OUT_RING( (HC_SubA_HTXnTBLRCa << 24) | vmesa->regHTXnTBLRCa_0 );
328 OUT_RING( (HC_SubA_HTXnTBLRCc << 24) | vmesa->regHTXnTBLRCc_0 );
329 OUT_RING( (HC_SubA_HTXnTBLRCbias << 24) | vmesa->regHTXnTBLRCbias_0 );
330 ADVANCE_RING();
331
332 if (t->regTexFM == HC_HTXnFM_Index8) {
333 struct gl_color_table *table = &texObj->Palette;
334 GLfloat *tableF = (GLfloat *)table->Table;
335
336 BEGIN_RING(2 + table->Size);
337 OUT_RING( HC_HEADER2 );
338 OUT_RING( (HC_ParaType_Palette << 16) | (0 << 24) );
339 for (j = 0; j < table->Size; j++)
340 OUT_RING( tableF[j] );
341 ADVANCE_RING();
342
343 }
344
345 QWORD_PAD_RING();
346 }
347
348 if (texUnit1->Enabled) {
349 struct gl_texture_object *texObj = texUnit1->_Current;
350 viaTextureObjectPtr t = (viaTextureObjectPtr)texObj->DriverData;
351 GLuint numLevels = t->lastLevel - t->firstLevel + 1;
352 int texunit = (texUnit0->Enabled ? 1 : 0);
353 if (VIA_DEBUG) {
354 fprintf(stderr, "texture1 enabled\n");
355 fprintf(stderr, "texture level %d\n", t->actualLevel);
356 }
357 if (numLevels == 8) {
358 BEGIN_RING(27);
359 OUT_RING( HC_HEADER2 );
360 OUT_RING( (HC_ParaType_Tex << 16) | (texunit << 24) );
361 OUT_RING( t->regTexFM );
362 OUT_RING( (HC_SubA_HTXnL0OS << 24) |
363 ((t->lastLevel) << HC_HTXnLVmax_SHIFT) | t->firstLevel );
364 OUT_RING( t->regTexWidthLog2[0] );
365 OUT_RING( t->regTexWidthLog2[1] );
366 OUT_RING( t->regTexHeightLog2[0] );
367 OUT_RING( t->regTexHeightLog2[1] );
368 OUT_RING( t->regTexBaseH[0] );
369 OUT_RING( t->regTexBaseH[1] );
370 OUT_RING( t->regTexBaseH[2] );
371 OUT_RING( t->regTexBaseAndPitch[0].baseL );
372 OUT_RING( t->regTexBaseAndPitch[0].pitchLog2 );
373 OUT_RING( t->regTexBaseAndPitch[1].baseL );
374 OUT_RING( t->regTexBaseAndPitch[1].pitchLog2 );
375 OUT_RING( t->regTexBaseAndPitch[2].baseL );
376 OUT_RING( t->regTexBaseAndPitch[2].pitchLog2 );
377 OUT_RING( t->regTexBaseAndPitch[3].baseL );
378 OUT_RING( t->regTexBaseAndPitch[3].pitchLog2 );
379 OUT_RING( t->regTexBaseAndPitch[4].baseL );
380 OUT_RING( t->regTexBaseAndPitch[4].pitchLog2 );
381 OUT_RING( t->regTexBaseAndPitch[5].baseL );
382 OUT_RING( t->regTexBaseAndPitch[5].pitchLog2 );
383 OUT_RING( t->regTexBaseAndPitch[6].baseL );
384 OUT_RING( t->regTexBaseAndPitch[6].pitchLog2 );
385 OUT_RING( t->regTexBaseAndPitch[7].baseL );
386 OUT_RING( t->regTexBaseAndPitch[7].pitchLog2 );
387 ADVANCE_RING();
388 }
389 else if (numLevels > 1) {
390 BEGIN_RING(12 + numLevels * 2);
391 OUT_RING( HC_HEADER2 );
392 OUT_RING( (HC_ParaType_Tex << 16) | (texunit << 24) );
393 OUT_RING( t->regTexFM );
394 OUT_RING( (HC_SubA_HTXnL0OS << 24) |
395 ((t->lastLevel) << HC_HTXnLVmax_SHIFT) | t->firstLevel );
396 OUT_RING( t->regTexWidthLog2[0] );
397 OUT_RING( t->regTexHeightLog2[0] );
398
399 if (numLevels > 6) {
400 OUT_RING( t->regTexWidthLog2[1] );
401 OUT_RING( t->regTexHeightLog2[1] );
402 i += 2;
403 }
404
405 OUT_RING( t->regTexBaseH[0] );
406
407 if (numLevels > 3) {
408 OUT_RING( t->regTexBaseH[1] );
409 }
410 if (numLevels > 6) {
411 OUT_RING( t->regTexBaseH[2] );
412 }
413 if (numLevels > 9) {
414 OUT_RING( t->regTexBaseH[3] );
415 }
416
417 for (j = 0; j < numLevels; j++) {
418 OUT_RING( t->regTexBaseAndPitch[j].baseL );
419 OUT_RING( t->regTexBaseAndPitch[j].pitchLog2 );
420 }
421 ADVANCE_RING_VARIABLE();
422 }
423 else {
424 BEGIN_RING(9);
425 OUT_RING( HC_HEADER2 );
426 OUT_RING( (HC_ParaType_Tex << 16) | (texunit << 24) );
427 OUT_RING( t->regTexFM );
428 OUT_RING( (HC_SubA_HTXnL0OS << 24) |
429 ((t->lastLevel) << HC_HTXnLVmax_SHIFT) | t->firstLevel );
430 OUT_RING( t->regTexWidthLog2[0] );
431 OUT_RING( t->regTexHeightLog2[0] );
432 OUT_RING( t->regTexBaseH[0] );
433 OUT_RING( t->regTexBaseAndPitch[0].baseL );
434 OUT_RING( t->regTexBaseAndPitch[0].pitchLog2 );
435 ADVANCE_RING();
436 }
437
438 BEGIN_RING(12);
439 OUT_RING( (HC_SubA_HTXnTB << 24) | vmesa->regHTXnTB_1 );
440 OUT_RING( (HC_SubA_HTXnMPMD << 24) | vmesa->regHTXnMPMD_1 );
441 OUT_RING( (HC_SubA_HTXnTBLCsat << 24) | vmesa->regHTXnTBLCsat_1 );
442 OUT_RING( (HC_SubA_HTXnTBLCop << 24) | vmesa->regHTXnTBLCop_1 );
443 OUT_RING( (HC_SubA_HTXnTBLMPfog << 24) | vmesa->regHTXnTBLMPfog_1 );
444 OUT_RING( (HC_SubA_HTXnTBLAsat << 24) | vmesa->regHTXnTBLAsat_1 );
445 OUT_RING( (HC_SubA_HTXnTBLRCb << 24) | vmesa->regHTXnTBLRCb_1 );
446 OUT_RING( (HC_SubA_HTXnTBLRAa << 24) | vmesa->regHTXnTBLRAa_1 );
447 OUT_RING( (HC_SubA_HTXnTBLRFog << 24) | vmesa->regHTXnTBLRFog_1 );
448 OUT_RING( (HC_SubA_HTXnTBLRCa << 24) | vmesa->regHTXnTBLRCa_1 );
449 OUT_RING( (HC_SubA_HTXnTBLRCc << 24) | vmesa->regHTXnTBLRCc_1 );
450 OUT_RING( (HC_SubA_HTXnTBLRCbias << 24) | vmesa->regHTXnTBLRCbias_1 );
451 ADVANCE_RING();
452
453 if (t->regTexFM == HC_HTXnFM_Index8) {
454 struct gl_color_table *table = &texObj->Palette;
455 GLfloat *tableF = (GLfloat *)table->Table;
456
457 BEGIN_RING(2 + table->Size);
458 OUT_RING( HC_HEADER2 );
459 OUT_RING( (HC_ParaType_Palette << 16) | (texunit << 24) );
460 for (j = 0; j < table->Size; j++) {
461 OUT_RING( tableF[j] );
462 }
463 ADVANCE_RING();
464 }
465
466 QWORD_PAD_RING();
467 }
468 }
469
470 if (ctx->Polygon.StippleFlag) {
471 GLuint *stipple = &vmesa->stipple[0];
472
473 BEGIN_RING(38);
474 OUT_RING( HC_HEADER2 );
475 OUT_RING( ((HC_ParaType_Palette << 16) | (HC_SubType_Stipple << 24)) );
476 OUT_RING( stipple[31] );
477 OUT_RING( stipple[30] );
478 OUT_RING( stipple[29] );
479 OUT_RING( stipple[28] );
480 OUT_RING( stipple[27] );
481 OUT_RING( stipple[26] );
482 OUT_RING( stipple[25] );
483 OUT_RING( stipple[24] );
484 OUT_RING( stipple[23] );
485 OUT_RING( stipple[22] );
486 OUT_RING( stipple[21] );
487 OUT_RING( stipple[20] );
488 OUT_RING( stipple[19] );
489 OUT_RING( stipple[18] );
490 OUT_RING( stipple[17] );
491 OUT_RING( stipple[16] );
492 OUT_RING( stipple[15] );
493 OUT_RING( stipple[14] );
494 OUT_RING( stipple[13] );
495 OUT_RING( stipple[12] );
496 OUT_RING( stipple[11] );
497 OUT_RING( stipple[10] );
498 OUT_RING( stipple[9] );
499 OUT_RING( stipple[8] );
500 OUT_RING( stipple[7] );
501 OUT_RING( stipple[6] );
502 OUT_RING( stipple[5] );
503 OUT_RING( stipple[4] );
504 OUT_RING( stipple[3] );
505 OUT_RING( stipple[2] );
506 OUT_RING( stipple[1] );
507 OUT_RING( stipple[0] );
508 OUT_RING( HC_HEADER2 );
509 OUT_RING( (HC_ParaType_NotTex << 16) );
510 OUT_RING( ((HC_SubA_HSPXYOS << 24) | (0x20 - (vmesa->driDrawable->h & 0x1F))) );
511 OUT_RING( ((HC_SubA_HSPXYOS << 24) | (0x20 - (vmesa->driDrawable->h & 0x1F))) );
512 ADVANCE_RING();
513 }
514
515 if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__);
516
517 vmesa->newEmitState = 0;
518 }
519
520
521 static __inline__ GLuint viaPackColor(GLuint format,
522 GLubyte r, GLubyte g,
523 GLubyte b, GLubyte a)
524 {
525 switch (format) {
526 case 0x10:
527 return PACK_COLOR_565(r, g, b);
528 case 0x20:
529 return PACK_COLOR_8888(a, r, g, b);
530 default:
531 if (VIA_DEBUG) fprintf(stderr, "unknown format %d\n", (int)format);
532 return PACK_COLOR_8888(a, r, g, b);
533 }
534 }
535
536 static void viaBlendEquationSeparate(GLcontext *ctx, GLenum rgbMode, GLenum aMode)
537 {
538 if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__);
539
540 /* GL_EXT_blend_equation_separate not supported */
541 ASSERT(rgbMode == aMode);
542
543 /* Can only do GL_ADD equation in hardware */
544 FALLBACK(VIA_CONTEXT(ctx), VIA_FALLBACK_BLEND_EQ, rgbMode != GL_FUNC_ADD_EXT);
545
546 /* BlendEquation sets ColorLogicOpEnabled in an unexpected
547 * manner.
548 */
549 FALLBACK(VIA_CONTEXT(ctx), VIA_FALLBACK_LOGICOP,
550 (ctx->Color.ColorLogicOpEnabled &&
551 ctx->Color.LogicOp != GL_COPY));
552 if (VIA_DEBUG) fprintf(stderr, "%s out\n", __FUNCTION__);
553 }
554
555 static void viaBlendFunc(GLcontext *ctx, GLenum sfactor, GLenum dfactor)
556 {
557 viaContextPtr vmesa = VIA_CONTEXT(ctx);
558 GLboolean fallback = GL_FALSE;
559 if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__);
560
561 switch (ctx->Color.BlendSrcRGB) {
562 case GL_SRC_ALPHA_SATURATE:
563 case GL_CONSTANT_COLOR:
564 case GL_ONE_MINUS_CONSTANT_COLOR:
565 case GL_CONSTANT_ALPHA:
566 case GL_ONE_MINUS_CONSTANT_ALPHA:
567 fallback = GL_TRUE;
568 break;
569 default:
570 break;
571 }
572
573 switch (ctx->Color.BlendDstRGB) {
574 case GL_CONSTANT_COLOR:
575 case GL_ONE_MINUS_CONSTANT_COLOR:
576 case GL_CONSTANT_ALPHA:
577 case GL_ONE_MINUS_CONSTANT_ALPHA:
578 fallback = GL_TRUE;
579 break;
580 default:
581 break;
582 }
583
584 FALLBACK(vmesa, VIA_FALLBACK_BLEND_FUNC, fallback);
585 if (VIA_DEBUG) fprintf(stderr, "%s out\n", __FUNCTION__);
586 }
587
588 /* Shouldn't be called as the extension is disabled.
589 */
590 static void viaBlendFuncSeparate(GLcontext *ctx, GLenum sfactorRGB,
591 GLenum dfactorRGB, GLenum sfactorA,
592 GLenum dfactorA)
593 {
594 if (dfactorRGB != dfactorA || sfactorRGB != sfactorA) {
595 _mesa_error(ctx, GL_INVALID_OPERATION, "glBlendEquation (disabled)");
596 }
597
598 viaBlendFunc(ctx, sfactorRGB, dfactorRGB);
599 }
600
601
602
603
604 /* =============================================================
605 * Hardware clipping
606 */
607 static void viaScissor(GLcontext *ctx, GLint x, GLint y,
608 GLsizei w, GLsizei h)
609 {
610 viaContextPtr vmesa = VIA_CONTEXT(ctx);
611
612 if (!vmesa->driDrawable)
613 return;
614
615 if (VIA_DEBUG)
616 fprintf(stderr, "%s %d,%d %dx%d, drawH %d\n", __FUNCTION__, x,y,w,h, vmesa->driDrawable->h);
617
618 if (vmesa->scissor) {
619 VIA_FLUSH_DMA(vmesa); /* don't pipeline cliprect changes */
620 }
621
622 vmesa->scissorRect.x1 = x;
623 vmesa->scissorRect.y1 = vmesa->driDrawable->h - y - h;
624 vmesa->scissorRect.x2 = x + w;
625 vmesa->scissorRect.y2 = vmesa->driDrawable->h - y;
626
627 if (VIA_DEBUG) fprintf(stderr, "%s out\n", __FUNCTION__);
628 }
629
630 static void viaEnable(GLcontext *ctx, GLenum cap, GLboolean state)
631 {
632 viaContextPtr vmesa = VIA_CONTEXT(ctx);
633
634 switch (cap) {
635 case GL_SCISSOR_TEST:
636 VIA_FLUSH_DMA(vmesa);
637 vmesa->scissor = state;
638 break;
639 default:
640 break;
641 }
642 }
643
644
645
646 /* Fallback to swrast for select and feedback.
647 */
648 static void viaRenderMode(GLcontext *ctx, GLenum mode)
649 {
650 FALLBACK(VIA_CONTEXT(ctx), VIA_FALLBACK_RENDERMODE, (mode != GL_RENDER));
651 }
652
653
654 static void viaDrawBuffer(GLcontext *ctx, GLenum mode)
655 {
656 viaContextPtr vmesa = VIA_CONTEXT(ctx);
657 if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__);
658 if (mode == GL_FRONT) {
659 VIA_FLUSH_DMA(vmesa);
660 vmesa->drawBuffer = vmesa->readBuffer = &vmesa->front;
661 FALLBACK(vmesa, VIA_FALLBACK_DRAW_BUFFER, GL_FALSE);
662 return;
663 }
664 else if (mode == GL_BACK) {
665 VIA_FLUSH_DMA(vmesa);
666 vmesa->drawBuffer = vmesa->readBuffer = &vmesa->back;
667 FALLBACK(vmesa, VIA_FALLBACK_DRAW_BUFFER, GL_FALSE);
668 return;
669 }
670 else {
671 FALLBACK(vmesa, VIA_FALLBACK_DRAW_BUFFER, GL_TRUE);
672 return;
673 }
674
675 viaXMesaWindowMoved(vmesa);
676
677 /* We want to update the s/w rast state too so that viaSetBuffer()
678 * gets called.
679 */
680 _swrast_DrawBuffer(ctx, mode);
681
682
683 if (VIA_DEBUG) fprintf(stderr, "%s out\n", __FUNCTION__);
684 }
685
686 static void viaClearColor(GLcontext *ctx, const GLfloat color[4])
687 {
688 viaContextPtr vmesa = VIA_CONTEXT(ctx);
689 GLubyte pcolor[4];
690 CLAMPED_FLOAT_TO_UBYTE(pcolor[0], color[0]);
691 CLAMPED_FLOAT_TO_UBYTE(pcolor[1], color[1]);
692 CLAMPED_FLOAT_TO_UBYTE(pcolor[2], color[2]);
693 CLAMPED_FLOAT_TO_UBYTE(pcolor[3], color[3]);
694 vmesa->ClearColor = viaPackColor(vmesa->viaScreen->bitsPerPixel,
695 pcolor[0], pcolor[1],
696 pcolor[2], pcolor[3]);
697
698 }
699
700 #define WRITEMASK_ALPHA_SHIFT 31
701 #define WRITEMASK_RED_SHIFT 30
702 #define WRITEMASK_GREEN_SHIFT 29
703 #define WRITEMASK_BLUE_SHIFT 28
704
705 static void viaColorMask(GLcontext *ctx,
706 GLboolean r, GLboolean g,
707 GLboolean b, GLboolean a)
708 {
709 viaContextPtr vmesa = VIA_CONTEXT( ctx );
710
711 if (VIA_DEBUG)
712 fprintf(stderr, "%s r(%d) g(%d) b(%d) a(%d)\n", __FUNCTION__, r, g, b, a);
713
714 vmesa->ClearMask = (((!r) << WRITEMASK_RED_SHIFT) |
715 ((!g) << WRITEMASK_GREEN_SHIFT) |
716 ((!b) << WRITEMASK_BLUE_SHIFT) |
717 ((!a) << WRITEMASK_ALPHA_SHIFT));
718 }
719
720
721 /* =============================================================
722 */
723
724
725 /* Using drawXoff like this is incorrect outside of locked regions.
726 * This hardware just isn't capable of private back buffers without
727 * glitches and/or a hefty locking scheme.
728 */
729 void viaCalcViewport(GLcontext *ctx)
730 {
731 viaContextPtr vmesa = VIA_CONTEXT(ctx);
732 const GLfloat *v = ctx->Viewport._WindowMap.m;
733 GLfloat *m = vmesa->ViewportMatrix.m;
734
735 /* See also via_translate_vertex.
736 */
737 m[MAT_SX] = v[MAT_SX];
738 m[MAT_TX] = v[MAT_TX] + SUBPIXEL_X + vmesa->drawXoff;
739 m[MAT_SY] = - v[MAT_SY];
740 m[MAT_TY] = - v[MAT_TY] + vmesa->driDrawable->h + SUBPIXEL_Y;
741 m[MAT_SZ] = v[MAT_SZ] * (1.0 / vmesa->depth_max);
742 m[MAT_TZ] = v[MAT_TZ] * (1.0 / vmesa->depth_max);
743 }
744
745 static void viaViewport(GLcontext *ctx,
746 GLint x, GLint y,
747 GLsizei width, GLsizei height)
748 {
749 /* update size of Mesa/software ancillary buffers */
750 _mesa_ResizeBuffersMESA();
751 viaCalcViewport(ctx);
752 }
753
754 static void viaDepthRange(GLcontext *ctx,
755 GLclampd nearval, GLclampd farval)
756 {
757 viaCalcViewport(ctx);
758 }
759
760 #if 0
761 static void
762 flip_bytes( GLubyte *p, GLuint n )
763 {
764 register GLuint i, a, b;
765
766 for (i=0;i<n;i++) {
767 b = (GLuint) p[i]; /* words are often faster than bytes */
768 a = ((b & 0x01) << 7) |
769 ((b & 0x02) << 5) |
770 ((b & 0x04) << 3) |
771 ((b & 0x08) << 1) |
772 ((b & 0x10) >> 1) |
773 ((b & 0x20) >> 3) |
774 ((b & 0x40) >> 5) |
775 ((b & 0x80) >> 7);
776 p[i] = (GLubyte) a;
777 }
778 }
779 #endif
780
781 static void viaPolygonStipple( GLcontext *ctx, const GLubyte *mask )
782 {
783 viaContextPtr vmesa = VIA_CONTEXT(ctx);
784 GLubyte *s = (GLubyte *)vmesa->stipple;
785 int i;
786
787 /* Fallback for the CLE266 case. Stipple works on the CLE266, but
788 * the stipple x/y offset registers don't seem to be respected,
789 * meaning that when drawXoff != 0, the stipple is rotated left or
790 * right by a few pixels, giving incorrect results.
791 */
792 if (vmesa->viaScreen->deviceID == VIA_CLE266) {
793 FALLBACK( vmesa, VIA_FALLBACK_STIPPLE, ctx->Polygon.StippleFlag);
794 } else {
795 for (i=0;i<128;i++)
796 s[i] = mask[i];
797 }
798 }
799
800 void viaInitState(GLcontext *ctx)
801 {
802 viaContextPtr vmesa = VIA_CONTEXT(ctx);
803
804 vmesa->regCmdA = HC_ACMD_HCmdA;
805 vmesa->regCmdB = HC_ACMD_HCmdB;
806 vmesa->regEnable = HC_HenCW_MASK;
807
808 /* Mesa should do this for us:
809 */
810
811 ctx->Driver.BlendEquationSeparate( ctx,
812 ctx->Color.BlendEquationRGB,
813 ctx->Color.BlendEquationA);
814
815 ctx->Driver.BlendFuncSeparate( ctx,
816 ctx->Color.BlendSrcRGB,
817 ctx->Color.BlendDstRGB,
818 ctx->Color.BlendSrcA,
819 ctx->Color.BlendDstA);
820
821 ctx->Driver.Scissor( ctx, ctx->Scissor.X, ctx->Scissor.Y,
822 ctx->Scissor.Width, ctx->Scissor.Height );
823
824 ctx->Driver.DrawBuffer( ctx, ctx->Color.DrawBuffer[0] );
825 }
826
827 /**
828 * Convert S and T texture coordinate wrap modes to hardware bits.
829 */
830 static u_int32_t
831 get_wrap_mode( GLenum sWrap, GLenum tWrap )
832 {
833 u_int32_t v = 0;
834
835
836 switch( sWrap ) {
837 case GL_REPEAT:
838 v |= HC_HTXnMPMD_Srepeat;
839 break;
840 case GL_CLAMP:
841 case GL_CLAMP_TO_EDGE:
842 v |= HC_HTXnMPMD_Sclamp;
843 break;
844 case GL_MIRRORED_REPEAT:
845 v |= HC_HTXnMPMD_Smirror;
846 break;
847 }
848
849 switch( tWrap ) {
850 case GL_REPEAT:
851 v |= HC_HTXnMPMD_Trepeat;
852 break;
853 case GL_CLAMP:
854 case GL_CLAMP_TO_EDGE:
855 v |= HC_HTXnMPMD_Tclamp;
856 break;
857 case GL_MIRRORED_REPEAT:
858 v |= HC_HTXnMPMD_Tmirror;
859 break;
860 }
861
862 return v;
863 }
864
865
866 static void viaChooseTextureState(GLcontext *ctx)
867 {
868 viaContextPtr vmesa = VIA_CONTEXT(ctx);
869 struct gl_texture_unit *texUnit0 = &ctx->Texture.Unit[0];
870 struct gl_texture_unit *texUnit1 = &ctx->Texture.Unit[1];
871 /*=* John Sheng [2003.7.18] texture combine *=*/
872
873 if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__);
874 if (texUnit0->_ReallyEnabled || texUnit1->_ReallyEnabled) {
875 if (VIA_DEBUG) {
876 fprintf(stderr, "Texture._ReallyEnabled - in\n");
877 fprintf(stderr, "texUnit0->_ReallyEnabled = %x\n",texUnit0->_ReallyEnabled);
878 }
879
880 if (VIA_DEBUG) {
881 struct gl_texture_object *texObj0 = texUnit0->_Current;
882 struct gl_texture_object *texObj1 = texUnit1->_Current;
883
884 fprintf(stderr, "env mode: 0x%04x / 0x%04x\n", texUnit0->EnvMode, texUnit1->EnvMode);
885
886 if ( (texObj0 != NULL) && (texObj0->Image[0][0] != NULL) )
887 fprintf(stderr, "format 0: 0x%04x\n", texObj0->Image[0][0]->Format);
888
889 if ( (texObj1 != NULL) && (texObj1->Image[0][0] != NULL) )
890 fprintf(stderr, "format 1: 0x%04x\n", texObj1->Image[0][0]->Format);
891 }
892
893
894 if (texUnit0->_ReallyEnabled) {
895 struct gl_texture_object *texObj = texUnit0->_Current;
896
897 if (VIA_DEBUG) fprintf(stderr, "texUnit0->_ReallyEnabled\n");
898
899 vmesa->regEnable |= HC_HenTXMP_MASK | HC_HenTXCH_MASK | HC_HenTXPP_MASK;
900
901 switch (texObj->MinFilter) {
902 case GL_NEAREST:
903 vmesa->regHTXnTB_0 = HC_HTXnFLSs_Nearest |
904 HC_HTXnFLTs_Nearest;
905 break;
906 case GL_LINEAR:
907 vmesa->regHTXnTB_0 = HC_HTXnFLSs_Linear |
908 HC_HTXnFLTs_Linear;
909 break;
910 case GL_NEAREST_MIPMAP_NEAREST:
911 vmesa->regHTXnTB_0 = HC_HTXnFLSs_Nearest |
912 HC_HTXnFLTs_Nearest;
913 vmesa->regHTXnTB_0 |= HC_HTXnFLDs_Nearest;
914 break;
915 case GL_LINEAR_MIPMAP_NEAREST:
916 vmesa->regHTXnTB_0 = HC_HTXnFLSs_Linear |
917 HC_HTXnFLTs_Linear;
918 vmesa->regHTXnTB_0 |= HC_HTXnFLDs_Nearest;
919 break;
920 case GL_NEAREST_MIPMAP_LINEAR:
921 vmesa->regHTXnTB_0 = HC_HTXnFLSs_Nearest |
922 HC_HTXnFLTs_Nearest;
923 vmesa->regHTXnTB_0 |= HC_HTXnFLDs_Linear;
924 break;
925 case GL_LINEAR_MIPMAP_LINEAR:
926 vmesa->regHTXnTB_0 = HC_HTXnFLSs_Linear |
927 HC_HTXnFLTs_Linear;
928 vmesa->regHTXnTB_0 |= HC_HTXnFLDs_Linear;
929 break;
930 default:
931 break;
932 }
933
934 switch (texObj->MagFilter) {
935 case GL_LINEAR:
936 vmesa->regHTXnTB_0 |= HC_HTXnFLSe_Linear |
937 HC_HTXnFLTe_Linear;
938 break;
939 case GL_NEAREST:
940 vmesa->regHTXnTB_0 |= HC_HTXnFLSe_Nearest |
941 HC_HTXnFLTe_Nearest;
942 break;
943 default:
944 break;
945 }
946
947 vmesa->regHTXnMPMD_0 &= ~(HC_HTXnMPMD_SMASK | HC_HTXnMPMD_TMASK);
948 vmesa->regHTXnMPMD_0 |= get_wrap_mode( texObj->WrapS,
949 texObj->WrapT );
950
951 if (VIA_DEBUG) fprintf(stderr, "texUnit0->EnvMode %x\n",texUnit0->EnvMode);
952
953 viaTexCombineState( vmesa, texUnit0->_CurrentCombine, 0 );
954 }
955
956 if (texUnit1->_ReallyEnabled) {
957 struct gl_texture_object *texObj = texUnit1->_Current;
958
959 vmesa->regEnable |= HC_HenTXMP_MASK | HC_HenTXCH_MASK | HC_HenTXPP_MASK;
960
961 switch (texObj->MinFilter) {
962 case GL_NEAREST:
963 vmesa->regHTXnTB_1 = HC_HTXnFLSs_Nearest |
964 HC_HTXnFLTs_Nearest;
965 break;
966 case GL_LINEAR:
967 vmesa->regHTXnTB_1 = HC_HTXnFLSs_Linear |
968 HC_HTXnFLTs_Linear;
969 break;
970 case GL_NEAREST_MIPMAP_NEAREST:
971 vmesa->regHTXnTB_1 = HC_HTXnFLSs_Nearest |
972 HC_HTXnFLTs_Nearest;
973 vmesa->regHTXnTB_1 |= HC_HTXnFLDs_Nearest;
974 break ;
975 case GL_LINEAR_MIPMAP_NEAREST:
976 vmesa->regHTXnTB_1 = HC_HTXnFLSs_Linear |
977 HC_HTXnFLTs_Linear;
978 vmesa->regHTXnTB_1 |= HC_HTXnFLDs_Nearest;
979 break ;
980 case GL_NEAREST_MIPMAP_LINEAR:
981 vmesa->regHTXnTB_1 = HC_HTXnFLSs_Nearest |
982 HC_HTXnFLTs_Nearest;
983 vmesa->regHTXnTB_1 |= HC_HTXnFLDs_Linear;
984 break ;
985 case GL_LINEAR_MIPMAP_LINEAR:
986 vmesa->regHTXnTB_1 = HC_HTXnFLSs_Linear |
987 HC_HTXnFLTs_Linear;
988 vmesa->regHTXnTB_1 |= HC_HTXnFLDs_Linear;
989 break ;
990 default:
991 break;
992 }
993
994 switch(texObj->MagFilter) {
995 case GL_LINEAR:
996 vmesa->regHTXnTB_1 |= HC_HTXnFLSe_Linear |
997 HC_HTXnFLTe_Linear;
998 break;
999 case GL_NEAREST:
1000 vmesa->regHTXnTB_1 |= HC_HTXnFLSe_Nearest |
1001 HC_HTXnFLTe_Nearest;
1002 break;
1003 default:
1004 break;
1005 }
1006
1007 vmesa->regHTXnMPMD_1 &= ~(HC_HTXnMPMD_SMASK | HC_HTXnMPMD_TMASK);
1008 vmesa->regHTXnMPMD_1 |= get_wrap_mode( texObj->WrapS,
1009 texObj->WrapT );
1010
1011 viaTexCombineState( vmesa, texUnit1->_CurrentCombine, 1 );
1012 }
1013
1014 if (VIA_DEBUG) {
1015 fprintf( stderr, "Csat_0 / Cop_0 = 0x%08x / 0x%08x\n",
1016 vmesa->regHTXnTBLCsat_0, vmesa->regHTXnTBLCop_0 );
1017 fprintf( stderr, "Asat_0 = 0x%08x\n",
1018 vmesa->regHTXnTBLAsat_0 );
1019 fprintf( stderr, "RCb_0 / RAa_0 = 0x%08x / 0x%08x\n",
1020 vmesa->regHTXnTBLRCb_0, vmesa->regHTXnTBLRAa_0 );
1021 fprintf( stderr, "RCa_0 / RCc_0 = 0x%08x / 0x%08x\n",
1022 vmesa->regHTXnTBLRCa_0, vmesa->regHTXnTBLRCc_0 );
1023 fprintf( stderr, "RCbias_0 = 0x%08x\n",
1024 vmesa->regHTXnTBLRCbias_0 );
1025 }
1026 }
1027 else {
1028 vmesa->regEnable &= (~(HC_HenTXMP_MASK | HC_HenTXCH_MASK | HC_HenTXPP_MASK));
1029 }
1030 if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__);
1031
1032 }
1033
1034 static void viaChooseColorState(GLcontext *ctx)
1035 {
1036 viaContextPtr vmesa = VIA_CONTEXT(ctx);
1037 GLenum s = ctx->Color.BlendSrcRGB;
1038 GLenum d = ctx->Color.BlendDstRGB;
1039
1040 /* The HW's blending equation is:
1041 * (Ca * FCa + Cbias + Cb * FCb) << Cshift
1042 */
1043 if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__);
1044
1045 if (ctx->Color.BlendEnabled) {
1046 vmesa->regEnable |= HC_HenABL_MASK;
1047 /* Ca -- always from source color.
1048 */
1049 vmesa->regHABLCsat = HC_HABLCsat_MASK | HC_HABLCa_OPC |
1050 HC_HABLCa_Csrc;
1051 /* Aa -- always from source alpha.
1052 */
1053 vmesa->regHABLAsat = HC_HABLAsat_MASK | HC_HABLAa_OPA |
1054 HC_HABLAa_Asrc;
1055 /* FCa -- depend on following condition.
1056 * FAa -- depend on following condition.
1057 */
1058 switch (s) {
1059 case GL_ZERO:
1060 /* (0, 0, 0, 0)
1061 */
1062 vmesa->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_HABLRCa;
1063 vmesa->regHABLAsat |= HC_HABLFAa_OPA | HC_HABLFAa_HABLFRA;
1064 vmesa->regHABLRFCa = 0x0;
1065 vmesa->regHABLRAa = 0x0;
1066 break;
1067 case GL_ONE:
1068 /* (1, 1, 1, 1)
1069 */
1070 vmesa->regHABLCsat |= HC_HABLFCa_InvOPC | HC_HABLFCa_HABLRCa;
1071 vmesa->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_HABLFRA;
1072 vmesa->regHABLRFCa = 0x0;
1073 vmesa->regHABLRAa = 0x0;
1074 break;
1075 case GL_SRC_COLOR:
1076 /* (Rs, Gs, Bs, As)
1077 */
1078 vmesa->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_Csrc;
1079 vmesa->regHABLAsat |= HC_HABLFAa_OPA | HC_HABLFAa_Asrc;
1080 break;
1081 case GL_ONE_MINUS_SRC_COLOR:
1082 /* (1, 1, 1, 1) - (Rs, Gs, Bs, As)
1083 */
1084 vmesa->regHABLCsat |= HC_HABLFCa_InvOPC | HC_HABLFCa_Csrc;
1085 vmesa->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_Asrc;
1086 break;
1087 case GL_DST_COLOR:
1088 /* (Rd, Gd, Bd, Ad)
1089 */
1090 vmesa->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_Cdst;
1091 vmesa->regHABLAsat |= HC_HABLFAa_OPA | HC_HABLFAa_Adst;
1092 break;
1093 case GL_ONE_MINUS_DST_COLOR:
1094 /* (1, 1, 1, 1) - (Rd, Gd, Bd, Ad)
1095 */
1096 vmesa->regHABLCsat |= HC_HABLFCa_InvOPC | HC_HABLFCa_Cdst;
1097 vmesa->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_Adst;
1098 break;
1099 case GL_SRC_ALPHA:
1100 /* (As, As, As, As)
1101 */
1102 vmesa->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_Asrc;
1103 vmesa->regHABLAsat |= HC_HABLFAa_OPA | HC_HABLFAa_Asrc;
1104 break;
1105 case GL_ONE_MINUS_SRC_ALPHA:
1106 /* (1, 1, 1, 1) - (As, As, As, As)
1107 */
1108 vmesa->regHABLCsat |= HC_HABLFCa_InvOPC | HC_HABLFCa_Asrc;
1109 vmesa->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_Asrc;
1110 break;
1111 case GL_DST_ALPHA:
1112 {
1113 if (vmesa->viaScreen->bitsPerPixel == 16) {
1114 /* (1, 1, 1, 1)
1115 */
1116 vmesa->regHABLCsat |= HC_HABLFCa_InvOPC | HC_HABLFCa_HABLRCa;
1117 vmesa->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_HABLFRA;
1118 vmesa->regHABLRFCa = 0x0;
1119 vmesa->regHABLRAa = 0x0;
1120 }
1121 else {
1122 /* (Ad, Ad, Ad, Ad)
1123 */
1124 vmesa->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_Adst;
1125 vmesa->regHABLAsat |= HC_HABLFAa_OPA | HC_HABLFAa_Adst;
1126 }
1127 }
1128 break;
1129 case GL_ONE_MINUS_DST_ALPHA:
1130 {
1131 if (vmesa->viaScreen->bitsPerPixel == 16) {
1132 /* (1, 1, 1, 1) - (1, 1, 1, 1) = (0, 0, 0, 0)
1133 */
1134 vmesa->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_HABLRCa;
1135 vmesa->regHABLAsat |= HC_HABLFAa_OPA | HC_HABLFAa_HABLFRA;
1136 vmesa->regHABLRFCa = 0x0;
1137 vmesa->regHABLRAa = 0x0;
1138 }
1139 else {
1140 /* (1, 1, 1, 1) - (Ad, Ad, Ad, Ad)
1141 */
1142 vmesa->regHABLCsat |= HC_HABLFCa_InvOPC | HC_HABLFCa_Adst;
1143 vmesa->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_Adst;
1144 }
1145 }
1146 break;
1147 case GL_SRC_ALPHA_SATURATE:
1148 {
1149 if (vmesa->viaScreen->bitsPerPixel == 16) {
1150 /* (f, f, f, 1), f = min(As, 1 - Ad) = min(As, 1 - 1) = 0
1151 * So (f, f, f, 1) = (0, 0, 0, 1)
1152 */
1153 vmesa->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_HABLRCa;
1154 vmesa->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_HABLFRA;
1155 vmesa->regHABLRFCa = 0x0;
1156 vmesa->regHABLRAa = 0x0;
1157 }
1158 else {
1159 /* (f, f, f, 1), f = min(As, 1 - Ad)
1160 */
1161 vmesa->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_mimAsrcInvAdst;
1162 vmesa->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_HABLFRA;
1163 vmesa->regHABLRFCa = 0x0;
1164 vmesa->regHABLRAa = 0x0;
1165 }
1166 }
1167 break;
1168 }
1169
1170 /* Op is add.
1171 */
1172
1173 /* bias is 0.
1174 */
1175 vmesa->regHABLCsat |= HC_HABLCbias_HABLRCbias;
1176 vmesa->regHABLAsat |= HC_HABLAbias_HABLRAbias;
1177
1178 /* Cb -- always from destination color.
1179 */
1180 vmesa->regHABLCop = HC_HABLCb_OPC | HC_HABLCb_Cdst;
1181 /* Ab -- always from destination alpha.
1182 */
1183 vmesa->regHABLAop = HC_HABLAb_OPA | HC_HABLAb_Adst;
1184 /* FCb -- depend on following condition.
1185 */
1186 switch (d) {
1187 case GL_ZERO:
1188 /* (0, 0, 0, 0)
1189 */
1190 vmesa->regHABLCop |= HC_HABLFCb_OPC | HC_HABLFCb_HABLRCb;
1191 vmesa->regHABLAop |= HC_HABLFAb_OPA | HC_HABLFAb_HABLFRA;
1192 vmesa->regHABLRFCb = 0x0;
1193 vmesa->regHABLRAb = 0x0;
1194 break;
1195 case GL_ONE:
1196 /* (1, 1, 1, 1)
1197 */
1198 vmesa->regHABLCop |= HC_HABLFCb_InvOPC | HC_HABLFCb_HABLRCb;
1199 vmesa->regHABLAop |= HC_HABLFAb_InvOPA | HC_HABLFAb_HABLFRA;
1200 vmesa->regHABLRFCb = 0x0;
1201 vmesa->regHABLRAb = 0x0;
1202 break;
1203 case GL_SRC_COLOR:
1204 /* (Rs, Gs, Bs, As)
1205 */
1206 vmesa->regHABLCop |= HC_HABLFCb_OPC | HC_HABLFCb_Csrc;
1207 vmesa->regHABLAop |= HC_HABLFAb_OPA | HC_HABLFAb_Asrc;
1208 break;
1209 case GL_ONE_MINUS_SRC_COLOR:
1210 /* (1, 1, 1, 1) - (Rs, Gs, Bs, As)
1211 */
1212 vmesa->regHABLCop |= HC_HABLFCb_InvOPC | HC_HABLFCb_Csrc;
1213 vmesa->regHABLAop |= HC_HABLFAb_InvOPA | HC_HABLFAb_Asrc;
1214 break;
1215 case GL_DST_COLOR:
1216 /* (Rd, Gd, Bd, Ad)
1217 */
1218 vmesa->regHABLCop |= HC_HABLFCb_OPC | HC_HABLFCb_Cdst;
1219 vmesa->regHABLAop |= HC_HABLFAb_OPA | HC_HABLFAb_Adst;
1220 break;
1221 case GL_ONE_MINUS_DST_COLOR:
1222 /* (1, 1, 1, 1) - (Rd, Gd, Bd, Ad)
1223 */
1224 vmesa->regHABLCop |= HC_HABLFCb_InvOPC | HC_HABLFCb_Cdst;
1225 vmesa->regHABLAop |= HC_HABLFAb_InvOPA | HC_HABLFAb_Adst;
1226 break;
1227 case GL_SRC_ALPHA:
1228 /* (As, As, As, As)
1229 */
1230 vmesa->regHABLCop |= HC_HABLFCb_OPC | HC_HABLFCb_Asrc;
1231 vmesa->regHABLAop |= HC_HABLFAb_OPA | HC_HABLFAb_Asrc;
1232 break;
1233 case GL_ONE_MINUS_SRC_ALPHA:
1234 /* (1, 1, 1, 1) - (As, As, As, As)
1235 */
1236 vmesa->regHABLCop |= HC_HABLFCb_InvOPC | HC_HABLFCb_Asrc;
1237 vmesa->regHABLAop |= HC_HABLFAb_InvOPA | HC_HABLFAb_Asrc;
1238 break;
1239 case GL_DST_ALPHA:
1240 {
1241 if (vmesa->viaScreen->bitsPerPixel == 16) {
1242 /* (1, 1, 1, 1)
1243 */
1244 vmesa->regHABLCop |= HC_HABLFCb_InvOPC | HC_HABLFCb_HABLRCb;
1245 vmesa->regHABLAop |= HC_HABLFAb_InvOPA | HC_HABLFAb_HABLFRA;
1246 vmesa->regHABLRFCb = 0x0;
1247 vmesa->regHABLRAb = 0x0;
1248 }
1249 else {
1250 /* (Ad, Ad, Ad, Ad)
1251 */
1252 vmesa->regHABLCop |= HC_HABLFCb_OPC | HC_HABLFCb_Adst;
1253 vmesa->regHABLAop |= HC_HABLFAb_OPA | HC_HABLFAb_Adst;
1254 }
1255 }
1256 break;
1257 case GL_ONE_MINUS_DST_ALPHA:
1258 {
1259 if (vmesa->viaScreen->bitsPerPixel == 16) {
1260 /* (1, 1, 1, 1) - (1, 1, 1, 1) = (0, 0, 0, 0)
1261 */
1262 vmesa->regHABLCop |= HC_HABLFCb_OPC | HC_HABLFCb_HABLRCb;
1263 vmesa->regHABLAop |= HC_HABLFAb_OPA | HC_HABLFAb_HABLFRA;
1264 vmesa->regHABLRFCb = 0x0;
1265 vmesa->regHABLRAb = 0x0;
1266 }
1267 else {
1268 /* (1, 1, 1, 1) - (Ad, Ad, Ad, Ad)
1269 */
1270 vmesa->regHABLCop |= HC_HABLFCb_InvOPC | HC_HABLFCb_Adst;
1271 vmesa->regHABLAop |= HC_HABLFAb_InvOPA | HC_HABLFAb_Adst;
1272 }
1273 }
1274 break;
1275 default:
1276 vmesa->regHABLCop |= HC_HABLFCb_OPC | HC_HABLFCb_HABLRCb;
1277 vmesa->regHABLAop |= HC_HABLFAb_OPA | HC_HABLFAb_HABLFRA;
1278 vmesa->regHABLRFCb = 0x0;
1279 vmesa->regHABLRAb = 0x0;
1280 break;
1281 }
1282
1283 if (vmesa->viaScreen->bitsPerPixel <= 16)
1284 vmesa->regEnable &= ~HC_HenDT_MASK;
1285
1286 }
1287 else {
1288 vmesa->regEnable &= (~HC_HenABL_MASK);
1289 }
1290
1291 if (ctx->Color.AlphaEnabled) {
1292 vmesa->regEnable |= HC_HenAT_MASK;
1293 vmesa->regHATMD = FLOAT_TO_UBYTE(ctx->Color.AlphaRef) |
1294 ((ctx->Color.AlphaFunc - GL_NEVER) << 8);
1295 }
1296 else {
1297 vmesa->regEnable &= (~HC_HenAT_MASK);
1298 }
1299
1300 if (ctx->Color.DitherFlag && (vmesa->viaScreen->bitsPerPixel < 32)) {
1301 if (ctx->Color.BlendEnabled) {
1302 vmesa->regEnable &= ~HC_HenDT_MASK;
1303 }
1304 else {
1305 vmesa->regEnable |= HC_HenDT_MASK;
1306 }
1307 }
1308
1309
1310 vmesa->regEnable &= ~HC_HenDT_MASK;
1311
1312 if (ctx->Color.ColorLogicOpEnabled)
1313 vmesa->regHROP = ROP[ctx->Color.LogicOp & 0xF];
1314 else
1315 vmesa->regHROP = HC_HROP_P;
1316
1317 vmesa->regHFBBMSKL = PACK_COLOR_888(ctx->Color.ColorMask[0],
1318 ctx->Color.ColorMask[1],
1319 ctx->Color.ColorMask[2]);
1320 vmesa->regHROP |= ctx->Color.ColorMask[3];
1321
1322 if (ctx->Color.ColorMask[3])
1323 vmesa->regEnable |= HC_HenAW_MASK;
1324 else
1325 vmesa->regEnable &= ~HC_HenAW_MASK;
1326
1327 if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__);
1328 }
1329
1330 static void viaChooseFogState(GLcontext *ctx)
1331 {
1332 viaContextPtr vmesa = VIA_CONTEXT(ctx);
1333
1334 if (ctx->Fog.Enabled) {
1335 GLubyte r, g, b, a;
1336
1337 vmesa->regEnable |= HC_HenFOG_MASK;
1338
1339 /* Use fog equation 0 (OpenGL's default) & local fog.
1340 */
1341 vmesa->regHFogLF = 0x0;
1342
1343 r = (GLubyte)(ctx->Fog.Color[0] * 255.0F);
1344 g = (GLubyte)(ctx->Fog.Color[1] * 255.0F);
1345 b = (GLubyte)(ctx->Fog.Color[2] * 255.0F);
1346 a = (GLubyte)(ctx->Fog.Color[3] * 255.0F);
1347 vmesa->regHFogCL = (r << 16) | (g << 8) | b;
1348 vmesa->regHFogCH = a;
1349 }
1350 else {
1351 vmesa->regEnable &= ~HC_HenFOG_MASK;
1352 }
1353 }
1354
1355 static void viaChooseDepthState(GLcontext *ctx)
1356 {
1357 viaContextPtr vmesa = VIA_CONTEXT(ctx);
1358 if (ctx->Depth.Test) {
1359 vmesa->regEnable |= HC_HenZT_MASK;
1360 if (ctx->Depth.Mask)
1361 vmesa->regEnable |= HC_HenZW_MASK;
1362 else
1363 vmesa->regEnable &= (~HC_HenZW_MASK);
1364 vmesa->regHZWTMD = (ctx->Depth.Func - GL_NEVER) << 16;
1365
1366 }
1367 else {
1368 vmesa->regEnable &= ~HC_HenZT_MASK;
1369
1370 /*=* [DBG] racer : can't display cars in car selection menu *=*/
1371 /*if (ctx->Depth.Mask)
1372 vmesa->regEnable |= HC_HenZW_MASK;
1373 else
1374 vmesa->regEnable &= (~HC_HenZW_MASK);*/
1375 vmesa->regEnable &= (~HC_HenZW_MASK);
1376 }
1377 }
1378
1379 static void viaChooseLightState(GLcontext *ctx)
1380 {
1381 viaContextPtr vmesa = VIA_CONTEXT(ctx);
1382
1383 if (ctx->Light.ShadeModel == GL_SMOOTH) {
1384 vmesa->regCmdA |= HC_HShading_Gouraud;
1385 }
1386 else {
1387 vmesa->regCmdA &= ~HC_HShading_Gouraud;
1388 }
1389 }
1390
1391 static void viaChooseLineState(GLcontext *ctx)
1392 {
1393 viaContextPtr vmesa = VIA_CONTEXT(ctx);
1394
1395 if (ctx->Line.SmoothFlag) {
1396 vmesa->regEnable |= HC_HenAA_MASK;
1397 }
1398 else {
1399 if (!ctx->Polygon.SmoothFlag) {
1400 vmesa->regEnable &= ~HC_HenAA_MASK;
1401 }
1402 }
1403
1404 if (0 && ctx->Line.StippleFlag) {
1405 vmesa->regEnable |= HC_HenLP_MASK;
1406 vmesa->regHLP = ctx->Line.StipplePattern;
1407 vmesa->regHLPRF = ctx->Line.StippleFactor;
1408 }
1409 else {
1410 vmesa->regEnable &= ~HC_HenLP_MASK;
1411 }
1412 }
1413
1414 static void viaChoosePolygonState(GLcontext *ctx)
1415 {
1416 viaContextPtr vmesa = VIA_CONTEXT(ctx);
1417
1418 /* KW: FIXME: this should be in viaRasterPrimitive (somehow)
1419 */
1420 if (ctx->Polygon.SmoothFlag) {
1421 vmesa->regEnable |= HC_HenAA_MASK;
1422 }
1423 else {
1424 if (!ctx->Line.SmoothFlag) {
1425 vmesa->regEnable &= ~HC_HenAA_MASK;
1426 }
1427 }
1428
1429 if (vmesa->viaScreen->deviceID != VIA_CLE266) {
1430 if (ctx->Polygon.StippleFlag) {
1431 vmesa->regEnable |= HC_HenSP_MASK;
1432 }
1433 else {
1434 vmesa->regEnable &= ~HC_HenSP_MASK;
1435 }
1436 }
1437
1438 if (ctx->Polygon.CullFlag) {
1439 vmesa->regEnable |= HC_HenFBCull_MASK;
1440 }
1441 else {
1442 vmesa->regEnable &= ~HC_HenFBCull_MASK;
1443 }
1444 }
1445
1446 static void viaChooseStencilState(GLcontext *ctx)
1447 {
1448 viaContextPtr vmesa = VIA_CONTEXT(ctx);
1449 if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__);
1450
1451 if (ctx->Stencil.Enabled) {
1452 GLuint temp;
1453
1454 vmesa->regEnable |= HC_HenST_MASK;
1455 temp = (ctx->Stencil.Ref[0] & 0xFF) << HC_HSTREF_SHIFT;
1456 temp |= 0xFF << HC_HSTOPMSK_SHIFT;
1457 temp |= (ctx->Stencil.ValueMask[0] & 0xFF);
1458 vmesa->regHSTREF = temp;
1459
1460 temp = (ctx->Stencil.Function[0] - GL_NEVER) << 16;
1461
1462 switch (ctx->Stencil.FailFunc[0]) {
1463 case GL_KEEP:
1464 temp |= HC_HSTOPSF_KEEP;
1465 break;
1466 case GL_ZERO:
1467 temp |= HC_HSTOPSF_ZERO;
1468 break;
1469 case GL_REPLACE:
1470 temp |= HC_HSTOPSF_REPLACE;
1471 break;
1472 case GL_INVERT:
1473 temp |= HC_HSTOPSF_INVERT;
1474 break;
1475 case GL_INCR:
1476 temp |= HC_HSTOPSF_INCR;
1477 break;
1478 case GL_DECR:
1479 temp |= HC_HSTOPSF_DECR;
1480 break;
1481 }
1482
1483 switch (ctx->Stencil.ZFailFunc[0]) {
1484 case GL_KEEP:
1485 temp |= HC_HSTOPSPZF_KEEP;
1486 break;
1487 case GL_ZERO:
1488 temp |= HC_HSTOPSPZF_ZERO;
1489 break;
1490 case GL_REPLACE:
1491 temp |= HC_HSTOPSPZF_REPLACE;
1492 break;
1493 case GL_INVERT:
1494 temp |= HC_HSTOPSPZF_INVERT;
1495 break;
1496 case GL_INCR:
1497 temp |= HC_HSTOPSPZF_INCR;
1498 break;
1499 case GL_DECR:
1500 temp |= HC_HSTOPSPZF_DECR;
1501 break;
1502 }
1503
1504 switch (ctx->Stencil.ZPassFunc[0]) {
1505 case GL_KEEP:
1506 temp |= HC_HSTOPSPZP_KEEP;
1507 break;
1508 case GL_ZERO:
1509 temp |= HC_HSTOPSPZP_ZERO;
1510 break;
1511 case GL_REPLACE:
1512 temp |= HC_HSTOPSPZP_REPLACE;
1513 break;
1514 case GL_INVERT:
1515 temp |= HC_HSTOPSPZP_INVERT;
1516 break;
1517 case GL_INCR:
1518 temp |= HC_HSTOPSPZP_INCR;
1519 break;
1520 case GL_DECR:
1521 temp |= HC_HSTOPSPZP_DECR;
1522 break;
1523 }
1524 vmesa->regHSTMD = temp;
1525 }
1526 else {
1527 vmesa->regEnable &= ~HC_HenST_MASK;
1528 }
1529 if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__);
1530 }
1531
1532
1533
1534 static void viaChooseTriangle(GLcontext *ctx)
1535 {
1536 viaContextPtr vmesa = VIA_CONTEXT(ctx);
1537 if (VIA_DEBUG) {
1538 fprintf(stderr, "%s - in\n", __FUNCTION__);
1539 fprintf(stderr, "GL_CULL_FACE = %x\n", GL_CULL_FACE);
1540 fprintf(stderr, "ctx->Polygon.CullFlag = %x\n", ctx->Polygon.CullFlag);
1541 fprintf(stderr, "GL_FRONT = %x\n", GL_FRONT);
1542 fprintf(stderr, "ctx->Polygon.CullFaceMode = %x\n", ctx->Polygon.CullFaceMode);
1543 fprintf(stderr, "GL_CCW = %x\n", GL_CCW);
1544 fprintf(stderr, "ctx->Polygon.FrontFace = %x\n", ctx->Polygon.FrontFace);
1545 }
1546 if (ctx->Polygon.CullFlag == GL_TRUE) {
1547 switch (ctx->Polygon.CullFaceMode) {
1548 case GL_FRONT:
1549 if (ctx->Polygon.FrontFace == GL_CCW)
1550 vmesa->regCmdB |= HC_HBFace_MASK;
1551 else
1552 vmesa->regCmdB &= ~HC_HBFace_MASK;
1553 break;
1554 case GL_BACK:
1555 if (ctx->Polygon.FrontFace == GL_CW)
1556 vmesa->regCmdB |= HC_HBFace_MASK;
1557 else
1558 vmesa->regCmdB &= ~HC_HBFace_MASK;
1559 break;
1560 case GL_FRONT_AND_BACK:
1561 return;
1562 }
1563 }
1564 if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__);
1565 }
1566
1567 void viaValidateState( GLcontext *ctx )
1568 {
1569 viaContextPtr vmesa = VIA_CONTEXT(ctx);
1570
1571 if (vmesa->newState & _NEW_TEXTURE) {
1572 viaChooseTextureState(ctx);
1573 viaUpdateTextureState(ctx); /* May modify vmesa->Fallback */
1574 }
1575
1576 if (vmesa->newState & _NEW_COLOR)
1577 viaChooseColorState(ctx);
1578
1579 if (vmesa->newState & _NEW_DEPTH)
1580 viaChooseDepthState(ctx);
1581
1582 if (vmesa->newState & _NEW_FOG)
1583 viaChooseFogState(ctx);
1584
1585 if (vmesa->newState & _NEW_LIGHT)
1586 viaChooseLightState(ctx);
1587
1588 if (vmesa->newState & _NEW_LINE)
1589 viaChooseLineState(ctx);
1590
1591 if (vmesa->newState & (_NEW_POLYGON | _NEW_POLYGONSTIPPLE)) {
1592 viaChoosePolygonState(ctx);
1593 viaChooseTriangle(ctx);
1594 }
1595
1596 if ((vmesa->newState & _NEW_STENCIL) && vmesa->have_hw_stencil)
1597 viaChooseStencilState(ctx);
1598
1599 if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR)
1600 vmesa->regEnable |= HC_HenCS_MASK;
1601 else
1602 vmesa->regEnable &= ~HC_HenCS_MASK;
1603
1604 vmesa->newEmitState |= vmesa->newState;
1605 vmesa->newState = 0;
1606 }
1607
1608 static void viaInvalidateState(GLcontext *ctx, GLuint newState)
1609 {
1610 viaContextPtr vmesa = VIA_CONTEXT(ctx);
1611
1612 VIA_FINISH_PRIM( vmesa );
1613 vmesa->newState |= newState;
1614
1615 _swrast_InvalidateState(ctx, newState);
1616 _swsetup_InvalidateState(ctx, newState);
1617 _ac_InvalidateState(ctx, newState);
1618 _tnl_InvalidateState(ctx, newState);
1619 }
1620
1621 void viaInitStateFuncs(GLcontext *ctx)
1622 {
1623 /* Callbacks for internal Mesa events.
1624 */
1625 ctx->Driver.UpdateState = viaInvalidateState;
1626
1627 /* API callbacks
1628 */
1629 ctx->Driver.BlendEquationSeparate = viaBlendEquationSeparate;
1630 ctx->Driver.BlendFuncSeparate = viaBlendFuncSeparate;
1631 ctx->Driver.ClearColor = viaClearColor;
1632 ctx->Driver.ColorMask = viaColorMask;
1633 ctx->Driver.DrawBuffer = viaDrawBuffer;
1634 ctx->Driver.RenderMode = viaRenderMode;
1635 ctx->Driver.Scissor = viaScissor;
1636 ctx->Driver.DepthRange = viaDepthRange;
1637 ctx->Driver.Viewport = viaViewport;
1638 ctx->Driver.Enable = viaEnable;
1639 ctx->Driver.PolygonStipple = viaPolygonStipple;
1640
1641 /* Pixel path fallbacks.
1642 */
1643 ctx->Driver.Accum = _swrast_Accum;
1644 ctx->Driver.Bitmap = _swrast_Bitmap;
1645 ctx->Driver.CopyPixels = _swrast_CopyPixels;
1646 ctx->Driver.DrawPixels = _swrast_DrawPixels;
1647 ctx->Driver.ReadPixels = _swrast_ReadPixels;
1648 ctx->Driver.ResizeBuffers = viaReAllocateBuffers;
1649
1650 /* Swrast hooks for imaging extensions:
1651 */
1652 ctx->Driver.CopyColorTable = _swrast_CopyColorTable;
1653 ctx->Driver.CopyColorSubTable = _swrast_CopyColorSubTable;
1654 ctx->Driver.CopyConvolutionFilter1D = _swrast_CopyConvolutionFilter1D;
1655 ctx->Driver.CopyConvolutionFilter2D = _swrast_CopyConvolutionFilter2D;
1656 }