savagestate.c

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

	imesa->oldRegs.ui[i] = imesa->regs.ui[i];
    if (SAVAGE_DEBUG & DEBUG_STATE)
	fprintf (stderr, "Emitting regs 0x%02x-0x%02x\n", first, last);
}
static void savageEmitChangedRegs (savageContextPtr imesa,
				   GLuint first, GLuint last) {
    GLuint i, firstChanged;
    firstChanged = SAVAGE_NR_REGS;
    for (i = first - SAVAGE_FIRST_REG; i <= last - SAVAGE_FIRST_REG; ++i) {
	if (imesa->oldRegs.ui[i] != imesa->regs.ui[i]) {
	    if (firstChanged == SAVAGE_NR_REGS)
		firstChanged = i;
	} else {
	    if (firstChanged != SAVAGE_NR_REGS) {
		savageEmitContiguousRegs (imesa, firstChanged+SAVAGE_FIRST_REG,
					  i-1+SAVAGE_FIRST_REG);
		firstChanged = SAVAGE_NR_REGS;
	    }
	}
    }
    if (firstChanged != SAVAGE_NR_REGS)
	savageEmitContiguousRegs (imesa, firstChanged+SAVAGE_FIRST_REG,
				  last);
}
static void savageEmitChangedRegChunk (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]) {
	    savageEmitContiguousRegs (imesa, first, last);
	    break;
	}
    }
}
static void savageUpdateRegister_s4(savageContextPtr imesa)
{
    /* In case the texture image was changed without changing the
     * texture address as well, we need to force emitting the texture
     * address in order to flush texture cashes. */
    if ((imesa->dirty & SAVAGE_UPLOAD_TEX0) &&
	imesa->oldRegs.s4.texAddr[0].ui == imesa->regs.s4.texAddr[0].ui)
	imesa->oldRegs.s4.texAddr[0].ui = 0xffffffff;
    if ((imesa->dirty & SAVAGE_UPLOAD_TEX1) &&
	imesa->oldRegs.s4.texAddr[1].ui == imesa->regs.s4.texAddr[1].ui)
	imesa->oldRegs.s4.texAddr[1].ui = 0xffffffff;

    /* Fix up watermarks */
    if (imesa->regs.s4.drawLocalCtrl.ni.flushPdDestWrites) {
	imesa->regs.s4.destTexWatermarks.ni.destWriteLow = 0;
	imesa->regs.s4.destTexWatermarks.ni.destFlush = 1;
    } else
	imesa->regs.s4.destTexWatermarks.ni.destWriteLow = S4_DWLO;
    if (imesa->regs.s4.drawLocalCtrl.ni.flushPdZbufWrites)
	imesa->regs.s4.zWatermarks.ni.wLow = 0;
    else
	imesa->regs.s4.zWatermarks.ni.wLow = S4_ZWLO;

    savageEmitChangedRegs (imesa, 0x1e, 0x39);

    imesa->dirty=0;
}
static void savageUpdateRegister_s3d(savageContextPtr imesa)
{
    /* In case the texture image was changed without changing the
     * texture address as well, we need to force emitting the texture
     * address in order to flush texture cashes. */
    if ((imesa->dirty & SAVAGE_UPLOAD_TEX0) &&
	imesa->oldRegs.s3d.texAddr.ui == imesa->regs.s3d.texAddr.ui)
	imesa->oldRegs.s3d.texAddr.ui = 0xffffffff;

    /* Fix up watermarks */
    if (imesa->regs.s3d.drawCtrl.ni.flushPdDestWrites) {
	imesa->regs.s3d.destTexWatermarks.ni.destWriteLow = 0;
	imesa->regs.s3d.destTexWatermarks.ni.destFlush = 1;
    } else
	imesa->regs.s3d.destTexWatermarks.ni.destWriteLow = S3D_DWLO;
    if (imesa->regs.s3d.drawCtrl.ni.flushPdZbufWrites)
	imesa->regs.s3d.zWatermarks.ni.wLow = 0;
    else
	imesa->regs.s3d.zWatermarks.ni.wLow = S3D_ZWLO;


    /* the savage3d uses two contiguous ranges of BCI registers:
     * 0x18-0x1c and 0x20-0x38. Some texture registers need to be
     * emitted in one chunk or we get some funky rendering errors. */
    savageEmitChangedRegs (imesa, 0x18, 0x19);
    savageEmitChangedRegChunk (imesa, 0x1a, 0x1c);
    savageEmitChangedRegs (imesa, 0x20, 0x38);

    imesa->dirty=0;
}


