savagestate.c

Mesa is an open-source implementation of the OpenGL specification - a system for rendering interacti

static void savageUpdateSpecular_s4(GLcontext *ctx) {
    savageContextPtr imesa = SAVAGE_CONTEXT( ctx );
    u_int32_t drawLocalCtrl = imesa->regs.s4.drawLocalCtrl.ui;

    if (NEED_SECONDARY_COLOR(ctx)) {
	imesa->regs.s4.drawLocalCtrl.ni.specShadeEn = GL_TRUE;
    } else {
	imesa->regs.s4.drawLocalCtrl.ni.specShadeEn = GL_FALSE;
    }

    if (drawLocalCtrl != imesa->regs.s4.drawLocalCtrl.ui)
	imesa->dirty |= SAVAGE_UPLOAD_LOCAL;
}

static void savageUpdateSpecular_s3d(GLcontext *ctx) {
    savageContextPtr imesa = SAVAGE_CONTEXT( ctx );
    u_int32_t drawCtrl = imesa->regs.s3d.drawCtrl.ui;

    if (NEED_SECONDARY_COLOR(ctx)) {
	imesa->regs.s3d.drawCtrl.ni.specShadeEn = GL_TRUE;
    } else {
	imesa->regs.s3d.drawCtrl.ni.specShadeEn = GL_FALSE;
    }

    if (drawCtrl != imesa->regs.s3d.drawCtrl.ui)
	imesa->dirty |= SAVAGE_UPLOAD_LOCAL;
}

static void savageDDLightModelfv_s4(GLcontext *ctx, GLenum pname, 
				    const GLfloat *param)
{
    savageUpdateSpecular_s4 (ctx);
}
static void savageDDLightModelfv_s3d(GLcontext *ctx, GLenum pname, 
				     const GLfloat *param)
{
    savageUpdateSpecular_s3d (ctx);
}

static void savageDDShadeModel_s4(GLcontext *ctx, GLuint mod)
{
    savageContextPtr imesa = SAVAGE_CONTEXT( ctx );
    u_int32_t drawLocalCtrl = imesa->regs.s4.drawLocalCtrl.ui;

    if (mod == GL_SMOOTH)  
    {    
	imesa->regs.s4.drawLocalCtrl.ni.flatShadeEn = GL_FALSE;
    }
    else
    {
	imesa->regs.s4.drawLocalCtrl.ni.flatShadeEn = GL_TRUE;
    }

    if (drawLocalCtrl != imesa->regs.s4.drawLocalCtrl.ui)
	imesa->dirty |= SAVAGE_UPLOAD_LOCAL;
}
static void savageDDShadeModel_s3d(GLcontext *ctx, GLuint mod)
{
    savageContextPtr imesa = SAVAGE_CONTEXT( ctx );
    u_int32_t drawCtrl = imesa->regs.s3d.drawCtrl.ui;

    if (mod == GL_SMOOTH)  
    {    
	imesa->regs.s3d.drawCtrl.ni.flatShadeEn = GL_FALSE;
    }
    else
    {
	imesa->regs.s3d.drawCtrl.ni.flatShadeEn = GL_TRUE;
    }

    if (drawCtrl != imesa->regs.s3d.drawCtrl.ui)
	imesa->dirty |= SAVAGE_UPLOAD_LOCAL;
}


/* =============================================================
 * Fog
 * The fogCtrl register has the same position and the same layout
 * on savage3d and savage4. No need for two separate functions.
 */

static void savageDDFogfv(GLcontext *ctx, GLenum pname, const GLfloat *param)
{
    savageContextPtr imesa = SAVAGE_CONTEXT(ctx);
    GLuint  fogClr;
    u_int32_t fogCtrl = imesa->regs.s4.fogCtrl.ui;

    /*if ((ctx->Fog.Enabled) &&(pname == GL_FOG_COLOR))*/
    if (ctx->Fog.Enabled)
    {
        fogClr = (((GLubyte)(ctx->Fog.Color[0]*255.0F) << 16) |
                  ((GLubyte)(ctx->Fog.Color[1]*255.0F) << 8) |
                  ((GLubyte)(ctx->Fog.Color[2]*255.0F) << 0));
	imesa->regs.s4.fogCtrl.ni.fogEn  = GL_TRUE;
        /*cheap fog*/
	imesa->regs.s4.fogCtrl.ni.fogMode  = GL_TRUE;
	imesa->regs.s4.fogCtrl.ni.fogClr = fogClr;    
    }    
    else
    {
        /*No fog*/
        
	imesa->regs.s4.fogCtrl.ni.fogEn     = 0;
	imesa->regs.s4.fogCtrl.ni.fogMode   = 0;
    }

    if (fogCtrl != imesa->regs.s4.fogCtrl.ui)
	imesa->dirty |= SAVAGE_UPLOAD_GLOBAL;
}


