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