void savageEmitOldState( savageContextPtr imesa )
{
    assert(imesa->cmdBuf.write == imesa->cmdBuf.base);
    if (imesa->savageScreen->chipset >= S3_SAVAGE4) {
	savageEmitOldRegs (imesa, 0x1e, 0x39, GL_TRUE);
    } else {
	savageEmitOldRegs (imesa, 0x18, 0x1c, GL_TRUE);
	savageEmitOldRegs (imesa, 0x20, 0x38, GL_FALSE);
    }
}


/* Push the state into the sarea and/or texture memory.
 */
void savageEmitChangedState( savageContextPtr imesa )
{
    if (SAVAGE_DEBUG & DEBUG_VERBOSE_API)
        savageDDPrintDirty( "\n\n\nsavageEmitHwStateLocked", imesa->dirty );

    if (imesa->dirty)
    {
	if (SAVAGE_DEBUG & DEBUG_VERBOSE_MSG)
	    fprintf (stderr, "... emitting state\n");
	if (imesa->savageScreen->chipset >= S3_SAVAGE4)
	    savageUpdateRegister_s4(imesa);
	else
	    savageUpdateRegister_s3d(imesa);
     }

    imesa->dirty = 0;
}


static void savageDDInitState_s4( savageContextPtr imesa )
{
#if 1
    imesa->regs.s4.destCtrl.ui          = 1<<7;
#endif

    imesa->regs.s4.zBufCtrl.ni.zCmpFunc = CF_Less;
    imesa->regs.s4.zBufCtrl.ni.wToZEn               = GL_TRUE;
    if (imesa->float_depth) {
	imesa->regs.s4.zBufCtrl.ni.zExpOffset =
	    imesa->savageScreen->zpp == 2 ? 16 : 32;
	imesa->regs.s4.zBufCtrl.ni.floatZEn = GL_TRUE;
    } else {
	imesa->regs.s4.zBufCtrl.ni.zExpOffset = 0;
	imesa->regs.s4.zBufCtrl.ni.floatZEn = GL_FALSE;
    }
    imesa->regs.s4.texBlendCtrl[0].ui            = TBC_NoTexMap;
    imesa->regs.s4.texBlendCtrl[1].ui            = TBC_NoTexMap1;
    imesa->regs.s4.drawCtrl0.ui         = 0;
#if 0
    imesa->regs.s4.drawCtrl1.ni.xyOffsetEn = 1;
#endif

    /* Set DestTexWatermarks_31,30 to 01 always.
     *Has no effect if dest. flush is disabled.
     */
#if 0
    imesa->regs.s4.zWatermarks.ui       = 0x12000C04;
    imesa->regs.s4.destTexWatermarks.ui = 0x40200400;
#else
    /*imesa->regs.s4.zWatermarks.ui       = 0x16001808;*/
    imesa->regs.s4.zWatermarks.ni.rLow  = S4_ZRLO;
    imesa->regs.s4.zWatermarks.ni.rHigh = S4_ZRHI;
    imesa->regs.s4.zWatermarks.ni.wLow  = S4_ZWLO;
    imesa->regs.s4.zWatermarks.ni.wHigh = S4_ZWHI;
    /*imesa->regs.s4.destTexWatermarks.ui = 0x4f000000;*/
    imesa->regs.s4.destTexWatermarks.ni.destReadLow   = S4_DRLO;
    imesa->regs.s4.destTexWatermarks.ni.destReadHigh  = S4_DRHI;
    imesa->regs.s4.destTexWatermarks.ni.destWriteLow  = S4_DWLO;
    imesa->regs.s4.destTexWatermarks.ni.destWriteHigh = S4_DWHI;
    imesa->regs.s4.destTexWatermarks.ni.texRead       = S4_TR;
    imesa->regs.s4.destTexWatermarks.ni.destFlush     = 1;
#endif
    imesa->regs.s4.drawCtrl0.ni.dPerfAccelEn = GL_TRUE;

    /* clrCmpAlphaBlendCtrl is needed to get alphatest and
     * alpha blending working properly
     */

    imesa->regs.s4.texCtrl[0].ni.dBias                 = 0x08;
    imesa->regs.s4.texCtrl[1].ni.dBias                 = 0x08;
    imesa->regs.s4.texCtrl[0].ni.texXprEn              = GL_TRUE;
    imesa->regs.s4.texCtrl[1].ni.texXprEn              = GL_TRUE;
    imesa->regs.s4.texCtrl[0].ni.dMax                  = 0x0f;
    imesa->regs.s4.texCtrl[1].ni.dMax                  = 0x0f;
    /* programm a valid tex address, in case texture state is emitted
     * in wrong order. */
    if (imesa->lastTexHeap == 2 && imesa->savageScreen->textureSize[1]) {
	/* AGP textures available */
	imesa->regs.s4.texAddr[0].ui = imesa->savageScreen->textureOffset[1]|3;
	imesa->regs.s4.texAddr[1].ui = imesa->savageScreen->textureOffset[1]|3;
    } else {
	/* no AGP textures available, use local */
	imesa->regs.s4.texAddr[0].ui = imesa->savageScreen->textureOffset[0]|2;
	imesa->regs.s4.texAddr[1].ui = imesa->savageScreen->textureOffset[0]|2;
    }
    imesa->regs.s4.drawLocalCtrl.ni.drawUpdateEn     = GL_TRUE;
    imesa->regs.s4.drawLocalCtrl.ni.srcAlphaMode    = SAM_One;
    imesa->regs.s4.drawLocalCtrl.ni.wrZafterAlphaTst = GL_FALSE;
    imesa->regs.s4.drawLocalCtrl.ni.flushPdZbufWrites= GL_TRUE;
    imesa->regs.s4.drawLocalCtrl.ni.flushPdDestWrites= GL_TRUE;

    imesa->regs.s4.drawLocalCtrl.ni.zUpdateEn= GL_TRUE;
    imesa->regs.s4.drawCtrl1.ni.ditherEn = (
	driQueryOptioni(&imesa->optionCache, "color_reduction") ==
	DRI_CONF_COLOR_REDUCTION_DITHER) ? GL_TRUE : GL_FALSE;
    imesa->regs.s4.drawCtrl1.ni.cullMode             = BCM_None;

    imesa->regs.s4.zBufCtrl.ni.stencilRefVal      = 0x00;

    imesa->regs.s4.stencilCtrl.ni.stencilEn       = GL_FALSE;
    imesa->regs.s4.stencilCtrl.ni.cmpFunc         = CF_Always;
    imesa->regs.s4.stencilCtrl.ni.failOp          = STENCIL_Keep;
    imesa->regs.s4.stencilCtrl.ni.passZfailOp     = STENCIL_Keep;
    imesa->regs.s4.stencilCtrl.ni.passZpassOp     = STENCIL_Keep;
    imesa->regs.s4.stencilCtrl.ni.writeMask       = 0xff;
    imesa->regs.s4.stencilCtrl.ni.readMask        = 0xff;

    imesa->LcsCullMode=BCM_None;
    imesa->regs.s4.texDescr.ni.palSize               = TPS_256;

    /* clear the local registers in the global reg mask */
    imesa->globalRegMask.s4.drawLocalCtrl.ui   = 0;
    imesa->globalRegMask.s4.texPalAddr.ui      = 0;
    imesa->globalRegMask.s4.texCtrl[0].ui      = 0;
    imesa->globalRegMask.s4.texCtrl[1].ui      = 0;
    imesa->globalRegMask.s4.texAddr[0].ui      = 0;
    imesa->globalRegMask.s4.texAddr[1].ui      = 0;
    imesa->globalRegMask.s4.texBlendCtrl[0].ui = 0;
    imesa->globalRegMask.s4.texBlendCtrl[1].ui = 0;
    imesa->globalRegMask.s4.texXprClr.ui       = 0;
    imesa->globalRegMask.s4.texDescr.ui        = 0;
}
static void savageDDInitState_s3d( savageContextPtr imesa )
{
#if 1
    imesa->regs.s3d.destCtrl.ui           = 1<<7;
#endif

    imesa->regs.s3d.zBufCtrl.ni.zCmpFunc  = CF_Less;
#if 0
    imesa->regs.s3d.drawCtrl.ni.xyOffsetEn = 1;
#endif

    /* Set DestTexWatermarks_31,30 to 01 always.
     *Has no effect if dest. flush is disabled.
     */
#if 0
    imesa->regs.s3d.zWatermarks.ui       = 0x12000C04;
    imesa->regs.s3d.destTexWatermarks.ui = 0x40200400;
#else
    /*imesa->regs.s3d.zWatermarks.ui       = 0x16001808;*/
    imesa->regs.s3d.zWatermarks.ni.rLow  = S3D_ZRLO;
    imesa->regs.s3d.zWatermarks.ni.rHigh = S3D_ZRHI;
    imesa->regs.s3d.zWatermarks.ni.wLow  = S3D_ZWLO;
    imesa->regs.s3d.zWatermarks.ni.wHigh = S3D_ZWHI;
    /*imesa->regs.s3d.destTexWatermarks.ui = 0x4f000000;*/
    imesa->regs.s3d.destTexWatermarks.ni.destReadLow   = S3D_DRLO;
    imesa->regs.s3d.destTexWatermarks.ni.destReadHigh  = S3D_DRHI;
    imesa->regs.s3d.destTexWatermarks.ni.destWriteLow  = S3D_DWLO;
    imesa->regs.s3d.destTexWatermarks.ni.destWriteHigh = S3D_DWHI;
    imesa->regs.s3d.destTexWatermarks.ni.texRead       = S3D_TR;
    imesa->regs.s3d.destTexWatermarks.ni.destFlush     = 1;
#endif

    imesa->regs.s3d.texCtrl.ni.dBias          = 0x08;
    imesa->regs.s3d.texCtrl.ni.texXprEn       = GL_TRUE;
    /* texXprEn is needed to get alphatest and alpha blending working
     * properly. However, this makes texels with color texXprClr
     * completely transparent in some texture environment modes. I
     * couldn't find a way to disable this. So choose an arbitrary and
     * improbable color. (0 is a bad choice, makes all black texels
     * transparent.) */
    imesa->regs.s3d.texXprClr.ui              = 0x26ae26ae;
    /* programm a valid tex address, in case texture state is emitted
     * in wrong order. */
    if (imesa->lastTexHeap == 2 && imesa->savageScreen->textureSize[1]) {
	/* AGP textures available */
	imesa->regs.s3d.texAddr.ui = imesa->savageScreen->textureOffset[1]|3;
    } else {
	/* no AGP textures available, use local */
	imesa->regs.s3d.texAddr.ui = imesa->savageScreen->textureOffset[0]|2;
    }

    imesa->regs.s3d.zBufCtrl.ni.drawUpdateEn     = GL_TRUE;
    imesa->regs.s3d.zBufCtrl.ni.wrZafterAlphaTst = GL_FALSE;
    imesa->regs.s3d.zBufCtrl.ni.zUpdateEn        = GL_TRUE;

    imesa->regs.s3d.drawCtrl.ni.srcAlphaMode      = SAM_One;
    imesa->regs.s3d.drawCtrl.ni.flushPdZbufWrites = GL_TRUE;
    imesa->regs.s3d.drawCtrl.ni.flushPdDestWrites = GL_TRUE;

    imesa->regs.s3d.drawCtrl.ni.ditherEn =  (
	driQueryOptioni(&imesa->optionCache, "color_reduction") ==
	DRI_CONF_COLOR_REDUCTION_DITHER) ? GL_TRUE : GL_FALSE;
    imesa->regs.s3d.drawCtrl.ni.cullMode          = BCM_None;

    imesa->LcsCullMode = BCM_None;
    imesa->regs.s3d.texDescr.ni.palSize          = TPS_256;

    /* clear the local registers in the global reg mask */
    imesa->globalRegMask.s3d.texPalAddr.ui = 0;
    imesa->globalRegMask.s3d.texXprClr.ui  = 0;
    imesa->globalRegMask.s3d.texAddr.ui    = 0;
    imesa->globalRegMask.s3d.texDescr.ui   = 0;
    imesa->globalRegMask.s3d.texCtrl.ui    = 0;

    imesa->globalRegMask.s3d.fogCtrl.ui = 0;

    /* drawCtrl is local with some exceptions */
    imesa->globalRegMask.s3d.drawCtrl.ui = 0;
    imesa->globalRegMask.s3d.drawCtrl.ni.cullMode = 0x3;
    imesa->globalRegMask.s3d.drawCtrl.ni.alphaTestCmpFunc = 0x7;
    imesa->globalRegMask.s3d.drawCtrl.ni.alphaTestEn = 0x1;
    imesa->globalRegMask.s3d.drawCtrl.ni.alphaRefVal = 0xff;

    /* zBufCtrl is local with some exceptions */
    imesa->globalRegMask.s3d.zBufCtrl.ui = 0;
    imesa->globalRegMask.s3d.zBufCtrl.ni.zCmpFunc = 0x7;
    imesa->globalRegMask.s3d.zBufCtrl.ni.zBufEn = 0x1;
}
void savageDDInitState( savageContextPtr imesa ) {
    memset (imesa->regs.ui, 0, SAVAGE_NR_REGS*sizeof(u_int32_t));
    memset (imesa->globalRegMask.ui, 0xff, SAVAGE_NR_REGS*sizeof(u_int32_t));
    if (imesa->savageScreen->chipset >= S3_SAVAGE4)
	savageDDInitState_s4 (imesa);
    else
	savageDDInitState_s3d (imesa);

    /*fprintf(stderr,"DBflag:%d\n",imesa->glCtx->Visual->DBflag);*/
    /* zbufoffset and destctrl have the same position and layout on
     * savage4 and savage3d. */
    if (imesa->glCtx->Visual.doubleBufferMode) {
	imesa->IsDouble = GL_TRUE;
	imesa->toggle = TARGET_BACK;
	imesa->regs.s4.destCtrl.ni.offset =
	    imesa->savageScreen->backOffset>>11;
    } else {
	imesa->IsDouble = GL_FALSE;
	imesa->toggle = TARGET_FRONT;
	imesa->regs.s4.destCtrl.ni.offset =
	    imesa->savageScreen->frontOffset>>11;
    }
    if(imesa->savageScreen->cpp == 2) {
        imesa->regs.s4.destCtrl.ni.dstPixFmt = 0;
        imesa->regs.s4.destCtrl.ni.dstWidthInTile =
            (imesa->savageScreen->width+63)>>6;
    } else {
        imesa->regs.s4.destCtrl.ni.dstPixFmt = 1;
        imesa->regs.s4.destCtrl.ni.dstWidthInTile =
            (imesa->savageScreen->width+31)>>5;
    }
    imesa->NotFirstFrame = GL_FALSE;

    imesa->regs.s4.zBufOffset.ni.offset=imesa->savageScreen->depthOffset>>11;
    if(imesa->savageScreen->zpp == 2) {
        imesa->regs.s4.zBufOffset.ni.zBufWidthInTiles = 
            (imesa->savageScreen->width+63)>>6;
        imesa->regs.s4.zBufOffset.ni.zDepthSelect = 0;
    } else {   
        imesa->regs.s4.zBufOffset.ni.zBufWidthInTiles = 
            (imesa->savageScreen->width+31)>>5;
        imesa->regs.s4.zBufOffset.ni.zDepthSelect = 1;      
    }

    memcpy (imesa->oldRegs.ui, imesa->regs.ui, SAVAGE_NR_REGS*sizeof(u_int32_t));

    /* Emit the initial state to the (empty) command buffer. */
    assert (imesa->cmdBuf.write == imesa->cmdBuf.base);
    savageEmitOldState(imesa);
    imesa->cmdBuf.start = imesa->cmdBuf.write;
}