static void
savageDDStencilFuncSeparate(GLcontext *ctx, GLenum face, GLenum func,
                            GLint ref, GLuint mask)
{
    savageContextPtr imesa = SAVAGE_CONTEXT(ctx);
    unsigned a=0;
    const u_int32_t zBufCtrl = imesa->regs.s4.zBufCtrl.ui;
    const u_int32_t stencilCtrl = imesa->regs.s4.stencilCtrl.ui;

    imesa->regs.s4.zBufCtrl.ni.stencilRefVal = ctx->Stencil.Ref[0] & 0xff;
    imesa->regs.s4.stencilCtrl.ni.readMask  = ctx->Stencil.ValueMask[0] & 0xff;

    switch (ctx->Stencil.Function[0])
    {
    case GL_NEVER: a = CF_Never; break;
    case GL_ALWAYS: a = CF_Always; break;
    case GL_LESS: a = CF_Less; break; 
    case GL_LEQUAL: a = CF_LessEqual; break;
    case GL_EQUAL: a = CF_Equal; break;
    case GL_GREATER: a = CF_Greater; break;
    case GL_GEQUAL: a = CF_GreaterEqual; break;
    case GL_NOTEQUAL: a = CF_NotEqual; break;
    default:
        break;
    }

    imesa->regs.s4.stencilCtrl.ni.cmpFunc = a;

    if (zBufCtrl != imesa->regs.s4.zBufCtrl.ui ||
	stencilCtrl != imesa->regs.s4.stencilCtrl.ui)
	imesa->dirty |= SAVAGE_UPLOAD_GLOBAL;
}

static void
savageDDStencilMaskSeparate(GLcontext *ctx, GLenum face, GLuint mask)
{
    savageContextPtr imesa = SAVAGE_CONTEXT(ctx);

    if (imesa->regs.s4.stencilCtrl.ni.writeMask != (ctx->Stencil.WriteMask[0] & 0xff)) {
	imesa->regs.s4.stencilCtrl.ni.writeMask = (ctx->Stencil.WriteMask[0] & 0xff);
	imesa->dirty |= SAVAGE_UPLOAD_GLOBAL;
    }
}

static unsigned get_stencil_op_value( GLenum op )
{
    switch (op)
    {
    case GL_KEEP:      return STENCIL_Keep;
    case GL_ZERO:      return STENCIL_Zero;
    case GL_REPLACE:   return STENCIL_Equal;
    case GL_INCR:      return STENCIL_IncClamp;
    case GL_DECR:      return STENCIL_DecClamp;
    case GL_INVERT:    return STENCIL_Invert;
    case GL_INCR_WRAP: return STENCIL_Inc;
    case GL_DECR_WRAP: return STENCIL_Dec;
    }

    /* Should *never* get here. */
    return STENCIL_Keep;
}

static void
savageDDStencilOpSeparate(GLcontext *ctx, GLenum face, GLenum fail,
                          GLenum zfail, GLenum zpass)
{
    savageContextPtr imesa = SAVAGE_CONTEXT(ctx);
    const u_int32_t stencilCtrl = imesa->regs.s4.stencilCtrl.ui;

    imesa->regs.s4.stencilCtrl.ni.failOp = get_stencil_op_value( ctx->Stencil.FailFunc[0] );
    imesa->regs.s4.stencilCtrl.ni.passZfailOp = get_stencil_op_value( ctx->Stencil.ZFailFunc[0] );
    imesa->regs.s4.stencilCtrl.ni.passZpassOp = get_stencil_op_value( ctx->Stencil.ZPassFunc[0] );

    if (stencilCtrl != imesa->regs.s4.stencilCtrl.ui)
	imesa->dirty |= SAVAGE_UPLOAD_GLOBAL;
}


/* =============================================================
 */

