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