#define INTERESTED (~(NEW_MODELVIEW|NEW_PROJECTION|\
                      NEW_TEXTURE_MATRIX|\
                      NEW_USER_CLIP|NEW_CLIENT_STATE))

static void savageDDInvalidateState( GLcontext *ctx, GLuint new_state )
{
   _swrast_InvalidateState( ctx, new_state );
   _swsetup_InvalidateState( ctx, new_state );
   _vbo_InvalidateState( ctx, new_state );
   _tnl_InvalidateState( ctx, new_state );
   SAVAGE_CONTEXT(ctx)->new_gl_state |= new_state;
}


void savageDDInitStateFuncs(GLcontext *ctx)
{
    ctx->Driver.UpdateState = savageDDInvalidateState;
    ctx->Driver.BlendEquationSeparate = savageDDBlendEquationSeparate;
    ctx->Driver.Fogfv = savageDDFogfv;
    ctx->Driver.Scissor = savageDDScissor;
#if HW_CULL
    ctx->Driver.CullFace = savageDDCullFaceFrontFace;
    ctx->Driver.FrontFace = savageDDCullFaceFrontFace;
#else
    ctx->Driver.CullFace = 0;
    ctx->Driver.FrontFace = 0;
#endif /* end #if HW_CULL */
    ctx->Driver.DrawBuffer = savageDDDrawBuffer;
    ctx->Driver.ReadBuffer = savageDDReadBuffer;
    ctx->Driver.ClearColor = savageDDClearColor;

    ctx->Driver.DepthRange = savageDepthRange;
    ctx->Driver.Viewport = savageViewport;
    ctx->Driver.RenderMode = savageRenderMode;

    if (SAVAGE_CONTEXT( ctx )->savageScreen->chipset >= S3_SAVAGE4) {
	ctx->Driver.Enable = savageDDEnable_s4;
	ctx->Driver.AlphaFunc = savageDDAlphaFunc_s4;
	ctx->Driver.DepthFunc = savageDDDepthFunc_s4;
	ctx->Driver.DepthMask = savageDDDepthMask_s4;
	ctx->Driver.BlendFuncSeparate = savageDDBlendFuncSeparate_s4;
	ctx->Driver.ColorMask = savageDDColorMask_s4;
	ctx->Driver.ShadeModel = savageDDShadeModel_s4;
	ctx->Driver.LightModelfv = savageDDLightModelfv_s4;
	ctx->Driver.StencilFuncSeparate = savageDDStencilFuncSeparate;
	ctx->Driver.StencilMaskSeparate = savageDDStencilMaskSeparate;
	ctx->Driver.StencilOpSeparate = savageDDStencilOpSeparate;
    } else {
	ctx->Driver.Enable = savageDDEnable_s3d;
	ctx->Driver.AlphaFunc = savageDDAlphaFunc_s3d;
	ctx->Driver.DepthFunc = savageDDDepthFunc_s3d;
	ctx->Driver.DepthMask = savageDDDepthMask_s3d;
	ctx->Driver.BlendFuncSeparate = savageDDBlendFuncSeparate_s3d;
	ctx->Driver.ColorMask = savageDDColorMask_s3d;
	ctx->Driver.ShadeModel = savageDDShadeModel_s3d;
	ctx->Driver.LightModelfv = savageDDLightModelfv_s3d;
	ctx->Driver.StencilFuncSeparate = NULL;
	ctx->Driver.StencilMaskSeparate = NULL;
	ctx->Driver.StencilOpSeparate = NULL;
    }
}