static void gammaDDShadeModel( GLcontext *ctx, GLenum mode )
{
gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
u_int32_t g = gmesa->GeometryMode;
u_int32_t c = gmesa->ColorDDAMode;
g &= ~GM_ShadingMask;
c &= ~ColorDDAShadingMask;
switch ( mode ) {
case GL_FLAT:
g |= GM_FlatShading;
c |= ColorDDAFlat;
break;
case GL_SMOOTH:
g |= GM_GouraudShading;
c |= ColorDDAGouraud;
break;
default:
return;
}
if ( gmesa->ColorDDAMode != c ) {
FLUSH_BATCH( gmesa );
gmesa->ColorDDAMode = c;
gmesa->dirty |= GAMMA_UPLOAD_SHADE;
}
if ( gmesa->GeometryMode != g ) {
FLUSH_BATCH( gmesa );
gmesa->GeometryMode = g;
gmesa->dirty |= GAMMA_UPLOAD_GEOMETRY;
}
}
static void gammaUpdateCull( GLcontext *ctx )
{
gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
u_int32_t g = gmesa->GeometryMode;
g &= ~(GM_PolyCullMask | GM_FFMask);
if (ctx->Polygon.FrontFace == GL_CCW) {
g |= GM_FrontFaceCCW;
} else {
g |= GM_FrontFaceCW;
}
switch ( ctx->Polygon.CullFaceMode ) {
case GL_FRONT:
g |= GM_PolyCullFront;
break;
case GL_BACK:
g |= GM_PolyCullBack;
break;
case GL_FRONT_AND_BACK:
g |= GM_PolyCullBoth;
break;
}
if ( ctx->Polygon.CullFlag ) {
g |= GM_PolyCullEnable;
} else {
g &= ~GM_PolyCullEnable;
}
if ( gmesa->GeometryMode != g ) {
gmesa->GeometryMode = g;
gmesa->dirty |= GAMMA_UPLOAD_GEOMETRY;
}
}
void gammaUpdateWindow( GLcontext *ctx )
{
gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
__DRIdrawablePrivate *dPriv = gmesa->driDrawable;
GLfloat xoffset = (GLfloat)dPriv->x;
GLfloat yoffset = gmesa->driScreen->fbHeight - (GLfloat)dPriv->y - dPriv->h;
const GLfloat *v = ctx->Viewport._WindowMap.m;
GLfloat sx = v[MAT_SX];
GLfloat tx = v[MAT_TX] + xoffset;
GLfloat sy = v[MAT_SY];
GLfloat ty = v[MAT_TY] + yoffset;
GLfloat sz = v[MAT_SZ] * gmesa->depth_scale;
GLfloat tz = v[MAT_TZ] * gmesa->depth_scale;
gmesa->dirty |= GAMMA_UPLOAD_VIEWPORT;
gmesa->ViewportScaleX = sx;
gmesa->ViewportScaleY = sy;
gmesa->ViewportScaleZ = sz;
gmesa->ViewportOffsetX = tx;
gmesa->ViewportOffsetY = ty;
gmesa->ViewportOffsetZ = tz;
}
static void gammaDDLightfv(GLcontext *ctx, GLenum light, GLenum pname,
const GLfloat *params, GLint nParams)
{
gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
GLfloat l,x,y,z,w;
switch(light) {
case GL_LIGHT0:
switch (pname) {
case GL_AMBIENT:
CHECK_DMA_BUFFER(gmesa, 3);
/* We don't do alpha */
WRITEF(gmesa->buf, Light0AmbientIntensityBlue, params[2]);
WRITEF(gmesa->buf, Light0AmbientIntensityGreen, params[1]);
WRITEF(gmesa->buf, Light0AmbientIntensityRed, params[0]);
break;
case GL_DIFFUSE:
CHECK_DMA_BUFFER(gmesa, 3);
/* We don't do alpha */
WRITEF(gmesa->buf, Light0DiffuseIntensityBlue, params[2]);
WRITEF(gmesa->buf, Light0DiffuseIntensityGreen, params[1]);
WRITEF(gmesa->buf, Light0DiffuseIntensityRed, params[0]);
break;
case GL_SPECULAR:
CHECK_DMA_BUFFER(gmesa, 3);
/* We don't do alpha */
WRITEF(gmesa->buf, Light0SpecularIntensityBlue, params[2]);
WRITEF(gmesa->buf, Light0SpecularIntensityGreen, params[1]);
WRITEF(gmesa->buf, Light0SpecularIntensityRed, params[0]);
break;
case GL_POSITION:
/* Normalize <x,y,z> */
x = params[0]; y = params[1]; z = params[2]; w = params[3];
l = sqrt(x*x + y*y + z*z + w*w);
w /= l;
x /= l;
y /= l;
z /= l;
if (params[3] != 0.0) {
gmesa->Light0Mode |= Light0ModeAttenuation;
gmesa->Light0Mode |= Light0ModeLocal;
} else {
gmesa->Light0Mode &= ~Light0ModeAttenuation;
gmesa->Light0Mode &= ~Light0ModeLocal;
}
CHECK_DMA_BUFFER(gmesa, 5);
WRITE(gmesa->buf, Light0Mode, gmesa->Light0Mode);
WRITEF(gmesa->buf, Light0PositionW, w);
WRITEF(gmesa->buf, Light0PositionZ, z);
WRITEF(gmesa->buf, Light0PositionY, y);
WRITEF(gmesa->buf, Light0PositionX, x);
break;
case GL_SPOT_DIRECTION:
CHECK_DMA_BUFFER(gmesa, 3);
/* WRITEF(gmesa->buf, Light0SpotlightDirectionW, params[3]); */
WRITEF(gmesa->buf, Light0SpotlightDirectionZ, params[2]);
WRITEF(gmesa->buf, Light0SpotlightDirectionY, params[1]);
WRITEF(gmesa->buf, Light0SpotlightDirectionX, params[0]);
break;
case GL_SPOT_EXPONENT:
CHECK_DMA_BUFFER(gmesa, 1);
WRITEF(gmesa->buf, Light0SpotlightExponent, params[0]);
break;
case GL_SPOT_CUTOFF:
if (params[0] != 180.0)
gmesa->Light0Mode |= Light0ModeSpotLight;
else
gmesa->Light0Mode &= ~Light0ModeSpotLight;
CHECK_DMA_BUFFER(gmesa, 2);
WRITE(gmesa->buf, Light0Mode, gmesa->Light0Mode);
WRITEF(gmesa->buf, Light0CosSpotlightCutoffAngle, cos(params[0]*DEG2RAD));
break;
case GL_CONSTANT_ATTENUATION:
CHECK_DMA_BUFFER(gmesa, 1);
WRITEF(gmesa->buf, Light0ConstantAttenuation, params[0]);
break;
case GL_LINEAR_ATTENUATION:
CHECK_DMA_BUFFER(gmesa, 1);
WRITEF(gmesa->buf, Light0LinearAttenuation, params[0]);
break;
case GL_QUADRATIC_ATTENUATION:
CHECK_DMA_BUFFER(gmesa, 1);
WRITEF(gmesa->buf, Light0QuadraticAttenuation, params[0]);
break;
}
break;
}
}
static void gammaDDPolygonStipple( GLcontext *ctx, const GLubyte *mask)
{
gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
FLUSH_BATCH( gmesa );
gmesa->new_state |= GAMMA_NEW_STIPPLE;
}
static void gammaDDFlush( GLcontext *ctx )
{
gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
FLUSH_DMA_BUFFER(gmesa);
}
static void gammaUpdateAlphaMode( GLcontext *ctx )
{
gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
u_int32_t a = gmesa->AlphaTestMode;
u_int32_t b = gmesa->AlphaBlendMode;
u_int32_t f = gmesa->AB_FBReadMode_Save = 0;
GLubyte refByte = (GLint) (ctx->Color.AlphaRef * 255.0);
a &= ~(AT_CompareMask | AT_RefValueMask);
b &= ~(AB_SrcBlendMask | AB_DstBlendMask);
a |= refByte << 4;
switch ( ctx->Color.AlphaFunc ) {
case GL_NEVER:
a |= AT_Never;
break;
case GL_LESS:
a |= AT_Less;
break;
case GL_EQUAL:
a |= AT_Equal;
break;
case GL_LEQUAL:
a |= AT_LessEqual;
break;
case GL_GEQUAL:
a |= AT_GreaterEqual;
break;
case GL_GREATER:
a |= AT_Greater;
break;
case GL_NOTEQUAL:
a |= AT_NotEqual;
break;
case GL_ALWAYS:
a |= AT_Always;
break;
}
if ( ctx->Color.AlphaEnabled ) {
f |= FBReadDstEnable;
a |= AlphaTestModeEnable;
} else {
a &= ~AlphaTestModeEnable;
}
switch ( ctx->Color.BlendSrcRGB ) {
case GL_ZERO:
b |= AB_Src_Zero;
break;
case GL_ONE:
b |= AB_Src_One;
break;
case GL_DST_COLOR:
b |= AB_Src_DstColor;
break;
case GL_ONE_MINUS_DST_COLOR:
b |= AB_Src_OneMinusDstColor;
break;
case GL_SRC_ALPHA:
b |= AB_Src_SrcAlpha;
break;
case GL_ONE_MINUS_SRC_ALPHA:
b |= AB_Src_OneMinusSrcAlpha;
break;
case GL_DST_ALPHA:
b |= AB_Src_DstAlpha;
f |= FBReadSrcEnable;
break;
case GL_ONE_MINUS_DST_ALPHA:
b |= AB_Src_OneMinusDstAlpha;
f |= FBReadSrcEnable;
break;
case GL_SRC_ALPHA_SATURATE:
b |= AB_Src_SrcAlphaSaturate;
break;
}
switch ( ctx->Color.BlendDstRGB ) {
case GL_ZERO:
b |= AB_Dst_Zero;
break;
case GL_ONE:
b |= AB_Dst_One;
break;
case GL_SRC_COLOR:
b |= AB_Dst_SrcColor;
break;
case GL_ONE_MINUS_SRC_COLOR:
b |= AB_Dst_OneMinusSrcColor;
break;
case GL_SRC_ALPHA:
b |= AB_Dst_SrcAlpha;
break;
case GL_ONE_MINUS_SRC_ALPHA:
b |= AB_Dst_OneMinusSrcAlpha;
break;
case GL_DST_ALPHA:
b |= AB_Dst_DstAlpha;
f |= FBReadSrcEnable;
break;
case GL_ONE_MINUS_DST_ALPHA:
b |= AB_Dst_OneMinusDstAlpha;
f |= FBReadSrcEnable;
break;
}
if ( ctx->Color.BlendEnabled ) {
f |= FBReadDstEnable;
b |= AlphaBlendModeEnable;
} else {
b &= ~AlphaBlendModeEnable;
}
if ( gmesa->AlphaTestMode != a ) {
gmesa->AlphaTestMode = a;
gmesa->dirty |= GAMMA_UPLOAD_ALPHA;
}
if ( gmesa->AlphaBlendMode != b) {
gmesa->AlphaBlendMode = b;
gmesa->dirty |= GAMMA_UPLOAD_BLEND;
}
gmesa->AB_FBReadMode_Save = f;
}
static void gammaUpdateZMode( GLcontext *ctx )
{
gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
u_int32_t z = gmesa->DepthMode;
u_int32_t delta = gmesa->DeltaMode;
u_int32_t window = gmesa->Window;
u_int32_t lbread = gmesa->LBReadMode;
z &= ~DM_CompareMask;
switch ( ctx->Depth.Func ) {
case GL_NEVER:
z |= DM_Never;
break;
case GL_ALWAYS:
z |= DM_Always;
break;
case GL_LESS:
z |= DM_Less;
break;
case GL_LEQUAL:
z |= DM_LessEqual;
break;
case GL_EQUAL:
z |= DM_Equal;
break;
case GL_GEQUAL:
z |= DM_GreaterEqual;
break;
case GL_GREATER:
z |= DM_Greater;
break;
case GL_NOTEQUAL:
z |= DM_NotEqual;
break;
}
if ( ctx->Depth.Test ) {
z |= DepthModeEnable;
delta |= DM_DepthEnable;
window |= W_DepthFCP;
lbread |= LBReadDstEnable;
} else {
z &= ~DepthModeEnable;
delta &= ~DM_DepthEnable;
window &= ~W_DepthFCP;
lbread &= ~LBReadDstEnable;
}
if ( ctx->Depth.Mask ) {
z |= DM_WriteMask;
} else {
z &= ~DM_WriteMask;
}
#if 0
if ( gmesa->DepthMode != z ){
#endif
gmesa->DepthMode = z;
gmesa->DeltaMode = delta;
gmesa->Window = window;
gmesa->LBReadMode = lbread;
gmesa->dirty |= GAMMA_UPLOAD_DEPTH;
#if 0
}
#endif
}
static void gammaDDClear( GLcontext *ctx, GLbitfield mask, GLboolean all,
GLint cx, GLint cy, GLint cw, GLint ch )
{
gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
GLINTDRIPtr gDRIPriv = (GLINTDRIPtr)gmesa->driScreen->pDevPriv;
GLuint temp = 0;
FLUSH_BATCH( gmesa );
/* Update and emit any new state. We need to do this here to catch
* changes to the masks.
* FIXME: Just update the masks?
*/
if ( gmesa->new_state )
gammaDDUpdateHWState( ctx );
#ifdef DO_VALIDATE
/* Flush any partially filled buffers */
FLUSH_DMA_BUFFER(gmesa);
DRM_SPINLOCK(&gmesa->driScreen->pSAREA->drawable_lock,
gmesa->driScreen->drawLockID);
VALIDATE_DRAWABLE_INFO_NO_LOCK(gmesa);
#endif
if (mask & BUFFER_BIT_DEPTH) {
/* Turn off writes the FB */
CHECK_DMA_BUFFER(gmesa, 1);
WRITE(gmesa->buf, FBWriteMode, FBWriteModeDisable);
mask &= ~BUFFER_BIT_DEPTH;
/*
* Turn Rectangle2DControl off when the window is not clipped
* (i.e., the GID tests are not necessary). This dramatically
* increases the performance of the depth clears.
*/
if (!gmesa->NotClipped) {
CHECK_DMA_BUFFER(gmesa, 1);
WRITE(gmesa->buf, Rectangle2DControl, 1);
}
temp = (gmesa->LBReadMode & LBPartialProdMask) | LBWindowOriginBot;
if (gDRIPriv->numMultiDevices == 2) temp |= LBScanLineInt2;
CHECK_DMA_BUFFER(gmesa, 5);
WRITE(gmesa->buf, LBReadMode, temp);
WRITE(gmesa->buf, DeltaMode, DM_DepthEnable);
WRITE(gmesa->buf, DepthMode, (DepthModeEnable |
DM_Always |
DM_SourceDepthRegister |
DM_WriteMask));
WRITE(gmesa->buf, GLINTDepth, gmesa->ClearDepth);
/* Increment the frame count */
gmesa->FrameCount++;
#ifdef FAST_CLEAR_4
gmesa->FrameCount &= 0x0f;
#else
gmesa->FrameCount &= 0xff;
#endif
/* Force FCP to be written */
WRITE(gmesa->buf, GLINTWindow, (WindowEnable |
W_PassIfEqual |
(gmesa->Window & W_GIDMask) |
W_DepthFCP |
W_LBUpdateFromRegisters |
W_OverrideWriteFiltering |
(gmesa->FrameCount << 9)));
/* Clear part of the depth and FCP buffers */
{
int y = gmesa->driScreen->fbHeight - gmesa->driDrawable->y - gmesa->driDrawable->h;
int x = gmesa->driDrawable->x;
int w = gmesa->driDrawable->w;
int h = gmesa->driDrawable->h;
#ifndef TURN_OFF_FCP
float hsub = h;
if (gmesa->WindowChanged) {
gmesa->WindowChanged = GL_FALSE;
} else {
#ifdef FAST_CLEAR_4
hsub /= 16;
#else
hsub /= 256;
#endif
/* Handle the case where the height < # of FCPs */
if (hsub < 1.0) {
if (gmesa->FrameCount > h)
gmesa->FrameCount = 0;
h = 1;
y += gmesa->FrameCount;
} else {
h = (gmesa->FrameCount+1)*hsub;
h -= (int)(gmesa->FrameCount*hsub);
y += gmesa->FrameCount*hsub;
}
}
#endif
if (h && w) {
#if 0
CHECK_DMA_BUFFER(gmesa, 2);
WRITE(gmesa->buf, Rectangle2DMode, ((h & 0xfff)<<12) |
(w & 0xfff) );
WRITE(gmesa->buf, DrawRectangle2D, ((y & 0xffff)<<16) |
(x & 0xffff) );
#else
CHECK_DMA_BUFFER(gmesa, 8);
WRITE(gmesa->buf, StartXDom, x<<16);
WRITE(gmesa->buf, StartY, y<<16);
WRITE(gmesa->buf, StartXSub, (x+w)<<16);
WRITE(gmesa->buf, GLINTCount, h);
WRITE(gmesa->buf, dY, 1<<16);
WRITE(gmesa->buf, dXDom, 0<<16);
WRITE(gmesa->buf, dXSub, 0<<16);
WRITE(gmesa->buf, Render, 0x00000040); /* NOT_DONE */
#endif
}
}
CHECK_DMA_BUFFER(gmesa, 6);
WRITE(gmesa->buf, DepthMode, gmesa->DepthMode);
WRITE(gmesa->buf, DeltaMode, gmesa->DeltaMode);
WRITE(gmesa->buf, LBReadMode, gmesa->LBReadMode);
WRITE(gmesa->buf, GLINTWindow, gmesa->Window);
WRITE(gmesa->buf, FastClearDepth, gmesa->ClearDepth);
WRITE(gmesa->buf, FBWriteMode, FBWriteModeEnable);
/* Turn on Depth FCP */
if (gmesa->Window & W_DepthFCP) {
CHECK_DMA_BUFFER(gmesa, 1);
WRITE(gmesa->buf, WindowOr, (gmesa->FrameCount << 9));
}
/* Turn off GID clipping if window is not clipped */
if (gmesa->NotClipped) {
CHECK_DMA_BUFFER(gmesa, 1);
WRITE(gmesa->buf, Rectangle2DControl, 0);
}
}
if (mask & (BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT)) {
int y = gmesa->driScreen->fbHeight - gmesa->driDrawable->y - gmesa->driDrawable->h;
int x = gmesa->driDrawable->x;
int w = gmesa->driDrawable->w;
int h = gmesa->driDrawable->h;
mask &= ~(BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT);
if (x < 0) { w -= -x; x = 0; }
/* Turn on GID clipping if window is clipped */
if (!gmesa->NotClipped) {
CHECK_DMA_BUFFER(gmesa, 1);
WRITE(gmesa->buf, Rectangle2DControl, 1);
}
CHECK_DMA_BUFFER(gmesa, 18);
WRITE(gmesa->buf, FBBlockColor, gmesa->ClearColor);
WRITE(gmesa->buf, ColorDDAMode, ColorDDADisable);
WRITE(gmesa->buf, FBWriteMode, FBWriteModeEnable);
WRITE(gmesa->buf, DepthMode, 0);
WRITE(gmesa->buf, DeltaMode, 0);
WRITE(gmesa->buf, AlphaBlendMode, 0);
#if 1
WRITE(gmesa->buf, dY, 1<<16);
WRITE(gmesa->buf, dXDom, 0<<16);
WRITE(gmesa->buf, dXSub, 0<<16);
WRITE(gmesa->buf, StartXSub, (x+w)<<16);
WRITE(gmesa->buf, GLINTCount, h);
WRITE(gmesa->buf, StartXDom, x<<16);
WRITE(gmesa->buf, StartY, y<<16);
WRITE(gmesa->buf, Render, 0x00000048); /* NOT_DONE */
#else
WRITE(gmesa->buf, Rectangle2DMode, (((h & 0xfff)<<12) |
(w & 0xfff)));
WRITE(gmesa->buf, DrawRectangle2D, (((y & 0xffff)<<16) |
(x & 0xffff)));
#endif
WRITE(gmesa->buf, DepthMode, gmesa->DepthMode);
WRITE(gmesa->buf, DeltaMode, gmesa->DeltaMode);
WRITE(gmesa->buf, AlphaBlendMode, gmesa->AlphaBlendMode);
WRITE(gmesa->buf, ColorDDAMode, gmesa->ColorDDAMode);
/* Turn off GID clipping if window is clipped */
if (gmesa->NotClipped) {
CHECK_DMA_BUFFER(gmesa, 1);
WRITE(gmesa->buf, Rectangle2DControl, 0);
}
}
#ifdef DO_VALIDATE
PROCESS_DMA_BUFFER_TOP_HALF(gmesa);
DRM_SPINUNLOCK(&gmesa->driScreen->pSAREA->drawable_lock,
gmesa->driScreen->drawLockID);
VALIDATE_DRAWABLE_INFO_NO_LOCK_POST(gmesa);
PROCESS_DMA_BUFFER_BOTTOM_HALF(gmesa);
#endif
if ( mask )
_swrast_Clear( ctx, mask, all, cx, cy, cw, ch );
}
static void gammaDDEnable( GLcontext *ctx, GLenum cap, GLboolean state )
{
gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
switch ( cap ) {
case GL_ALPHA_TEST:
case GL_BLEND:
FLUSH_BATCH( gmesa );
gmesa->new_state |= GAMMA_NEW_ALPHA;
break;
case GL_CULL_FACE:
FLUSH_BATCH( gmesa );
gmesa->new_state |= GAMMA_NEW_CULL;
break;
case GL_DEPTH_TEST:
FLUSH_BATCH( gmesa );
gmesa->new_state |= GAMMA_NEW_DEPTH;
break;
case GL_DITHER:
do {
u_int32_t d = gmesa->DitherMode;
FLUSH_BATCH( gmesa );
if ( state ) {
d |= DM_DitherEnable;
} else {
d &= ~DM_DitherEnable;
}
if ( gmesa->DitherMode != d ) {
gmesa->DitherMode = d;
gmesa->dirty |= GAMMA_UPLOAD_DITHER;
}
} while (0);
break;
#if 0
case GL_FOG:
FLUSH_BATCH( gmesa );
gmesa->new_state |= GAMMA_NEW_FOG;
break;
#endif
case GL_INDEX_LOGIC_OP:
case GL_COLOR_LOGIC_OP:
FLUSH_BATCH( gmesa );
gmesa->new_state |= GAMMA_NEW_LOGICOP;
break;
#if ENABLELIGHTING
case GL_LIGHTING:
do {
u_int32_t l = gmesa->LightingMode;
FLUSH_BATCH( gmesa );
if ( state ) {
l |= LightingModeEnable;
} else {
l &= ~LightingModeEnable;
}
if ( gmesa->LightingMode != l ) {
gmesa->LightingMode = l;
gmesa->dirty |= GAMMA_UPLOAD_LIGHT;
}
} while (0);
break;
case GL_COLOR_MATERIAL:
do {
u_int32_t m = gmesa->MaterialMode;
FLUSH_BATCH( gmesa );
if ( state ) {
m |= MaterialModeEnable;
} else {
m &= ~MaterialModeEnable;
}
if ( gmesa->MaterialMode != m ) {
gmesa->MaterialMode = m;
gmesa->dirty |= GAMMA_UPLOAD_LIGHT;
}
} while (0);
break;
#endif
case GL_LINE_SMOOTH:
FLUSH_BATCH( gmesa );
if ( state ) {
gmesa->AntialiasMode |= AntialiasModeEnable;
gmesa->LineMode |= LM_AntialiasEnable;
} else {
gmesa->AntialiasMode &= ~AntialiasModeEnable;
gmesa->LineMode &= ~LM_AntialiasEnable;
}
gmesa->dirty |= GAMMA_UPLOAD_LINEMODE;
break;
case GL_POINT_SMOOTH:
FLUSH_BATCH( gmesa );
if ( state ) {
gmesa->AntialiasMode |= AntialiasModeEnable;
gmesa->PointMode |= PM_AntialiasEnable;
} else {
gmesa->AntialiasMode &= ~AntialiasModeEnable;
gmesa->PointMode &= ~PM_AntialiasEnable;
}
gmesa->dirty |= GAMMA_UPLOAD_POINTMODE;
break;
case GL_POLYGON_SMOOTH:
FLUSH_BATCH( gmesa );
if ( state ) {
gmesa->AntialiasMode |= AntialiasModeEnable;
gmesa->TriangleMode |= TM_AntialiasEnable;
} else {
gmesa->AntialiasMode &= ~AntialiasModeEnable;
gmesa->TriangleMode &= ~TM_AntialiasEnable;
}
gmesa->dirty |= GAMMA_UPLOAD_TRIMODE;
break;
case GL_SCISSOR_TEST:
FLUSH_BATCH( gmesa );
gmesa->new_state |= GAMMA_NEW_CLIP;
break;
case GL_POLYGON_OFFSET_FILL:
case GL_POLYGON_OFFSET_POINT:
case GL_POLYGON_OFFSET_LINE:
FLUSH_BATCH( gmesa );
gmesa->new_state |= GAMMA_NEW_POLYGON;
break;
case GL_LINE_STIPPLE:
FLUSH_BATCH( gmesa );
if ( state )
gmesa->LineMode |= LM_StippleEnable;
else
gmesa->LineMode &= ~LM_StippleEnable;
gmesa->dirty |= GAMMA_UPLOAD_LINEMODE;
break;
case GL_POLYGON_STIPPLE:
FLUSH_BATCH( gmesa );
gmesa->new_state |= GAMMA_NEW_STIPPLE;
break;
default:
return;
}
}
static void gammaLoadHWMatrix(GLcontext *ctx)
{
gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
const GLfloat *m;
gmesa->TransformMode &= ~XM_XformTexture;
switch (ctx->Transform.MatrixMode) {
case GL_MODELVIEW:
gmesa->TransformMode |= XM_UseModelViewMatrix;
m = ctx->ModelviewMatrixStack.Top->m;
CHECK_DMA_BUFFER(gmesa, 16);
WRITEF(gmesa->buf, ModelViewMatrix0, m[0]);
WRITEF(gmesa->buf, ModelViewMatrix1, m[1]);
WRITEF(gmesa->buf, ModelViewMatrix2, m[2]);
WRITEF(gmesa->buf, ModelViewMatrix3, m[3]);
WRITEF(gmesa->buf, ModelViewMatrix4, m[4]);
WRITEF(gmesa->buf, ModelViewMatrix5, m[5]);
WRITEF(gmesa->buf, ModelViewMatrix6, m[6]);
WRITEF(gmesa->buf, ModelViewMatrix7, m[7]);
WRITEF(gmesa->buf, ModelViewMatrix8, m[8]);
WRITEF(gmesa->buf, ModelViewMatrix9, m[9]);
WRITEF(gmesa->buf, ModelViewMatrix10, m[10]);
WRITEF(gmesa->buf, ModelViewMatrix11, m[11]);
WRITEF(gmesa->buf, ModelViewMatrix12, m[12]);
WRITEF(gmesa->buf, ModelViewMatrix13, m[13]);
WRITEF(gmesa->buf, ModelViewMatrix14, m[14]);
WRITEF(gmesa->buf, ModelViewMatrix15, m[15]);
break;
case GL_PROJECTION:
m = ctx->ProjectionMatrixStack.Top->m;
CHECK_DMA_BUFFER(gmesa, 16);
WRITEF(gmesa->buf, ModelViewProjectionMatrix0, m[0]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix1, m[1]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix2, m[2]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix3, m[3]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix4, m[4]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix5, m[5]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix6, m[6]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix7, m[7]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix8, m[8]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix9, m[9]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix10, m[10]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix11, m[11]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix12, m[12]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix13, m[13]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix14, m[14]);
WRITEF(gmesa->buf, ModelViewProjectionMatrix15, m[15]);
break;
case GL_TEXTURE:
m = ctx->TextureMatrixStack[0].Top->m;
CHECK_DMA_BUFFER(gmesa, 16);
gmesa->TransformMode |= XM_XformTexture;
WRITEF(gmesa->buf, TextureMatrix0, m[0]);
WRITEF(gmesa->buf, TextureMatrix1, m[1]);
WRITEF(gmesa->buf, TextureMatrix2, m[2]);
WRITEF(gmesa->buf, TextureMatrix3, m[3]);
WRITEF(gmesa->buf, TextureMatrix4, m[4]);
WRITEF(gmesa->buf, TextureMatrix5, m[5]);
WRITEF(gmesa->buf, TextureMatrix6, m[6]);
WRITEF(gmesa->buf, TextureMatrix7, m[7]);
WRITEF(gmesa->buf, TextureMatrix8, m[8]);
WRITEF(gmesa->buf, TextureMatrix9, m[9]);
WRITEF(gmesa->buf, TextureMatrix10, m[10]);
WRITEF(gmesa->buf, TextureMatrix11, m[11]);
WRITEF(gmesa->buf, TextureMatrix12, m[12]);
WRITEF(gmesa->buf, TextureMatrix13, m[13]);
WRITEF(gmesa->buf, TextureMatrix14, m[14]);
WRITEF(gmesa->buf, TextureMatrix15, m[15]);
break;
default:
/* ERROR!!! -- how did this happen? */
break;
}
gmesa->dirty |= GAMMA_UPLOAD_TRANSFORM;
}
void gammaDDInitSpanFuncs( GLcontext *ctx )
{
gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
struct swrast_device_driver *swdd = _swrast_GetDeviceDriverReference(ctx);
swdd->SetBuffer = gammaSetBuffer;
switch ( gmesa->gammaScreen->cpp ) {
case 2:
swdd->WriteRGBASpan = gammaWriteRGBASpan_RGB565;
swdd->WriteRGBSpan = gammaWriteRGBSpan_RGB565;
swdd->WriteMonoRGBASpan = gammaWriteMonoRGBASpan_RGB565;
swdd->WriteRGBAPixels = gammaWriteRGBAPixels_RGB565;
swdd->WriteMonoRGBAPixels = gammaWriteMonoRGBAPixels_RGB565;
swdd->ReadRGBASpan = gammaReadRGBASpan_RGB565;
swdd->ReadRGBAPixels = gammaReadRGBAPixels_RGB565;
break;
case 4:
swdd->WriteRGBASpan = gammaWriteRGBASpan_ARGB8888;
swdd->WriteRGBSpan = gammaWriteRGBSpan_ARGB8888;
swdd->WriteMonoRGBASpan = gammaWriteMonoRGBASpan_ARGB8888;
swdd->WriteRGBAPixels = gammaWriteRGBAPixels_ARGB8888;
swdd->WriteMonoRGBAPixels = gammaWriteMonoRGBAPixels_ARGB8888;
#if 1
swdd->ReadRGBASpan = gammaReadRGBASpan_ARGB8888;
#else
swdd->ReadRGBASpan = gammaReadRGBASpan8888;
#endif
swdd->ReadRGBAPixels = gammaReadRGBAPixels_ARGB8888;
break;
default:
break;
}
switch ( gmesa->glCtx->Visual.depthBits ) {
case 16:
swdd->ReadDepthSpan = gammaReadDepthSpan_16;
swdd->WriteDepthSpan = gammaWriteDepthSpan_16;
swdd->ReadDepthPixels = gammaReadDepthPixels_16;
swdd->WriteDepthPixels = gammaWriteDepthPixels_16;
break;
case 24:
swdd->ReadDepthSpan = gammaReadDepthSpan_24_8;
swdd->WriteDepthSpan = gammaWriteDepthSpan_24_8;
swdd->ReadDepthPixels = gammaReadDepthPixels_24_8;
swdd->WriteDepthPixels = gammaWriteDepthPixels_24_8;
#if 0
swdd->ReadStencilSpan = gammaReadStencilSpan_24_8;
swdd->WriteStencilSpan = gammaWriteStencilSpan_24_8;
swdd->ReadStencilPixels = gammaReadStencilPixels_24_8;
swdd->WriteStencilPixels = gammaWriteStencilPixels_24_8;
#endif
break;
default:
break;
}
}
