#include <stdio.h>
-#include "glheader.h"
-#include "buffers.h"
-#include "context.h"
-#include "macros.h"
-#include "colormac.h"
-#include "enums.h"
-#include "dd.h"
-
-#include "mm.h"
+#include "main/glheader.h"
+#include "main/context.h"
+#include "main/macros.h"
+#include "main/colormac.h"
+#include "main/enums.h"
+#include "main/dd.h"
+#include "main/mm.h"
+
#include "via_context.h"
#include "via_state.h"
#include "via_tex.h"
-#include "via_vb.h"
#include "via_tris.h"
#include "via_ioctl.h"
+#include "via_3d_reg.h"
#include "swrast/swrast.h"
-#include "array_cache/acache.h"
+#include "vbo/vbo.h"
#include "tnl/tnl.h"
#include "swrast_setup/swrast_setup.h"
HC_HROP_WHITE /* GL_SET 1 */
};
+/*
+ * Compute the 'S5.5' lod bias factor from the floating point OpenGL bias.
+ */
+static GLuint viaComputeLodBias(GLfloat bias)
+{
+ int b = (int) (bias * 32.0);
+ if (b > 511)
+ b = 511;
+ else if (b < -512)
+ b = -512;
+ return (GLuint) b;
+}
-
-static void via_emit_state(viaContextPtr vmesa)
+void viaEmitState(struct via_context *vmesa)
{
GLcontext *ctx = vmesa->glCtx;
GLuint i = 0;
GLuint j = 0;
RING_VARS;
- if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__);
-
viaCheckDma(vmesa, 0x110);
BEGIN_RING(5);
pitch = vmesa->depth.pitch;
BEGIN_RING(6);
- OUT_RING( ((HC_SubA_HZWBBasL << 24) | (offset & 0xFFFFFF)) );
- OUT_RING( ((HC_SubA_HZWBBasH << 24) | ((offset & 0xFF000000) >> 24)) );
- OUT_RING( ((HC_SubA_HZWBType << 24) | HC_HDBLoc_Local | HC_HZONEasFF_MASK |
- format | pitch) );
- OUT_RING( ((HC_SubA_HZWTMD << 24) | vmesa->regHZWTMD) );
- OUT_RING( ((HC_SubA_HSTREF << 24) | vmesa->regHSTREF) );
- OUT_RING( ((HC_SubA_HSTMD << 24) | vmesa->regHSTMD) );
+ OUT_RING( (HC_SubA_HZWBBasL << 24) | (offset & 0xFFFFFF) );
+ OUT_RING( (HC_SubA_HZWBBasH << 24) | ((offset & 0xFF000000) >> 24) );
+ OUT_RING( (HC_SubA_HZWBType << 24) | HC_HDBLoc_Local | HC_HZONEasFF_MASK |
+ format | pitch );
+ OUT_RING( (HC_SubA_HZWTMD << 24) | vmesa->regHZWTMD );
+ OUT_RING( (HC_SubA_HSTREF << 24) | vmesa->regHSTREF );
+ OUT_RING( (HC_SubA_HSTMD << 24) | vmesa->regHSTMD );
ADVANCE_RING();
}
else if (vmesa->hasDepth) {
GLuint pitch, format, offset;
if (vmesa->depthBits == 16) {
- /* We haven't support 16bit depth yet */
format = HC_HZWBFM_16;
- /*format = HC_HZWBFM_32;*/
- if (VIA_DEBUG) fprintf(stderr, "z format = 16\n");
}
else {
format = HC_HZWBFM_32;
- if (VIA_DEBUG) fprintf(stderr, "z format = 32\n");
}
pitch = vmesa->depth.pitch;
BEGIN_RING(4);
- OUT_RING( ((HC_SubA_HZWBBasL << 24) | (offset & 0xFFFFFF)) );
- OUT_RING( ((HC_SubA_HZWBBasH << 24) | ((offset & 0xFF000000) >> 24)) );
- OUT_RING( ((HC_SubA_HZWBType << 24) | HC_HDBLoc_Local | HC_HZONEasFF_MASK |
- format | pitch) );
- OUT_RING( ((HC_SubA_HZWTMD << 24) | vmesa->regHZWTMD) );
+ OUT_RING( (HC_SubA_HZWBBasL << 24) | (offset & 0xFFFFFF) );
+ OUT_RING( (HC_SubA_HZWBBasH << 24) | ((offset & 0xFF000000) >> 24) );
+ OUT_RING( (HC_SubA_HZWBType << 24) | HC_HDBLoc_Local | HC_HZONEasFF_MASK |
+ format | pitch );
+ OUT_RING( (HC_SubA_HZWTMD << 24) | vmesa->regHZWTMD );
ADVANCE_RING();
}
if (ctx->Color.AlphaEnabled) {
BEGIN_RING(1);
- OUT_RING( ((HC_SubA_HATMD << 24) | vmesa->regHATMD) );
+ OUT_RING( (HC_SubA_HATMD << 24) | vmesa->regHATMD );
ADVANCE_RING();
i++;
}
if (ctx->Color.BlendEnabled) {
BEGIN_RING(11);
- OUT_RING( ((HC_SubA_HABLCsat << 24) | vmesa->regHABLCsat) );
- OUT_RING( ((HC_SubA_HABLCop << 24) | vmesa->regHABLCop) );
- OUT_RING( ((HC_SubA_HABLAsat << 24) | vmesa->regHABLAsat) );
- OUT_RING( ((HC_SubA_HABLAop << 24) | vmesa->regHABLAop) );
- OUT_RING( ((HC_SubA_HABLRCa << 24) | vmesa->regHABLRCa) );
- OUT_RING( ((HC_SubA_HABLRFCa << 24) | vmesa->regHABLRFCa) );
- OUT_RING( ((HC_SubA_HABLRCbias << 24) | vmesa->regHABLRCbias) );
- OUT_RING( ((HC_SubA_HABLRCb << 24) | vmesa->regHABLRCb) );
- OUT_RING( ((HC_SubA_HABLRFCb << 24) | vmesa->regHABLRFCb) );
- OUT_RING( ((HC_SubA_HABLRAa << 24) | vmesa->regHABLRAa) );
- OUT_RING( ((HC_SubA_HABLRAb << 24) | vmesa->regHABLRAb) );
+ OUT_RING( (HC_SubA_HABLCsat << 24) | vmesa->regHABLCsat );
+ OUT_RING( (HC_SubA_HABLCop << 24) | vmesa->regHABLCop );
+ OUT_RING( (HC_SubA_HABLAsat << 24) | vmesa->regHABLAsat );
+ OUT_RING( (HC_SubA_HABLAop << 24) | vmesa->regHABLAop );
+ OUT_RING( (HC_SubA_HABLRCa << 24) | vmesa->regHABLRCa );
+ OUT_RING( (HC_SubA_HABLRFCa << 24) | vmesa->regHABLRFCa );
+ OUT_RING( (HC_SubA_HABLRCbias << 24) | vmesa->regHABLRCbias );
+ OUT_RING( (HC_SubA_HABLRCb << 24) | vmesa->regHABLRCb );
+ OUT_RING( (HC_SubA_HABLRFCb << 24) | vmesa->regHABLRFCb );
+ OUT_RING( (HC_SubA_HABLRAa << 24) | vmesa->regHABLRAa );
+ OUT_RING( (HC_SubA_HABLRAb << 24) | vmesa->regHABLRAb );
ADVANCE_RING();
}
if (ctx->Fog.Enabled) {
BEGIN_RING(3);
- OUT_RING( ((HC_SubA_HFogLF << 24) | vmesa->regHFogLF) );
- OUT_RING( ((HC_SubA_HFogCL << 24) | vmesa->regHFogCL) );
- OUT_RING( ((HC_SubA_HFogCH << 24) | vmesa->regHFogCH) );
+ OUT_RING( (HC_SubA_HFogLF << 24) | vmesa->regHFogLF );
+ OUT_RING( (HC_SubA_HFogCL << 24) | vmesa->regHFogCL );
+ OUT_RING( (HC_SubA_HFogCH << 24) | vmesa->regHFogCH );
ADVANCE_RING();
}
if (ctx->Line.StippleFlag) {
BEGIN_RING(2);
- OUT_RING( ((HC_SubA_HLP << 24) | ctx->Line.StipplePattern) );
- OUT_RING( ((HC_SubA_HLPRF << 24) | ctx->Line.StippleFactor) );
- ADVANCE_RING();
- }
- else {
- BEGIN_RING(2);
- OUT_RING( ((HC_SubA_HLP << 24) | 0xFFFF) );
- OUT_RING( ((HC_SubA_HLPRF << 24) | 0x1) );
+ OUT_RING( (HC_SubA_HLP << 24) | ctx->Line.StipplePattern );
+ OUT_RING( (HC_SubA_HLPRF << 24) | ctx->Line.StippleFactor );
ADVANCE_RING();
}
BEGIN_RING(1);
- OUT_RING( ((HC_SubA_HPixGC << 24) | 0x0) );
+ OUT_RING( (HC_SubA_HPixGC << 24) | 0x0 );
ADVANCE_RING();
QWORD_PAD_RING();
struct gl_texture_unit *texUnit1 = &ctx->Texture.Unit[1];
{
- viaTextureObjectPtr t = (viaTextureObjectPtr)texUnit0->_Current->DriverData;
GLuint nDummyValue = 0;
BEGIN_RING( 8 );
OUT_RING( HC_HEADER2 );
OUT_RING( (HC_ParaType_Tex << 16) | (HC_SubType_TexGeneral << 24) );
- if (ctx->Texture._EnabledUnits > 1) {
- if (VIA_DEBUG) fprintf(stderr, "multi texture\n");
- nDummyValue = (HC_SubA_HTXSMD << 24) | (1 << 3);
-
- if (t && t->needClearCache) {
- OUT_RING( nDummyValue | HC_HTXCHCLR_MASK );
- OUT_RING( nDummyValue );
- }
- else {
- OUT_RING( nDummyValue );
- OUT_RING( nDummyValue );
- }
+ if (texUnit0->Enabled && texUnit1->Enabled) {
+ nDummyValue = (HC_SubA_HTXSMD << 24) | (1 << 3);
}
else {
- if (VIA_DEBUG) fprintf(stderr, "single texture\n");
nDummyValue = (HC_SubA_HTXSMD << 24) | 0;
-
- if (t && t->needClearCache) {
- OUT_RING( nDummyValue | HC_HTXCHCLR_MASK );
- OUT_RING( nDummyValue );
- }
- else {
- OUT_RING( nDummyValue );
- OUT_RING( nDummyValue );
- }
}
+
+ if (vmesa->clearTexCache) {
+ vmesa->clearTexCache = 0;
+ OUT_RING( nDummyValue | HC_HTXCHCLR_MASK );
+ OUT_RING( nDummyValue );
+ }
+ else {
+ OUT_RING( nDummyValue );
+ OUT_RING( nDummyValue );
+ }
+
OUT_RING( HC_HEADER2 );
OUT_RING( HC_ParaType_NotTex << 16 );
OUT_RING( (HC_SubA_HEnable << 24) | vmesa->regEnable );
if (texUnit0->Enabled) {
struct gl_texture_object *texObj = texUnit0->_Current;
- viaTextureObjectPtr t = (viaTextureObjectPtr)texObj->DriverData;
+ struct via_texture_object *t = (struct via_texture_object *)texObj;
GLuint numLevels = t->lastLevel - t->firstLevel + 1;
- if (VIA_DEBUG) {
+ if (VIA_DEBUG & DEBUG_STATE) {
fprintf(stderr, "texture0 enabled\n");
- fprintf(stderr, "texture level %d\n", t->actualLevel);
}
if (numLevels == 8) {
BEGIN_RING(27);
ADVANCE_RING();
}
- BEGIN_RING(12);
- OUT_RING( (HC_SubA_HTXnTB << 24) | vmesa->regHTXnTB_0 );
- OUT_RING( (HC_SubA_HTXnMPMD << 24) | vmesa->regHTXnMPMD_0 );
- OUT_RING( (HC_SubA_HTXnTBLCsat << 24) | vmesa->regHTXnTBLCsat_0 );
- OUT_RING( (HC_SubA_HTXnTBLCop << 24) | vmesa->regHTXnTBLCop_0 );
- OUT_RING( (HC_SubA_HTXnTBLMPfog << 24) | vmesa->regHTXnTBLMPfog_0 );
- OUT_RING( (HC_SubA_HTXnTBLAsat << 24) | vmesa->regHTXnTBLAsat_0 );
- OUT_RING( (HC_SubA_HTXnTBLRCb << 24) | vmesa->regHTXnTBLRCb_0 );
- OUT_RING( (HC_SubA_HTXnTBLRAa << 24) | vmesa->regHTXnTBLRAa_0 );
- OUT_RING( (HC_SubA_HTXnTBLRFog << 24) | vmesa->regHTXnTBLRFog_0 );
- OUT_RING( (HC_SubA_HTXnTBLRCa << 24) | vmesa->regHTXnTBLRCa_0 );
- OUT_RING( (HC_SubA_HTXnTBLRCc << 24) | vmesa->regHTXnTBLRCc_0 );
- OUT_RING( (HC_SubA_HTXnTBLRCbias << 24) | vmesa->regHTXnTBLRCbias_0 );
+ BEGIN_RING(14);
+ OUT_RING( (HC_SubA_HTXnTB << 24) | vmesa->regHTXnTB[0] );
+ OUT_RING( (HC_SubA_HTXnMPMD << 24) | vmesa->regHTXnMPMD[0] );
+ OUT_RING( (HC_SubA_HTXnTBLCsat << 24) | vmesa->regHTXnTBLCsat[0] );
+ OUT_RING( (HC_SubA_HTXnTBLCop << 24) | vmesa->regHTXnTBLCop[0] );
+ OUT_RING( (HC_SubA_HTXnTBLMPfog << 24) | vmesa->regHTXnTBLMPfog[0] );
+ OUT_RING( (HC_SubA_HTXnTBLAsat << 24) | vmesa->regHTXnTBLAsat[0] );
+ OUT_RING( (HC_SubA_HTXnTBLRCb << 24) | vmesa->regHTXnTBLRCb[0] );
+ OUT_RING( (HC_SubA_HTXnTBLRAa << 24) | vmesa->regHTXnTBLRAa[0] );
+ OUT_RING( (HC_SubA_HTXnTBLRFog << 24) | vmesa->regHTXnTBLRFog[0] );
+ OUT_RING( (HC_SubA_HTXnTBLRCa << 24) | vmesa->regHTXnTBLRCa[0] );
+ OUT_RING( (HC_SubA_HTXnTBLRCc << 24) | vmesa->regHTXnTBLRCc[0] );
+ OUT_RING( (HC_SubA_HTXnTBLRCbias << 24) | vmesa->regHTXnTBLRCbias[0] );
+ OUT_RING( (HC_SubA_HTXnTBC << 24) | vmesa->regHTXnTBC[0] );
+ OUT_RING( (HC_SubA_HTXnTRAH << 24) | vmesa->regHTXnTRAH[0] );
+/* OUT_RING( (HC_SubA_HTXnCLODu << 24) | vmesa->regHTXnCLOD[0] ); */
ADVANCE_RING();
+ /* KW: This test never succeeds:
+ */
if (t->regTexFM == HC_HTXnFM_Index8) {
- struct gl_color_table *table = &texObj->Palette;
- GLfloat *tableF = (GLfloat *)table->Table;
+ const struct gl_color_table *table = &texObj->Palette;
+ const GLfloat *tableF = table->TableF;
BEGIN_RING(2 + table->Size);
OUT_RING( HC_HEADER2 );
if (texUnit1->Enabled) {
struct gl_texture_object *texObj = texUnit1->_Current;
- viaTextureObjectPtr t = (viaTextureObjectPtr)texObj->DriverData;
+ struct via_texture_object *t = (struct via_texture_object *)texObj;
GLuint numLevels = t->lastLevel - t->firstLevel + 1;
- if (VIA_DEBUG) {
+ int texunit = (texUnit0->Enabled ? 1 : 0);
+ if (VIA_DEBUG & DEBUG_STATE) {
fprintf(stderr, "texture1 enabled\n");
- fprintf(stderr, "texture level %d\n", t->actualLevel);
}
if (numLevels == 8) {
BEGIN_RING(27);
OUT_RING( HC_HEADER2 );
- OUT_RING( (HC_ParaType_Tex << 16) | (1 << 24) );
+ OUT_RING( (HC_ParaType_Tex << 16) | (texunit << 24) );
OUT_RING( t->regTexFM );
OUT_RING( (HC_SubA_HTXnL0OS << 24) |
((t->lastLevel) << HC_HTXnLVmax_SHIFT) | t->firstLevel );
else if (numLevels > 1) {
BEGIN_RING(12 + numLevels * 2);
OUT_RING( HC_HEADER2 );
- OUT_RING( (HC_ParaType_Tex << 16) | (1 << 24) );
+ OUT_RING( (HC_ParaType_Tex << 16) | (texunit << 24) );
OUT_RING( t->regTexFM );
OUT_RING( (HC_SubA_HTXnL0OS << 24) |
((t->lastLevel) << HC_HTXnLVmax_SHIFT) | t->firstLevel );
else {
BEGIN_RING(9);
OUT_RING( HC_HEADER2 );
- OUT_RING( (HC_ParaType_Tex << 16) | (1 << 24) );
+ OUT_RING( (HC_ParaType_Tex << 16) | (texunit << 24) );
OUT_RING( t->regTexFM );
OUT_RING( (HC_SubA_HTXnL0OS << 24) |
((t->lastLevel) << HC_HTXnLVmax_SHIFT) | t->firstLevel );
ADVANCE_RING();
}
- BEGIN_RING(9);
- OUT_RING( (HC_SubA_HTXnTB << 24) | vmesa->regHTXnTB_1 );
- OUT_RING( (HC_SubA_HTXnMPMD << 24) | vmesa->regHTXnMPMD_1 );
- OUT_RING( (HC_SubA_HTXnTBLCsat << 24) | vmesa->regHTXnTBLCsat_1 );
- OUT_RING( (HC_SubA_HTXnTBLCop << 24) | vmesa->regHTXnTBLCop_1 );
- OUT_RING( (HC_SubA_HTXnTBLMPfog << 24) | vmesa->regHTXnTBLMPfog_1 );
- OUT_RING( (HC_SubA_HTXnTBLAsat << 24) | vmesa->regHTXnTBLAsat_1 );
- OUT_RING( (HC_SubA_HTXnTBLRCb << 24) | vmesa->regHTXnTBLRCb_1 );
- OUT_RING( (HC_SubA_HTXnTBLRAa << 24) | vmesa->regHTXnTBLRAa_1 );
- OUT_RING( (HC_SubA_HTXnTBLRFog << 24) | vmesa->regHTXnTBLRFog_1 );
+ BEGIN_RING(14);
+ OUT_RING( (HC_SubA_HTXnTB << 24) | vmesa->regHTXnTB[1] );
+ OUT_RING( (HC_SubA_HTXnMPMD << 24) | vmesa->regHTXnMPMD[1] );
+ OUT_RING( (HC_SubA_HTXnTBLCsat << 24) | vmesa->regHTXnTBLCsat[1] );
+ OUT_RING( (HC_SubA_HTXnTBLCop << 24) | vmesa->regHTXnTBLCop[1] );
+ OUT_RING( (HC_SubA_HTXnTBLMPfog << 24) | vmesa->regHTXnTBLMPfog[1] );
+ OUT_RING( (HC_SubA_HTXnTBLAsat << 24) | vmesa->regHTXnTBLAsat[1] );
+ OUT_RING( (HC_SubA_HTXnTBLRCb << 24) | vmesa->regHTXnTBLRCb[1] );
+ OUT_RING( (HC_SubA_HTXnTBLRAa << 24) | vmesa->regHTXnTBLRAa[1] );
+ OUT_RING( (HC_SubA_HTXnTBLRFog << 24) | vmesa->regHTXnTBLRFog[1] );
+ OUT_RING( (HC_SubA_HTXnTBLRCa << 24) | vmesa->regHTXnTBLRCa[1] );
+ OUT_RING( (HC_SubA_HTXnTBLRCc << 24) | vmesa->regHTXnTBLRCc[1] );
+ OUT_RING( (HC_SubA_HTXnTBLRCbias << 24) | vmesa->regHTXnTBLRCbias[1] );
+ OUT_RING( (HC_SubA_HTXnTBC << 24) | vmesa->regHTXnTBC[1] );
+ OUT_RING( (HC_SubA_HTXnTRAH << 24) | vmesa->regHTXnTRAH[1] );
+/* OUT_RING( (HC_SubA_HTXnCLODu << 24) | vmesa->regHTXnCLOD[1] ); */
ADVANCE_RING();
+ /* KW: This test never succeeds:
+ */
if (t->regTexFM == HC_HTXnFM_Index8) {
- struct gl_color_table *table = &texObj->Palette;
- GLfloat *tableF = (GLfloat *)table->Table;
+ const struct gl_color_table *table = &texObj->Palette;
+ const GLfloat *tableF = table->TableF;
BEGIN_RING(2 + table->Size);
OUT_RING( HC_HEADER2 );
- OUT_RING( (HC_ParaType_Palette << 16) | (1 << 24) );
+ OUT_RING( (HC_ParaType_Palette << 16) | (texunit << 24) );
for (j = 0; j < table->Size; j++) {
OUT_RING( tableF[j] );
}
}
}
-
+#if 0
+ /* Polygon stipple is broken - for certain stipple values,
+ * eg. 0xf0f0f0f0, the hardware will refuse to accept the stipple.
+ * Coincidentally, conform generates just such a stipple.
+ */
if (ctx->Polygon.StippleFlag) {
GLuint *stipple = &ctx->PolygonStipple[0];
+ __DRIdrawablePrivate *dPriv = vmesa->driDrawable;
+ struct via_renderbuffer *const vrb =
+ (struct via_renderbuffer *) dPriv->driverPrivate;
+ GLint i;
BEGIN_RING(38);
OUT_RING( HC_HEADER2 );
+
OUT_RING( ((HC_ParaType_Palette << 16) | (HC_SubType_Stipple << 24)) );
- OUT_RING( stipple[31] );
- OUT_RING( stipple[30] );
- OUT_RING( stipple[29] );
- OUT_RING( stipple[28] );
- OUT_RING( stipple[27] );
- OUT_RING( stipple[26] );
- OUT_RING( stipple[25] );
- OUT_RING( stipple[24] );
- OUT_RING( stipple[23] );
- OUT_RING( stipple[22] );
- OUT_RING( stipple[21] );
- OUT_RING( stipple[20] );
- OUT_RING( stipple[19] );
- OUT_RING( stipple[18] );
- OUT_RING( stipple[17] );
- OUT_RING( stipple[16] );
- OUT_RING( stipple[15] );
- OUT_RING( stipple[14] );
- OUT_RING( stipple[13] );
- OUT_RING( stipple[12] );
- OUT_RING( stipple[11] );
- OUT_RING( stipple[10] );
- OUT_RING( stipple[9] );
- OUT_RING( stipple[8] );
- OUT_RING( stipple[7] );
- OUT_RING( stipple[6] );
- OUT_RING( stipple[5] );
- OUT_RING( stipple[4] );
- OUT_RING( stipple[3] );
- OUT_RING( stipple[2] );
- OUT_RING( stipple[1] );
- OUT_RING( stipple[0] );
+ for (i = 31; i >= 0; i--) {
+ GLint j;
+ GLuint k = 0;
+
+ /* Need to flip bits left to right:
+ */
+ for (j = 0 ; j < 32; j++)
+ if (stipple[i] & (1<<j))
+ k |= 1 << (31-j);
+
+ OUT_RING( k );
+ }
+
OUT_RING( HC_HEADER2 );
OUT_RING( (HC_ParaType_NotTex << 16) );
- OUT_RING( ((HC_SubA_HSPXYOS << 24) | (0x20 - (vmesa->driDrawable->h & 0x1F))) );
- OUT_RING( ((HC_SubA_HSPXYOS << 24) | (0x20 - (vmesa->driDrawable->h & 0x1F))) );
+ OUT_RING( (HC_SubA_HSPXYOS << 24) );
+ OUT_RING( (HC_SubA_HSPXYOS << 24) );
+
ADVANCE_RING();
}
+#endif
- if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__);
+ vmesa->newEmitState = 0;
}
-static __inline__ GLuint viaPackColor(GLuint format,
- GLubyte r, GLubyte g,
- GLubyte b, GLubyte a)
+static INLINE GLuint viaPackColor(GLuint bpp,
+ GLubyte r, GLubyte g,
+ GLubyte b, GLubyte a)
{
- switch (format) {
- case 0x10:
+ switch (bpp) {
+ case 16:
return PACK_COLOR_565(r, g, b);
- case 0x20:
+ case 32:
return PACK_COLOR_8888(a, r, g, b);
default:
- if (VIA_DEBUG) fprintf(stderr, "unknown format %d\n", (int)format);
- return PACK_COLOR_8888(a, r, g, b);
+ assert(0);
+ return 0;
}
}
-static void viaBlendEquationSeparate(GLcontext *ctx, GLenum rgbMode, GLenum aMode)
+static void viaBlendEquationSeparate(GLcontext *ctx,
+ GLenum rgbMode,
+ GLenum aMode)
{
- if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__);
+ if (VIA_DEBUG & DEBUG_STATE)
+ fprintf(stderr, "%s in\n", __FUNCTION__);
/* GL_EXT_blend_equation_separate not supported */
ASSERT(rgbMode == aMode);
/* Can only do GL_ADD equation in hardware */
- FALLBACK(VIA_CONTEXT(ctx), VIA_FALLBACK_BLEND_EQ, rgbMode != GL_FUNC_ADD_EXT);
+ FALLBACK(VIA_CONTEXT(ctx), VIA_FALLBACK_BLEND_EQ,
+ rgbMode != GL_FUNC_ADD_EXT);
/* BlendEquation sets ColorLogicOpEnabled in an unexpected
* manner.
FALLBACK(VIA_CONTEXT(ctx), VIA_FALLBACK_LOGICOP,
(ctx->Color.ColorLogicOpEnabled &&
ctx->Color.LogicOp != GL_COPY));
- if (VIA_DEBUG) fprintf(stderr, "%s out\n", __FUNCTION__);
}
static void viaBlendFunc(GLcontext *ctx, GLenum sfactor, GLenum dfactor)
{
- viaContextPtr vmesa = VIA_CONTEXT(ctx);
+ struct via_context *vmesa = VIA_CONTEXT(ctx);
GLboolean fallback = GL_FALSE;
- if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__);
+ if (VIA_DEBUG & DEBUG_STATE)
+ fprintf(stderr, "%s in\n", __FUNCTION__);
switch (ctx->Color.BlendSrcRGB) {
case GL_SRC_ALPHA_SATURATE:
}
FALLBACK(vmesa, VIA_FALLBACK_BLEND_FUNC, fallback);
- if (VIA_DEBUG) fprintf(stderr, "%s out\n", __FUNCTION__);
}
/* Shouldn't be called as the extension is disabled.
static void viaScissor(GLcontext *ctx, GLint x, GLint y,
GLsizei w, GLsizei h)
{
- viaContextPtr vmesa = VIA_CONTEXT(ctx);
+ struct via_context *vmesa = VIA_CONTEXT(ctx);
if (!vmesa->driDrawable)
return;
- if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__);
+ if (VIA_DEBUG & DEBUG_STATE)
+ fprintf(stderr, "%s %d,%d %dx%d, drawH %d\n", __FUNCTION__,
+ x,y,w,h, vmesa->driDrawable->h);
- if (ctx->Scissor.Enabled) {
+ if (vmesa->scissor) {
VIA_FLUSH_DMA(vmesa); /* don't pipeline cliprect changes */
}
vmesa->scissorRect.x1 = x;
- vmesa->scissorRect.y1 = vmesa->driDrawable->h - (y + h);
+ vmesa->scissorRect.y1 = vmesa->driDrawable->h - y - h;
vmesa->scissorRect.x2 = x + w;
vmesa->scissorRect.y2 = vmesa->driDrawable->h - y;
- if (VIA_DEBUG) fprintf(stderr, "%s out\n", __FUNCTION__);
+}
+
+static void viaEnable(GLcontext *ctx, GLenum cap, GLboolean state)
+{
+ struct via_context *vmesa = VIA_CONTEXT(ctx);
+
+ switch (cap) {
+ case GL_SCISSOR_TEST:
+ VIA_FLUSH_DMA(vmesa);
+ vmesa->scissor = state;
+ break;
+ default:
+ break;
+ }
}
static void viaDrawBuffer(GLcontext *ctx, GLenum mode)
{
- viaContextPtr vmesa = VIA_CONTEXT(ctx);
- if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__);
- if (mode == GL_FRONT) {
- VIA_FLUSH_DMA(vmesa);
- vmesa->drawMap = (char *)vmesa->driScreen->pFB;
- vmesa->readMap = (char *)vmesa->driScreen->pFB;
- vmesa->drawPitch = vmesa->front.pitch;
- vmesa->readPitch = vmesa->front.pitch;
- viaXMesaSetFrontClipRects(vmesa);
- FALLBACK(vmesa, VIA_FALLBACK_DRAW_BUFFER, GL_FALSE);
- return;
- }
- else if (mode == GL_BACK) {
- VIA_FLUSH_DMA(vmesa);
- vmesa->drawMap = vmesa->back.map;
- vmesa->readMap = vmesa->back.map;
- vmesa->drawPitch = vmesa->back.pitch;
- vmesa->readPitch = vmesa->back.pitch;
- viaXMesaSetBackClipRects(vmesa);
- FALLBACK(vmesa, VIA_FALLBACK_DRAW_BUFFER, GL_FALSE);
- return;
- }
- else {
- FALLBACK(vmesa, VIA_FALLBACK_DRAW_BUFFER, GL_TRUE);
- return;
- }
+ struct via_context *vmesa = VIA_CONTEXT(ctx);
- /* We want to update the s/w rast state too so that r200SetBuffer()
- * gets called.
- */
- _swrast_DrawBuffer(ctx, mode);
+ if (VIA_DEBUG & (DEBUG_DRI|DEBUG_STATE))
+ fprintf(stderr, "%s in\n", __FUNCTION__);
+
+ if (!ctx->DrawBuffer)
+ return;
+
+ if (ctx->DrawBuffer->_NumColorDrawBuffers != 1) {
+ FALLBACK(vmesa, VIA_FALLBACK_DRAW_BUFFER, GL_TRUE);
+ return;
+ }
+
+ switch ( ctx->DrawBuffer->_ColorDrawBufferIndexes[0] ) {
+ case BUFFER_FRONT_LEFT:
+ VIA_FLUSH_DMA(vmesa);
+ vmesa->drawBuffer = &vmesa->front;
+ FALLBACK(vmesa, VIA_FALLBACK_DRAW_BUFFER, GL_FALSE);
+ break;
+ case BUFFER_BACK_LEFT:
+ VIA_FLUSH_DMA(vmesa);
+ vmesa->drawBuffer = &vmesa->back;
+ FALLBACK(vmesa, VIA_FALLBACK_DRAW_BUFFER, GL_FALSE);
+ break;
+ default:
+ FALLBACK(vmesa, VIA_FALLBACK_DRAW_BUFFER, GL_TRUE);
+ return;
+ }
- if (VIA_DEBUG) fprintf(stderr, "%s out\n", __FUNCTION__);
+ viaXMesaWindowMoved(vmesa);
}
static void viaClearColor(GLcontext *ctx, const GLfloat color[4])
{
- viaContextPtr vmesa = VIA_CONTEXT(ctx);
+ struct via_context *vmesa = VIA_CONTEXT(ctx);
GLubyte pcolor[4];
CLAMPED_FLOAT_TO_UBYTE(pcolor[0], color[0]);
CLAMPED_FLOAT_TO_UBYTE(pcolor[1], color[1]);
vmesa->ClearColor = viaPackColor(vmesa->viaScreen->bitsPerPixel,
pcolor[0], pcolor[1],
pcolor[2], pcolor[3]);
-
}
+#define WRITEMASK_ALPHA_SHIFT 31
+#define WRITEMASK_RED_SHIFT 30
+#define WRITEMASK_GREEN_SHIFT 29
+#define WRITEMASK_BLUE_SHIFT 28
-/* =============================================================
- */
+static void viaColorMask(GLcontext *ctx,
+ GLboolean r, GLboolean g,
+ GLboolean b, GLboolean a)
+{
+ struct via_context *vmesa = VIA_CONTEXT( ctx );
+ if (VIA_DEBUG & DEBUG_STATE)
+ fprintf(stderr, "%s r(%d) g(%d) b(%d) a(%d)\n", __FUNCTION__, r, g, b, a);
+ vmesa->ClearMask = (((!r) << WRITEMASK_RED_SHIFT) |
+ ((!g) << WRITEMASK_GREEN_SHIFT) |
+ ((!b) << WRITEMASK_BLUE_SHIFT) |
+ ((!a) << WRITEMASK_ALPHA_SHIFT));
+}
+
+
+
+/* This hardware just isn't capable of private back buffers without
+ * glitches and/or a hefty locking scheme.
+ */
void viaCalcViewport(GLcontext *ctx)
{
- viaContextPtr vmesa = VIA_CONTEXT(ctx);
+ struct via_context *vmesa = VIA_CONTEXT(ctx);
+ __DRIdrawablePrivate *dPriv = vmesa->driDrawable;
+ struct via_renderbuffer *const vrb =
+ (struct via_renderbuffer *) dPriv->driverPrivate;
const GLfloat *v = ctx->Viewport._WindowMap.m;
GLfloat *m = vmesa->ViewportMatrix.m;
- /* See also via_translate_vertex.
- */
m[MAT_SX] = v[MAT_SX];
- m[MAT_TX] = v[MAT_TX] + SUBPIXEL_X + vmesa->drawXoff;
+ m[MAT_TX] = v[MAT_TX] + vrb->drawX + SUBPIXEL_X;
m[MAT_SY] = - v[MAT_SY];
- m[MAT_TY] = - v[MAT_TY] + vmesa->driDrawable->h + SUBPIXEL_Y;
+ m[MAT_TY] = - v[MAT_TY] + vrb->drawY + SUBPIXEL_Y + vrb->drawH;
m[MAT_SZ] = v[MAT_SZ] * (1.0 / vmesa->depth_max);
m[MAT_TZ] = v[MAT_TZ] * (1.0 / vmesa->depth_max);
}
GLint x, GLint y,
GLsizei width, GLsizei height)
{
- /* update size of Mesa/software ancillary buffers */
- _mesa_ResizeBuffersMESA();
viaCalcViewport(ctx);
}
viaCalcViewport(ctx);
}
-
void viaInitState(GLcontext *ctx)
{
- viaContextPtr vmesa = VIA_CONTEXT(ctx);
+ struct via_context *vmesa = VIA_CONTEXT(ctx);
- vmesa->regCmdA = HC_ACMD_HCmdA;
- vmesa->regCmdB = HC_ACMD_HCmdB | HC_HVPMSK_X | HC_HVPMSK_Y | HC_HVPMSK_Z;
+ vmesa->regCmdB = HC_ACMD_HCmdB;
vmesa->regEnable = HC_HenCW_MASK;
/* Mesa should do this for us:
/**
* Convert S and T texture coordinate wrap modes to hardware bits.
*/
-static u_int32_t
+static uint32_t
get_wrap_mode( GLenum sWrap, GLenum tWrap )
{
- u_int32_t v = 0;
+ uint32_t v = 0;
switch( sWrap ) {
return v;
}
-
-static void viaChooseTextureState(GLcontext *ctx)
+static uint32_t
+get_minmag_filter( GLenum min, GLenum mag )
{
- viaContextPtr vmesa = VIA_CONTEXT(ctx);
- struct gl_texture_unit *texUnit0 = &ctx->Texture.Unit[0];
- struct gl_texture_unit *texUnit1 = &ctx->Texture.Unit[1];
- /*=* John Sheng [2003.7.18] texture combine *=*/
+ uint32_t v = 0;
- if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__);
- if (texUnit0->_ReallyEnabled || texUnit1->_ReallyEnabled) {
- if (VIA_DEBUG) {
- fprintf(stderr, "Texture._ReallyEnabled - in\n");
- fprintf(stderr, "texUnit0->_ReallyEnabled = %x\n",texUnit0->_ReallyEnabled);
- }
+ switch (min) {
+ case GL_NEAREST:
+ v = HC_HTXnFLSs_Nearest |
+ HC_HTXnFLTs_Nearest;
+ break;
+ case GL_LINEAR:
+ v = HC_HTXnFLSs_Linear |
+ HC_HTXnFLTs_Linear;
+ break;
+ case GL_NEAREST_MIPMAP_NEAREST:
+ v = HC_HTXnFLSs_Nearest |
+ HC_HTXnFLTs_Nearest;
+ v |= HC_HTXnFLDs_Nearest;
+ break;
+ case GL_LINEAR_MIPMAP_NEAREST:
+ v = HC_HTXnFLSs_Linear |
+ HC_HTXnFLTs_Linear;
+ v |= HC_HTXnFLDs_Nearest;
+ break;
+ case GL_NEAREST_MIPMAP_LINEAR:
+ v = HC_HTXnFLSs_Nearest |
+ HC_HTXnFLTs_Nearest;
+ v |= HC_HTXnFLDs_Linear;
+ break;
+ case GL_LINEAR_MIPMAP_LINEAR:
+ v = HC_HTXnFLSs_Linear |
+ HC_HTXnFLTs_Linear;
+ v |= HC_HTXnFLDs_Linear;
+ break;
+ default:
+ break;
+ }
+
+ switch (mag) {
+ case GL_LINEAR:
+ v |= HC_HTXnFLSe_Linear |
+ HC_HTXnFLTe_Linear;
+ break;
+ case GL_NEAREST:
+ v |= HC_HTXnFLSe_Nearest |
+ HC_HTXnFLTe_Nearest;
+ break;
+ default:
+ break;
+ }
- if (VIA_DEBUG) {
- struct gl_texture_object *texObj0 = texUnit0->_Current;
- struct gl_texture_object *texObj1 = texUnit1->_Current;
+ return v;
+}
- fprintf(stderr, "env mode: 0x%04x / 0x%04x\n", texUnit0->EnvMode, texUnit1->EnvMode);
- if ( (texObj0 != NULL) && (texObj0->Image[0][0] != NULL) )
- fprintf(stderr, "format 0: 0x%04x\n", texObj0->Image[0][0]->Format);
-
- if ( (texObj1 != NULL) && (texObj1->Image[0][0] != NULL) )
- fprintf(stderr, "format 1: 0x%04x\n", texObj1->Image[0][0]->Format);
- }
+static GLboolean viaChooseTextureState(GLcontext *ctx)
+{
+ struct via_context *vmesa = VIA_CONTEXT(ctx);
+ struct gl_texture_unit *texUnit0 = &ctx->Texture.Unit[0];
+ struct gl_texture_unit *texUnit1 = &ctx->Texture.Unit[1];
+ if (texUnit0->_ReallyEnabled || texUnit1->_ReallyEnabled) {
+ vmesa->regEnable |= HC_HenTXMP_MASK | HC_HenTXCH_MASK | HC_HenTXPP_MASK;
if (texUnit0->_ReallyEnabled) {
struct gl_texture_object *texObj = texUnit0->_Current;
- struct gl_texture_image *texImage = texObj->Image[0][0];
-
- if (VIA_DEBUG) fprintf(stderr, "texUnit0->_ReallyEnabled\n");
- if (texImage->Border) {
- FALLBACK(vmesa, VIA_FALLBACK_TEXTURE, GL_TRUE);
- return;
- }
- vmesa->regCmdB |= HC_HVPMSK_S | HC_HVPMSK_T | HC_HVPMSK_W | HC_HVPMSK_Cs;
- vmesa->regEnable |= HC_HenTXMP_MASK | HC_HenTXCH_MASK | HC_HenTXPP_MASK;
- switch (texObj->MinFilter) {
- case GL_NEAREST:
- vmesa->regHTXnTB_0 = HC_HTXnFLSs_Nearest |
- HC_HTXnFLTs_Nearest;
- break;
- case GL_LINEAR:
- vmesa->regHTXnTB_0 = HC_HTXnFLSs_Linear |
- HC_HTXnFLTs_Linear;
- break;
- case GL_NEAREST_MIPMAP_NEAREST:
- vmesa->regHTXnTB_0 = HC_HTXnFLSs_Nearest |
- HC_HTXnFLTs_Nearest;
- vmesa->regHTXnTB_0 |= HC_HTXnFLDs_Nearest;
- break;
- case GL_LINEAR_MIPMAP_NEAREST:
- vmesa->regHTXnTB_0 = HC_HTXnFLSs_Linear |
- HC_HTXnFLTs_Linear;
- vmesa->regHTXnTB_0 |= HC_HTXnFLDs_Nearest;
- break;
- case GL_NEAREST_MIPMAP_LINEAR:
- vmesa->regHTXnTB_0 = HC_HTXnFLSs_Nearest |
- HC_HTXnFLTs_Nearest;
- vmesa->regHTXnTB_0 |= HC_HTXnFLDs_Linear;
- break;
- case GL_LINEAR_MIPMAP_LINEAR:
- vmesa->regHTXnTB_0 = HC_HTXnFLSs_Linear |
- HC_HTXnFLTs_Linear;
- vmesa->regHTXnTB_0 |= HC_HTXnFLDs_Linear;
- break;
- default:
- break;
- }
+ vmesa->regHTXnTB[0] = get_minmag_filter( texObj->MinFilter,
+ texObj->MagFilter );
- if (texObj->MagFilter) {
- vmesa->regHTXnTB_0 |= HC_HTXnFLSe_Linear |
- HC_HTXnFLTe_Linear;
- }
- else {
- vmesa->regHTXnTB_0 |= HC_HTXnFLSe_Nearest |
- HC_HTXnFLTe_Nearest;
- }
-
- vmesa->regHTXnMPMD_0 &= ~(HC_HTXnMPMD_SMASK | HC_HTXnMPMD_TMASK);
- vmesa->regHTXnMPMD_0 |= get_wrap_mode( texObj->WrapS,
+ vmesa->regHTXnMPMD[0] &= ~(HC_HTXnMPMD_SMASK | HC_HTXnMPMD_TMASK);
+ vmesa->regHTXnMPMD[0] |= get_wrap_mode( texObj->WrapS,
texObj->WrapT );
- if (VIA_DEBUG) fprintf(stderr, "texUnit0->EnvMode %x\n",texUnit0->EnvMode);
+ vmesa->regHTXnTB[0] &= ~(HC_HTXnTB_TBC_S | HC_HTXnTB_TBC_T);
+ if (texObj->Image[0][texObj->BaseLevel]->Border > 0) {
+ vmesa->regHTXnTB[0] |= (HC_HTXnTB_TBC_S | HC_HTXnTB_TBC_T);
+ vmesa->regHTXnTBC[0] =
+ PACK_COLOR_888(FLOAT_TO_UBYTE(texObj->BorderColor[0]),
+ FLOAT_TO_UBYTE(texObj->BorderColor[1]),
+ FLOAT_TO_UBYTE(texObj->BorderColor[2]));
+ vmesa->regHTXnTRAH[0] = FLOAT_TO_UBYTE(texObj->BorderColor[3]);
+ }
+
+ if (texUnit0->LodBias != 0.0f) {
+ GLuint b = viaComputeLodBias(texUnit0->LodBias);
+ vmesa->regHTXnTB[0] &= ~HC_HTXnFLDs_MASK;
+ vmesa->regHTXnTB[0] |= HC_HTXnFLDs_ConstLOD;
+ vmesa->regHTXnCLOD[0] = (b&0x1f) | (((~b)&0x1f)<<10); /* FIXME */
+ }
- viaTexCombineState( vmesa, texUnit0->_CurrentCombine, 0 );
+ if (!viaTexCombineState( vmesa, texUnit0->_CurrentCombine, 0 )) {
+ if (VIA_DEBUG & DEBUG_TEXTURE)
+ fprintf(stderr, "viaTexCombineState failed for unit 0\n");
+ return GL_FALSE;
+ }
}
- else {
- /* Should turn Cs off if actually no Cs */
- }
if (texUnit1->_ReallyEnabled) {
struct gl_texture_object *texObj = texUnit1->_Current;
- struct gl_texture_image *texImage = texObj->Image[0][0];
- if (texImage->Border) {
- FALLBACK(vmesa, VIA_FALLBACK_TEXTURE, GL_TRUE);
- return;
- }
+ vmesa->regHTXnTB[1] = get_minmag_filter( texObj->MinFilter,
+ texObj->MagFilter );
+ vmesa->regHTXnMPMD[1] &= ~(HC_HTXnMPMD_SMASK | HC_HTXnMPMD_TMASK);
+ vmesa->regHTXnMPMD[1] |= get_wrap_mode( texObj->WrapS,
+ texObj->WrapT );
- switch (texObj->MinFilter) {
- case GL_NEAREST:
- vmesa->regHTXnTB_1 = HC_HTXnFLSs_Nearest |
- HC_HTXnFLTs_Nearest;
- break;
- case GL_LINEAR:
- vmesa->regHTXnTB_1 = HC_HTXnFLSs_Linear |
- HC_HTXnFLTs_Linear;
- break;
- case GL_NEAREST_MIPMAP_NEAREST:
- vmesa->regHTXnTB_1 = HC_HTXnFLSs_Nearest |
- HC_HTXnFLTs_Nearest;
- vmesa->regHTXnTB_1 |= HC_HTXnFLDs_Nearest;
- break ;
- case GL_LINEAR_MIPMAP_NEAREST:
- vmesa->regHTXnTB_1 = HC_HTXnFLSs_Linear |
- HC_HTXnFLTs_Linear;
- vmesa->regHTXnTB_1 |= HC_HTXnFLDs_Nearest;
- break ;
- case GL_NEAREST_MIPMAP_LINEAR:
- vmesa->regHTXnTB_1 = HC_HTXnFLSs_Nearest |
- HC_HTXnFLTs_Nearest;
- vmesa->regHTXnTB_1 |= HC_HTXnFLDs_Linear;
- break ;
- case GL_LINEAR_MIPMAP_LINEAR:
- vmesa->regHTXnTB_1 = HC_HTXnFLSs_Linear |
- HC_HTXnFLTs_Linear;
- vmesa->regHTXnTB_1 |= HC_HTXnFLDs_Linear;
- break ;
- default:
- break;
+ vmesa->regHTXnTB[1] &= ~(HC_HTXnTB_TBC_S | HC_HTXnTB_TBC_T);
+ if (texObj->Image[0][texObj->BaseLevel]->Border > 0) {
+ vmesa->regHTXnTB[1] |= (HC_HTXnTB_TBC_S | HC_HTXnTB_TBC_T);
+ vmesa->regHTXnTBC[1] =
+ PACK_COLOR_888(FLOAT_TO_UBYTE(texObj->BorderColor[0]),
+ FLOAT_TO_UBYTE(texObj->BorderColor[1]),
+ FLOAT_TO_UBYTE(texObj->BorderColor[2]));
+ vmesa->regHTXnTRAH[1] = FLOAT_TO_UBYTE(texObj->BorderColor[3]);
}
- switch(texObj->MagFilter) {
- case GL_NEAREST:
- vmesa->regHTXnTB_1 |= HC_HTXnFLSs_Nearest |
- HC_HTXnFLTs_Nearest;
- break;
- case GL_LINEAR:
- vmesa->regHTXnTB_1 |= HC_HTXnFLSs_Linear |
- HC_HTXnFLTs_Linear;
- break;
+
+ if (texUnit1->LodBias != 0.0f) {
+ GLuint b = viaComputeLodBias(texUnit1->LodBias);
+ vmesa->regHTXnTB[1] &= ~HC_HTXnFLDs_MASK;
+ vmesa->regHTXnTB[1] |= HC_HTXnFLDs_ConstLOD;
+ vmesa->regHTXnCLOD[1] = (b&0x1f) | (((~b)&0x1f)<<10); /* FIXME */
}
-
- vmesa->regHTXnMPMD_1 &= ~(HC_HTXnMPMD_SMASK | HC_HTXnMPMD_TMASK);
- vmesa->regHTXnMPMD_1 |= get_wrap_mode( texObj->WrapS,
- texObj->WrapT );
- viaTexCombineState( vmesa, texUnit1->_CurrentCombine, 1 );
+ if (!viaTexCombineState( vmesa, texUnit1->_CurrentCombine, 1 )) {
+ if (VIA_DEBUG & DEBUG_TEXTURE)
+ fprintf(stderr, "viaTexCombineState failed for unit 1\n");
+ return GL_FALSE;
+ }
}
-
- if (VIA_DEBUG) {
- fprintf( stderr, "Csat_0 / Cop_0 = 0x%08x / 0x%08x\n",
- vmesa->regHTXnTBLCsat_0, vmesa->regHTXnTBLCop_0 );
- fprintf( stderr, "Asat_0 = 0x%08x\n",
- vmesa->regHTXnTBLAsat_0 );
- fprintf( stderr, "RCb_0 / RAa_0 = 0x%08x / 0x%08x\n",
- vmesa->regHTXnTBLRCb_0, vmesa->regHTXnTBLRAa_0 );
- fprintf( stderr, "RCa_0 / RCc_0 = 0x%08x / 0x%08x\n",
- vmesa->regHTXnTBLRCa_0, vmesa->regHTXnTBLRCc_0 );
- fprintf( stderr, "RCbias_0 = 0x%08x\n",
- vmesa->regHTXnTBLRCbias_0 );
- }
}
else {
- if (ctx->Fog.Enabled)
- vmesa->regCmdB &= (~(HC_HVPMSK_S | HC_HVPMSK_T));
- else
- vmesa->regCmdB &= (~(HC_HVPMSK_S | HC_HVPMSK_T | HC_HVPMSK_W));
- vmesa->regEnable &= (~(HC_HenTXMP_MASK | HC_HenTXCH_MASK | HC_HenTXPP_MASK));
+ vmesa->regEnable &= ~(HC_HenTXMP_MASK | HC_HenTXCH_MASK |
+ HC_HenTXPP_MASK);
}
- if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__);
+ return GL_TRUE;
}
static void viaChooseColorState(GLcontext *ctx)
{
- viaContextPtr vmesa = VIA_CONTEXT(ctx);
+ struct via_context *vmesa = VIA_CONTEXT(ctx);
GLenum s = ctx->Color.BlendSrcRGB;
GLenum d = ctx->Color.BlendDstRGB;
/* The HW's blending equation is:
* (Ca * FCa + Cbias + Cb * FCb) << Cshift
*/
- if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__);
if (ctx->Color.BlendEnabled) {
vmesa->regEnable |= HC_HenABL_MASK;
/* Ca -- always from source color.
*/
- vmesa->regHABLCsat = HC_HABLCsat_MASK | HC_HABLCa_OPC |
- HC_HABLCa_Csrc;
+ vmesa->regHABLCsat = HC_HABLCsat_MASK | HC_HABLCa_OPC | HC_HABLCa_Csrc;
/* Aa -- always from source alpha.
*/
- vmesa->regHABLAsat = HC_HABLAsat_MASK | HC_HABLAa_OPA |
- HC_HABLAa_Asrc;
+ vmesa->regHABLAsat = HC_HABLAsat_MASK | HC_HABLAa_OPA | HC_HABLAa_Asrc;
/* FCa -- depend on following condition.
* FAa -- depend on following condition.
*/
if (vmesa->viaScreen->bitsPerPixel == 16) {
/* (1, 1, 1, 1)
*/
- vmesa->regHABLCsat |= HC_HABLFCa_InvOPC | HC_HABLFCa_HABLRCa;
- vmesa->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_HABLFRA;
+ vmesa->regHABLCsat |= (HC_HABLFCa_InvOPC |
+ HC_HABLFCa_HABLRCa);
+ vmesa->regHABLAsat |= (HC_HABLFAa_InvOPA |
+ HC_HABLFAa_HABLFRA);
vmesa->regHABLRFCa = 0x0;
vmesa->regHABLRAa = 0x0;
}
* So (f, f, f, 1) = (0, 0, 0, 1)
*/
vmesa->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_HABLRCa;
- vmesa->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_HABLFRA;
+ vmesa->regHABLAsat |= (HC_HABLFAa_InvOPA |
+ HC_HABLFAa_HABLFRA);
vmesa->regHABLRFCa = 0x0;
vmesa->regHABLRAa = 0x0;
}
else {
/* (f, f, f, 1), f = min(As, 1 - Ad)
*/
- vmesa->regHABLCsat |= HC_HABLFCa_OPC | HC_HABLFCa_mimAsrcInvAdst;
- vmesa->regHABLAsat |= HC_HABLFAa_InvOPA | HC_HABLFAa_HABLFRA;
+ vmesa->regHABLCsat |= (HC_HABLFCa_OPC |
+ HC_HABLFCa_mimAsrcInvAdst);
+ vmesa->regHABLAsat |= (HC_HABLFAa_InvOPA |
+ HC_HABLFAa_HABLFRA);
vmesa->regHABLRFCa = 0x0;
vmesa->regHABLRAa = 0x0;
}
if (ctx->Color.AlphaEnabled) {
vmesa->regEnable |= HC_HenAT_MASK;
- vmesa->regHATMD = (((GLchan)ctx->Color.AlphaRef) & 0xFF) |
+ vmesa->regHATMD = FLOAT_TO_UBYTE(ctx->Color.AlphaRef) |
((ctx->Color.AlphaFunc - GL_NEVER) << 8);
}
else {
}
}
+
+ vmesa->regEnable &= ~HC_HenDT_MASK;
+
if (ctx->Color.ColorLogicOpEnabled)
vmesa->regHROP = ROP[ctx->Color.LogicOp & 0xF];
else
vmesa->regHROP = HC_HROP_P;
- vmesa->regHFBBMSKL = (*(GLuint *)&ctx->Color.ColorMask[0]) & 0xFFFFFF;
- vmesa->regHROP |= ((*(GLuint *)&ctx->Color.ColorMask[0]) >> 24) & 0xFF;
+ vmesa->regHFBBMSKL = PACK_COLOR_888(ctx->Color.ColorMask[0],
+ ctx->Color.ColorMask[1],
+ ctx->Color.ColorMask[2]);
+ vmesa->regHROP |= ctx->Color.ColorMask[3];
- if ((GLuint)((GLuint *)&ctx->Color.ColorMask[0]) & 0xFF000000)
+ if (ctx->Color.ColorMask[3])
vmesa->regEnable |= HC_HenAW_MASK;
else
- vmesa->regEnable &= (~HC_HenAW_MASK);
- if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__);
+ vmesa->regEnable &= ~HC_HenAW_MASK;
}
static void viaChooseFogState(GLcontext *ctx)
{
- viaContextPtr vmesa = VIA_CONTEXT(ctx);
+ struct via_context *vmesa = VIA_CONTEXT(ctx);
if (ctx->Fog.Enabled) {
GLubyte r, g, b, a;
- vmesa->regCmdB |= (HC_HVPMSK_Cd | HC_HVPMSK_Cs | HC_HVPMSK_W);
vmesa->regEnable |= HC_HenFOG_MASK;
/* Use fog equation 0 (OpenGL's default) & local fog.
vmesa->regHFogCH = a;
}
else {
- if (!ctx->Texture._EnabledUnits) {
- vmesa->regCmdB &= ~ HC_HVPMSK_W;
- vmesa->regCmdB &= ~ HC_HVPMSK_Cs;
- }
vmesa->regEnable &= ~HC_HenFOG_MASK;
}
}
static void viaChooseDepthState(GLcontext *ctx)
{
- viaContextPtr vmesa = VIA_CONTEXT(ctx);
+ struct via_context *vmesa = VIA_CONTEXT(ctx);
if (ctx->Depth.Test) {
- vmesa->regCmdB |= HC_HVPMSK_Z;
vmesa->regEnable |= HC_HenZT_MASK;
if (ctx->Depth.Mask)
vmesa->regEnable |= HC_HenZW_MASK;
}
else {
- /* Still need to send parameter Z.
- */
-
- vmesa->regCmdB |= HC_HVPMSK_Z;
vmesa->regEnable &= ~HC_HenZT_MASK;
/*=* [DBG] racer : can't display cars in car selection menu *=*/
}
}
-static void viaChooseLightState(GLcontext *ctx)
-{
- viaContextPtr vmesa = VIA_CONTEXT(ctx);
-
- if (ctx->Light.ShadeModel == GL_SMOOTH) {
- vmesa->regCmdA |= HC_HShading_Gouraud;
- vmesa->regCmdB |= HC_HVPMSK_Cd;
- }
- else {
- vmesa->regCmdA &= ~HC_HShading_Gouraud;
- vmesa->regCmdB |= HC_HVPMSK_Cd;
- }
-}
-
static void viaChooseLineState(GLcontext *ctx)
{
- viaContextPtr vmesa = VIA_CONTEXT(ctx);
-
- if (ctx->Line.SmoothFlag) {
- vmesa->regEnable |= HC_HenAA_MASK;
- }
- else {
- if (!ctx->Polygon.SmoothFlag) {
- vmesa->regEnable &= ~HC_HenAA_MASK;
- }
- }
+ struct via_context *vmesa = VIA_CONTEXT(ctx);
if (ctx->Line.StippleFlag) {
vmesa->regEnable |= HC_HenLP_MASK;
static void viaChoosePolygonState(GLcontext *ctx)
{
- viaContextPtr vmesa = VIA_CONTEXT(ctx);
+ struct via_context *vmesa = VIA_CONTEXT(ctx);
- /* KW: FIXME: this should be in viaRasterPrimitive (somehow)
+#if 0
+ /* Polygon stipple is broken - see via_state.c
*/
- if (ctx->Polygon.SmoothFlag) {
- vmesa->regEnable |= HC_HenAA_MASK;
- }
- else {
- if (!ctx->Line.SmoothFlag) {
- vmesa->regEnable &= ~HC_HenAA_MASK;
- }
- }
-
if (ctx->Polygon.StippleFlag) {
vmesa->regEnable |= HC_HenSP_MASK;
}
else {
vmesa->regEnable &= ~HC_HenSP_MASK;
}
+#else
+ FALLBACK(vmesa, VIA_FALLBACK_POLY_STIPPLE,
+ ctx->Polygon.StippleFlag);
+#endif
if (ctx->Polygon.CullFlag) {
vmesa->regEnable |= HC_HenFBCull_MASK;
static void viaChooseStencilState(GLcontext *ctx)
{
- viaContextPtr vmesa = VIA_CONTEXT(ctx);
- if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__);
+ struct via_context *vmesa = VIA_CONTEXT(ctx);
- if (ctx->Stencil.Enabled) {
+ if (ctx->Stencil._Enabled) {
GLuint temp;
vmesa->regEnable |= HC_HenST_MASK;
else {
vmesa->regEnable &= ~HC_HenST_MASK;
}
- if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__);
}
static void viaChooseTriangle(GLcontext *ctx)
{
- viaContextPtr vmesa = VIA_CONTEXT(ctx);
- if (VIA_DEBUG) {
- fprintf(stderr, "%s - in\n", __FUNCTION__);
- fprintf(stderr, "GL_CULL_FACE = %x\n", GL_CULL_FACE);
- fprintf(stderr, "ctx->Polygon.CullFlag = %x\n", ctx->Polygon.CullFlag);
- fprintf(stderr, "GL_FRONT = %x\n", GL_FRONT);
- fprintf(stderr, "ctx->Polygon.CullFaceMode = %x\n", ctx->Polygon.CullFaceMode);
- fprintf(stderr, "GL_CCW = %x\n", GL_CCW);
- fprintf(stderr, "ctx->Polygon.FrontFace = %x\n", ctx->Polygon.FrontFace);
- }
+ struct via_context *vmesa = VIA_CONTEXT(ctx);
+
if (ctx->Polygon.CullFlag == GL_TRUE) {
switch (ctx->Polygon.CullFaceMode) {
case GL_FRONT:
return;
}
}
- if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__);
}
void viaValidateState( GLcontext *ctx )
{
- viaContextPtr vmesa = VIA_CONTEXT(ctx);
- struct gl_texture_unit *texUnit0 = &ctx->Texture.Unit[0];
- struct gl_texture_unit *texUnit1 = &ctx->Texture.Unit[1];
- if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__);
+ struct via_context *vmesa = VIA_CONTEXT(ctx);
-#if 0
- if (!(vmesa->newState & (_NEW_COLOR |
- _NEW_TEXTURE |
- _NEW_DEPTH |
- _NEW_FOG |
- _NEW_LIGHT |
- _NEW_LINE |
- _NEW_POLYGON |
- _NEW_POLYGONSTIPPLE |
- _NEW_STENCIL)))
- return;
-#endif
-
- if (texUnit0->_ReallyEnabled || texUnit1->_ReallyEnabled || ctx->Fog.Enabled) {
- vmesa->regCmdB |= HC_HVPMSK_Cs;
- }
- else {
- vmesa->regCmdB &= ~ HC_HVPMSK_Cs;
- }
-
if (vmesa->newState & _NEW_TEXTURE) {
- viaChooseTextureState(ctx);
- viaUpdateTextureState(ctx); /* May modify vmesa->Fallback */
+ GLboolean ok = (viaChooseTextureState(ctx) &&
+ viaUpdateTextureState(ctx));
+
+ FALLBACK(vmesa, VIA_FALLBACK_TEXTURE, !ok);
}
if (vmesa->newState & _NEW_COLOR)
if (vmesa->newState & _NEW_FOG)
viaChooseFogState(ctx);
- if (vmesa->newState & _NEW_LIGHT)
- viaChooseLightState(ctx);
-
if (vmesa->newState & _NEW_LINE)
viaChooseLineState(ctx);
viaChooseTriangle(ctx);
}
- if (vmesa->newState & _NEW_STENCIL)
+ if ((vmesa->newState & _NEW_STENCIL) && vmesa->have_hw_stencil)
viaChooseStencilState(ctx);
- if (!vmesa->Fallback) {
- via_emit_state(vmesa);
- vmesa->newState = 0;
- }
-
- if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__);
+ if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR)
+ vmesa->regEnable |= HC_HenCS_MASK;
+ else
+ vmesa->regEnable &= ~HC_HenCS_MASK;
+
+ if (ctx->Point.SmoothFlag ||
+ ctx->Line.SmoothFlag ||
+ ctx->Polygon.SmoothFlag)
+ vmesa->regEnable |= HC_HenAA_MASK;
+ else
+ vmesa->regEnable &= ~HC_HenAA_MASK;
+
+ vmesa->newEmitState |= vmesa->newState;
+ vmesa->newState = 0;
}
static void viaInvalidateState(GLcontext *ctx, GLuint newState)
{
- viaContextPtr vmesa = VIA_CONTEXT(ctx);
+ struct via_context *vmesa = VIA_CONTEXT(ctx);
VIA_FINISH_PRIM( vmesa );
vmesa->newState |= newState;
_swrast_InvalidateState(ctx, newState);
_swsetup_InvalidateState(ctx, newState);
- _ac_InvalidateState(ctx, newState);
+ _vbo_InvalidateState(ctx, newState);
_tnl_InvalidateState(ctx, newState);
}
ctx->Driver.BlendEquationSeparate = viaBlendEquationSeparate;
ctx->Driver.BlendFuncSeparate = viaBlendFuncSeparate;
ctx->Driver.ClearColor = viaClearColor;
+ ctx->Driver.ColorMask = viaColorMask;
ctx->Driver.DrawBuffer = viaDrawBuffer;
ctx->Driver.RenderMode = viaRenderMode;
ctx->Driver.Scissor = viaScissor;
ctx->Driver.DepthRange = viaDepthRange;
ctx->Driver.Viewport = viaViewport;
+ ctx->Driver.Enable = viaEnable;
- /* Pixel path fallbacks.
- */
- ctx->Driver.Accum = _swrast_Accum;
- ctx->Driver.Bitmap = _swrast_Bitmap;
- ctx->Driver.CopyPixels = _swrast_CopyPixels;
- ctx->Driver.DrawPixels = _swrast_DrawPixels;
- ctx->Driver.ReadPixels = _swrast_ReadPixels;
+ /* XXX this should go away */
ctx->Driver.ResizeBuffers = viaReAllocateBuffers;
-
- /* Swrast hooks for imaging extensions:
- */
- ctx->Driver.CopyColorTable = _swrast_CopyColorTable;
- ctx->Driver.CopyColorSubTable = _swrast_CopyColorSubTable;
- ctx->Driver.CopyConvolutionFilter1D = _swrast_CopyConvolutionFilter1D;
- ctx->Driver.CopyConvolutionFilter2D = _swrast_CopyConvolutionFilter2D;
}
projects / mesa.git / blobdiff