static void mgaDDLogicOp( GLcontext *ctx, GLenum opcode )
{
mgaContextPtr mmesa = MGA_CONTEXT( ctx );
MGA_STATECHANGE( mmesa, MGA_UPLOAD_CONTEXT );
mmesa->hw.rop = mgarop_NoBLK[ opcode & 0x0f ];
}
static void mgaDDDepthFunc(GLcontext *ctx, GLenum func)
{
mgaContextPtr mmesa = MGA_CONTEXT( ctx );
int zmode;
switch (func) {
case GL_NEVER:
/* can't do this in h/w, we'll use a s/w fallback */
FALLBACK (ctx, MGA_FALLBACK_DEPTH, ctx->Depth.Test);
/* FALLTHROUGH */
case GL_ALWAYS:
zmode = DC_zmode_nozcmp; break;
case GL_LESS:
zmode = DC_zmode_zlt; break;
case GL_LEQUAL:
zmode = DC_zmode_zlte; break;
case GL_EQUAL:
zmode = DC_zmode_ze; break;
case GL_GREATER:
zmode = DC_zmode_zgt; break;
case GL_GEQUAL:
zmode = DC_zmode_zgte; break;
case GL_NOTEQUAL:
zmode = DC_zmode_zne; break;
default:
zmode = 0; break;
}
MGA_STATECHANGE( mmesa, MGA_UPLOAD_CONTEXT );
mmesa->hw.zmode &= DC_zmode_MASK;
mmesa->hw.zmode |= zmode;
}
static void mgaDDStencilMask(GLcontext *ctx, GLuint mask)
{
mgaContextPtr mmesa = MGA_CONTEXT(ctx);
MGA_STATECHANGE( mmesa, MGA_UPLOAD_CONTEXT );
mmesa->hw.stencil &= S_swtmsk_MASK;
mmesa->hw.stencil |= MGA_FIELD( S_swtmsk, mask );
}
static void mgaDDDepthMask(GLcontext *ctx, GLboolean flag)
{
mgaContextPtr mmesa = MGA_CONTEXT( ctx );
MGA_STATECHANGE( mmesa, MGA_UPLOAD_CONTEXT );
mmesa->hw.zmode &= DC_atype_MASK;
mmesa->hw.zmode |= (flag) ? DC_atype_zi : DC_atype_i;
}
static void mgaDDFogfv(GLcontext *ctx, GLenum pname, const GLfloat *param)
{
mgaContextPtr mmesa = MGA_CONTEXT(ctx);
if (pname == GL_FOG_COLOR) {
GLuint color = PACK_COLOR_888((GLubyte)(ctx->Fog.Color[0]*255.0F),
(GLubyte)(ctx->Fog.Color[1]*255.0F),
(GLubyte)(ctx->Fog.Color[2]*255.0F));
MGA_STATECHANGE(mmesa, MGA_UPLOAD_CONTEXT);
mmesa->setup.fogcolor = color;
}
}
static void updateBlendLogicOp(GLcontext *ctx)
{
mgaContextPtr mmesa = MGA_CONTEXT(ctx);
MGA_STATECHANGE( mmesa, MGA_UPLOAD_CONTEXT );
mmesa->hw.blend_func_enable =
(ctx->Color.BlendEnabled && !ctx->Color._LogicOpEnabled) ? ~0 : 0;
FALLBACK( ctx, MGA_FALLBACK_BLEND,
ctx->Color.BlendEnabled && !ctx->Color._LogicOpEnabled &&
mmesa->hw.blend_func == (AC_src_src_alpha_sat | AC_dst_zero) );
}
static void
mgaDDStencilFuncSeparate(GLcontext *ctx, GLenum face, GLenum func, GLint ref,
GLuint mask)
{
mgaContextPtr mmesa = MGA_CONTEXT(ctx);
GLuint stencil;
GLuint stencilctl;
stencil = MGA_FIELD( S_sref, ref ) | MGA_FIELD( S_smsk, mask );
switch (func)
{
case GL_NEVER:
stencilctl = SC_smode_snever;
break;
case GL_LESS:
stencilctl = SC_smode_slt;
break;
case GL_LEQUAL:
stencilctl = SC_smode_slte;
break;
case GL_GREATER:
stencilctl = SC_smode_sgt;
break;
case GL_GEQUAL:
stencilctl = SC_smode_sgte;
break;
case GL_NOTEQUAL:
stencilctl = SC_smode_sne;
break;
case GL_EQUAL:
stencilctl = SC_smode_se;
break;
case GL_ALWAYS:
default:
stencilctl = SC_smode_salways;
break;
}
MGA_STATECHANGE( mmesa, MGA_UPLOAD_CONTEXT );
mmesa->hw.stencil &= (S_sref_MASK & S_smsk_MASK);
mmesa->hw.stencil |= stencil;
mmesa->hw.stencilctl &= SC_smode_MASK;
mmesa->hw.stencilctl |= stencilctl;
}
static void mgaDDAlphaFunc(GLcontext *ctx, GLenum func, GLfloat ref)
{
mgaContextPtr mmesa = MGA_CONTEXT(ctx);
GLubyte refByte;
GLuint a;
CLAMPED_FLOAT_TO_UBYTE(refByte, ref);
switch ( func ) {
case GL_NEVER:
a = AC_atmode_alt;
refByte = 0;
break;
case GL_LESS:
a = AC_atmode_alt;
break;
case GL_GEQUAL:
a = AC_atmode_agte;
break;
case GL_LEQUAL:
a = AC_atmode_alte;
break;
case GL_GREATER:
a = AC_atmode_agt;
break;
case GL_NOTEQUAL:
a = AC_atmode_ane;
break;
case GL_EQUAL:
a = AC_atmode_ae;
break;
case GL_ALWAYS:
a = AC_atmode_noacmp;
break;
default:
a = 0;
break;
}
MGA_STATECHANGE( mmesa, MGA_UPLOAD_CONTEXT );
mmesa->hw.alpha_func = a | MGA_FIELD( AC_atref, refByte );
}
static void mgaDDColorMask(GLcontext *ctx,
GLboolean r, GLboolean g,
GLboolean b, GLboolean a )
{
mgaContextPtr mmesa = MGA_CONTEXT( ctx );
mgaScreenPrivate *mgaScreen = mmesa->mgaScreen;
GLuint mask = mgaPackColor(mgaScreen->cpp,
ctx->Color.ColorMask[RCOMP],
ctx->Color.ColorMask[GCOMP],
ctx->Color.ColorMask[BCOMP],
ctx->Color.ColorMask[ACOMP]);
if (mgaScreen->cpp == 2)
mask = mask | (mask << 16);
if (mmesa->setup.plnwt != mask) {
MGA_STATECHANGE( mmesa, MGA_UPLOAD_CONTEXT );
mmesa->setup.plnwt = mask;
}
}
static void mgaDDCullFaceFrontFace(GLcontext *ctx, GLenum unused)
{
mgaContextPtr mmesa = MGA_CONTEXT(ctx);
MGA_STATECHANGE( mmesa, MGA_UPLOAD_CONTEXT );
if (ctx->Polygon.CullFlag &&
ctx->Polygon.CullFaceMode != GL_FRONT_AND_BACK)
{
mmesa->hw.cull = _CULL_NEGATIVE;
if (ctx->Polygon.CullFaceMode == GL_FRONT)
mmesa->hw.cull ^= (_CULL_POSITIVE ^ _CULL_NEGATIVE);
if (ctx->Polygon.FrontFace != GL_CCW)
mmesa->hw.cull ^= (_CULL_POSITIVE ^ _CULL_NEGATIVE);
mmesa->hw.cull_dualtex = mmesa->hw.cull ^
(_CULL_POSITIVE ^ _CULL_NEGATIVE); /* warp bug? */
}
else {
mmesa->hw.cull = _CULL_DISABLE;
mmesa->hw.cull_dualtex = _CULL_DISABLE;
}
}
static void mgaDDEnable(GLcontext *ctx, GLenum cap, GLboolean state)
{
mgaContextPtr mmesa = MGA_CONTEXT( ctx );
switch(cap) {
case GL_DITHER:
MGA_STATECHANGE( mmesa, MGA_UPLOAD_CONTEXT );
if (!ctx->Color.DitherFlag)
mmesa->setup.maccess |= MA_nodither_enable;
else
mmesa->setup.maccess &= ~MA_nodither_enable;
break;
case GL_LIGHTING:
case GL_COLOR_SUM_EXT:
FLUSH_BATCH( mmesa );
updateSpecularLighting( ctx );
break;
case GL_ALPHA_TEST:
MGA_STATECHANGE( mmesa, MGA_UPLOAD_CONTEXT );
mmesa->hw.alpha_func_enable = (state) ? ~0 : 0;
break;
case GL_DEPTH_TEST:
MGA_STATECHANGE( mmesa, MGA_UPLOAD_CONTEXT );
FALLBACK (ctx, MGA_FALLBACK_DEPTH,
ctx->Depth.Func == GL_NEVER && ctx->Depth.Test);
break;
case GL_SCISSOR_TEST:
FLUSH_BATCH( mmesa );
mmesa->scissor = state;
mgaUpdateClipping( ctx );
break;
case GL_FOG:
MGA_STATECHANGE( mmesa, MGA_UPLOAD_CONTEXT );
if (ctx->Fog.Enabled)
mmesa->setup.maccess |= MA_fogen_enable;
else
mmesa->setup.maccess &= ~MA_fogen_enable;
break;
case GL_CULL_FACE:
mgaDDCullFaceFrontFace( ctx, 0 );
break;
case GL_TEXTURE_1D:
case GL_TEXTURE_2D:
case GL_TEXTURE_3D:
break;
case GL_POLYGON_STIPPLE:
if (mmesa->haveHwStipple && mmesa->raster_primitive == GL_TRIANGLES) {
MGA_STATECHANGE( mmesa, MGA_UPLOAD_CONTEXT );
mmesa->setup.dwgctl &= ~(0xf<<20);
if (state)
mmesa->setup.dwgctl |= mmesa->poly_stipple;
}
break;
case GL_BLEND:
case GL_COLOR_LOGIC_OP:
updateBlendLogicOp( ctx );
break;
case GL_STENCIL_TEST:
MGA_STATECHANGE( mmesa, MGA_UPLOAD_CONTEXT );
if (mmesa->hw_stencil) {
mmesa->hw.stencil_enable = ( state ) ? ~0 : 0;
}
else {
FALLBACK( ctx, MGA_FALLBACK_STENCIL, state );
}
default:
break;
}
}
static void
mgaDDStencilOpSeparate(GLcontext *ctx, GLenum face, GLenum fail, GLenum zfail,
GLenum zpass)
{
mgaContextPtr mmesa = MGA_CONTEXT(ctx);
GLuint stencilctl;
stencilctl = 0;
switch (ctx->Stencil.FailFunc[0])
{
case GL_KEEP:
stencilctl |= SC_sfailop_keep;
break;
case GL_ZERO:
stencilctl |= SC_sfailop_zero;
break;
case GL_REPLACE:
stencilctl |= SC_sfailop_replace;
break;
case GL_INCR:
stencilctl |= SC_sfailop_incrsat;
break;
case GL_DECR:
stencilctl |= SC_sfailop_decrsat;
break;
case GL_INCR_WRAP:
stencilctl |= SC_sfailop_incr;
break;
case GL_DECR_WRAP:
stencilctl |= SC_sfailop_decr;
break;
case GL_INVERT:
stencilctl |= SC_sfailop_invert;
break;
default:
break;
}
switch (ctx->Stencil.ZFailFunc[0])
{
case GL_KEEP:
stencilctl |= SC_szfailop_keep;
break;
case GL_ZERO:
stencilctl |= SC_szfailop_zero;
break;
case GL_REPLACE:
stencilctl |= SC_szfailop_replace;
break;
case GL_INCR:
stencilctl |= SC_szfailop_incrsat;
break;
case GL_DECR:
stencilctl |= SC_szfailop_decrsat;
break;
case GL_INCR_WRAP:
stencilctl |= SC_szfailop_incr;
break;
case GL_DECR_WRAP:
stencilctl |= SC_szfailop_decr;
break;
case GL_INVERT:
stencilctl |= SC_szfailop_invert;
break;
default:
break;
}
switch (ctx->Stencil.ZPassFunc[0])
{
case GL_KEEP:
stencilctl |= SC_szpassop_keep;
break;
case GL_ZERO:
stencilctl |= SC_szpassop_zero;
break;
case GL_REPLACE:
stencilctl |= SC_szpassop_replace;
break;
case GL_INCR:
stencilctl |= SC_szpassop_incrsat;
break;
case GL_DECR:
stencilctl |= SC_szpassop_decrsat;
break;
case GL_INCR_WRAP:
stencilctl |= SC_szpassop_incr;
break;
case GL_DECR_WRAP:
stencilctl |= SC_szpassop_decr;
break;
case GL_INVERT:
stencilctl |= SC_szpassop_invert;
break;
default:
break;
}
MGA_STATECHANGE( mmesa, MGA_UPLOAD_CONTEXT );
mmesa->hw.stencilctl &= (SC_sfailop_MASK & SC_szfailop_MASK
& SC_szpassop_MASK);
mmesa->hw.stencilctl |= stencilctl;
}
static void mgaDDBlendFuncSeparate( GLcontext *ctx, GLenum sfactorRGB,
GLenum dfactorRGB, GLenum sfactorA,
GLenum dfactorA )
{
mgaContextPtr mmesa = MGA_CONTEXT(ctx);
GLuint src;
GLuint dst;
switch (ctx->Color.BlendSrcRGB) {
case GL_ZERO:
src = AC_src_zero; break;
case GL_SRC_ALPHA:
src = AC_src_src_alpha; break;
case GL_ONE:
default: /* never happens */
src = AC_src_one; break;
case GL_DST_COLOR:
src = AC_src_dst_color; break;
case GL_ONE_MINUS_DST_COLOR:
src = AC_src_om_dst_color; break;
case GL_ONE_MINUS_SRC_ALPHA:
src = AC_src_om_src_alpha; break;
case GL_DST_ALPHA:
src = (ctx->Visual.alphaBits > 0)
? AC_src_dst_alpha : AC_src_one;
break;
case GL_ONE_MINUS_DST_ALPHA:
src = (ctx->Visual.alphaBits > 0)
? AC_src_om_dst_alpha : AC_src_zero;
break;
case GL_SRC_ALPHA_SATURATE:
src = (ctx->Visual.alphaBits > 0)
? AC_src_src_alpha_sat : AC_src_zero;
break;
}
switch (ctx->Color.BlendDstRGB) {
case GL_SRC_ALPHA:
dst = AC_dst_src_alpha; break;
case GL_ONE_MINUS_SRC_ALPHA:
dst = AC_dst_om_src_alpha; break;
default: /* never happens */
case GL_ZERO:
dst = AC_dst_zero; break;
case GL_ONE:
dst = AC_dst_one; break;
case GL_SRC_COLOR:
dst = AC_dst_src_color; break;
case GL_ONE_MINUS_SRC_COLOR:
dst = AC_dst_om_src_color; break;
case GL_DST_ALPHA:
dst = (ctx->Visual.alphaBits > 0)
? AC_dst_dst_alpha : AC_dst_one;
break;
case GL_ONE_MINUS_DST_ALPHA:
dst = (ctx->Visual.alphaBits > 0)
? AC_dst_om_dst_alpha : AC_dst_zero;
break;
}
MGA_STATECHANGE( mmesa, MGA_UPLOAD_CONTEXT );
mmesa->hw.blend_func = (src | dst);
FALLBACK( ctx, MGA_FALLBACK_BLEND,
ctx->Color.BlendEnabled && !ctx->Color._LogicOpEnabled &&
mmesa->hw.blend_func == (AC_src_src_alpha_sat | AC_dst_zero) );
}