static void savageDDEnable_s4(GLcontext *ctx, GLenum cap, GLboolean state)
{
   
    savageContextPtr imesa = SAVAGE_CONTEXT(ctx);
    switch(cap) {
        case GL_ALPHA_TEST:
            /* we should consider the disable case*/
            savageBlendFunc_s4(ctx);
            break;
        case GL_BLEND:
            /*add the savageBlendFunc 2001/11/25
             * if call no such function, then glDisable(GL_BLEND) will do noting,
             *our chip has no disable bit
             */ 
            savageBlendFunc_s4(ctx);
        case GL_COLOR_LOGIC_OP:
            /* Fall through: 
	     * For some reason enable(GL_BLEND) affects ColorLogicOpEnabled.
             */
	    FALLBACK (ctx, SAVAGE_FALLBACK_LOGICOP,
		      (ctx->Color.ColorLogicOpEnabled &&
		       ctx->Color.LogicOp != GL_COPY));
            break;
        case GL_DEPTH_TEST:
            savageDDDepthFunc_s4(ctx,ctx->Depth.Func);
            break;
        case GL_SCISSOR_TEST:
	    savageDDScissor(ctx, ctx->Scissor.X, ctx->Scissor.Y,
			    ctx->Scissor.Width, ctx->Scissor.Height);
            break;
        case GL_STENCIL_TEST:
	    if (!imesa->hw_stencil)
		FALLBACK (ctx, SAVAGE_FALLBACK_STENCIL, state);
	    else {
		imesa->regs.s4.stencilCtrl.ni.stencilEn = state;
		if (ctx->Stencil.Enabled &&
		    imesa->regs.s4.zBufCtrl.ni.zBufEn != GL_TRUE)
		{
		    /* Stencil buffer requires Z enabled. */
		    imesa->regs.s4.zBufCtrl.ni.zCmpFunc       = CF_Always;
		    imesa->regs.s4.zBufCtrl.ni.zBufEn         = GL_TRUE;
		    imesa->regs.s4.drawLocalCtrl.ni.zUpdateEn = GL_FALSE;
		}
		imesa->dirty |= SAVAGE_UPLOAD_GLOBAL | SAVAGE_UPLOAD_LOCAL;
	    }
            break;
        case GL_FOG:
            savageDDFogfv(ctx,0,0);	
            break;
        case GL_CULL_FACE:
#if HW_CULL
            if (state)
            {
                savageDDCullFaceFrontFace(ctx,0);
            }
            else
            {
		imesa->LcsCullMode = BCM_None;
		imesa->new_state |= SAVAGE_NEW_CULL;
            }
#endif
            break;
        case GL_DITHER:
            if (state)
            {
                if ( ctx->Color.DitherFlag )
                {
                    imesa->regs.s4.drawCtrl1.ni.ditherEn=GL_TRUE;
                }
            }   
            if (!ctx->Color.DitherFlag )
            {
                imesa->regs.s4.drawCtrl1.ni.ditherEn=GL_FALSE;
            }
            imesa->dirty |= SAVAGE_UPLOAD_GLOBAL;
            break;
 
        case GL_LIGHTING:
	    savageUpdateSpecular_s4 (ctx);
            break;
        case GL_TEXTURE_1D:      
        case GL_TEXTURE_3D:      
            imesa->new_state |= SAVAGE_NEW_TEXTURE;
            break;
        case GL_TEXTURE_2D:      
            imesa->new_state |= SAVAGE_NEW_TEXTURE;
            break;
        default:
            ; 
    }    
}
static void savageDDEnable_s3d(GLcontext *ctx, GLenum cap, GLboolean state)
{
   
    savageContextPtr imesa = SAVAGE_CONTEXT(ctx);
    switch(cap) {
        case GL_ALPHA_TEST:
            /* we should consider the disable case*/
            savageBlendFunc_s3d(ctx);
            break;
        case GL_BLEND:
            /*add the savageBlendFunc 2001/11/25
             * if call no such function, then glDisable(GL_BLEND) will do noting,
             *our chip has no disable bit
             */ 
            savageBlendFunc_s3d(ctx);
        case GL_COLOR_LOGIC_OP:
            /* Fall through: 
	     * For some reason enable(GL_BLEND) affects ColorLogicOpEnabled.
             */
	    FALLBACK (ctx, SAVAGE_FALLBACK_LOGICOP,
		      (ctx->Color.ColorLogicOpEnabled &&
		       ctx->Color.LogicOp != GL_COPY));
            break;
        case GL_DEPTH_TEST:
            savageDDDepthFunc_s3d(ctx,ctx->Depth.Func);
            break;
        case GL_SCISSOR_TEST:
	    savageDDScissor(ctx, ctx->Scissor.X, ctx->Scissor.Y,
			    ctx->Scissor.Width, ctx->Scissor.Height);
            break;
        case GL_STENCIL_TEST:
	    FALLBACK (ctx, SAVAGE_FALLBACK_STENCIL, state);
	    break;
        case GL_FOG:
            savageDDFogfv(ctx,0,0);	
            break;
        case GL_CULL_FACE:
#if HW_CULL
            if (state)
            {
                savageDDCullFaceFrontFace(ctx,0);
            }
            else
            {
                imesa->LcsCullMode = BCM_None;
		imesa->new_state |= SAVAGE_NEW_CULL;
            }
#endif
            break;
        case GL_DITHER:
            if (state)
            {
                if ( ctx->Color.DitherFlag )
                {
                    imesa->regs.s3d.drawCtrl.ni.ditherEn=GL_TRUE;
                }
            }
            if (!ctx->Color.DitherFlag )
            {
                imesa->regs.s3d.drawCtrl.ni.ditherEn=GL_FALSE;
            }
            imesa->dirty |= SAVAGE_UPLOAD_LOCAL;
            break;
 
        case GL_LIGHTING:
	    savageUpdateSpecular_s3d (ctx);
            break;
        case GL_TEXTURE_1D:      
        case GL_TEXTURE_3D:      
            imesa->new_state |= SAVAGE_NEW_TEXTURE;
            break;
        case GL_TEXTURE_2D:      
            imesa->new_state |= SAVAGE_NEW_TEXTURE;
            break;
        default:
            ; 
    }    
}

void savageDDUpdateHwState( GLcontext *ctx )
{
    savageContextPtr imesa = SAVAGE_CONTEXT(ctx);

    if (imesa->new_state) {
	savageFlushVertices(imesa);
	if (imesa->new_state & SAVAGE_NEW_TEXTURE) {
	    savageUpdateTextureState( ctx );
	}
	if ((imesa->new_state & SAVAGE_NEW_CULL)) {
	    savageUpdateCull(ctx);
	}
	imesa->new_state = 0;
    }
}


static void savageDDPrintDirty( const char *msg, GLuint state )
{
    fprintf(stderr, "%s (0x%x): %s%s%s%s%s%s\n",	   
            msg,
            (unsigned int) state,
            (state & SAVAGE_UPLOAD_LOCAL)      ? "upload-local, " : "",
            (state & SAVAGE_UPLOAD_TEX0)       ? "upload-tex0, " : "",
            (state & SAVAGE_UPLOAD_TEX1)       ? "upload-tex1, " : "",
            (state & SAVAGE_UPLOAD_FOGTBL)     ? "upload-fogtbl, " : "",
            (state & SAVAGE_UPLOAD_GLOBAL)     ? "upload-global, " : "",
            (state & SAVAGE_UPLOAD_TEXGLOBAL)  ? "upload-texglobal, " : ""
            );
}


/**
 * Check if global registers were changed
 */
static GLboolean savageGlobalRegChanged (savageContextPtr imesa,
					 GLuint first, GLuint last) {
    GLuint i;
    for (i = first - SAVAGE_FIRST_REG; i <= last - SAVAGE_FIRST_REG; ++i) {
	if (((imesa->oldRegs.ui[i] ^ imesa->regs.ui[i]) &
	     imesa->globalRegMask.ui[i]) != 0)
	    return GL_TRUE;
    }
    return GL_FALSE;
}
static void savageEmitOldRegs (savageContextPtr imesa,
			       GLuint first, GLuint last, GLboolean global) {
    GLuint n = last-first+1;
    drm_savage_cmd_header_t *cmd = savageAllocCmdBuf(imesa, n*4);
    cmd->state.cmd = SAVAGE_CMD_STATE;
    cmd->state.global = global;
    cmd->state.count = n;
    cmd->state.start = first;
    memcpy(cmd+1, &imesa->oldRegs.ui[first-SAVAGE_FIRST_REG], n*4);
}
static void savageEmitContiguousRegs (savageContextPtr imesa,
				      GLuint first, GLuint last) {
    GLuint i;
    GLuint n = last-first+1;
    drm_savage_cmd_header_t *cmd = savageAllocCmdBuf(imesa, n*4);
    cmd->state.cmd = SAVAGE_CMD_STATE;
    cmd->state.global = savageGlobalRegChanged(imesa, first, last);
    cmd->state.count = n;
    cmd->state.start = first;
    memcpy(cmd+1, &imesa->regs.ui[first-SAVAGE_FIRST_REG], n*4);
    /* savageAllocCmdBuf may need to flush the cmd buffer and backup
     * the current hardware state. It should see the "old" (current)
     * state that has actually been emitted to the hardware. Therefore
     * this update is done *after* savageAllocCmdBuf. */
    for (i = first - SAVAGE_FIRST_REG; i <= last - SAVAGE_FIRST_REG; ++i)