windows-server-2003/multimedia/directx/dxg/d3d/dx6/rast/spaninit/spaninit.mcp

//-----------------------------------------------------------------------------
//
// This file contains the span state validation function.
//
// Copyright (C) Microsoft Corporation, 1997.
//
//-----------------------------------------------------------------------------

#include "pch.cpp"
#pragma hdrstop

include(`bead.mh')
include(`rampbead.mh')
#include "BdStr_mh.h"
#include "RastCap.h"
#include "RastColl.h"
#include "RampOld.h"

static CRastCollection g_RastCollection;

UINT16 g_uDitherTable[16] =
{
    0x00,   0x80,   0x20,   0xa0,
    0xc0,   0x40,   0xe0,   0x60,
    0x30,   0xb0,   0x10,   0x90,
    0xf0,   0x70,   0xd0,   0x50
};

//-----------------------------------------------------------------------------
//
// DoZCompareSetup
//
// Initializes arithmetic Z compare state based on the Z test function.
//
//-----------------------------------------------------------------------------
void DoZCompareSetup(PD3DI_RASTCTX pCtx, BOOL bIsMMX)
{
    INT32 iXorMask;
    if (bIsMMX)
    {
        iXorMask = -1;
    }
    else
    {
        iXorMask = 1;
    }
    D3DCMPFUNC ZFunc = (D3DCMPFUNC)pCtx->pdwRenderState[D3DRENDERSTATE_ZFUNC];
    if (!pCtx->pdwRenderState[D3DRENDERSTATE_ZENABLE])
    {
        // setup ALWAYS if Z is not enabled, since we may be going into
        // the test beads for other reasons (like stencil)
        ZFunc = D3DCMP_ALWAYS;
    }
    switch (ZFunc)
    {
    case D3DCMP_NEVER:
        pCtx->iZAndMask = 0; pCtx->iZNeg = 0; pCtx->iZXorMask = iXorMask;
        break;
    case D3DCMP_ALWAYS:
        pCtx->iZAndMask = 0; pCtx->iZNeg = 0; pCtx->iZXorMask = 0;
        break;

    case D3DCMP_LESS:
        pCtx->iZAndMask = ~0; pCtx->iZNeg = 0; pCtx->iZXorMask = iXorMask;
        break;
    case D3DCMP_GREATEREQUAL:
        pCtx->iZAndMask = ~0; pCtx->iZNeg = 0; pCtx->iZXorMask = 0;
        break;

    case D3DCMP_EQUAL:
        pCtx->iZAndMask = 0x7fffffff; pCtx->iZNeg = 1; pCtx->iZXorMask =
            iXorMask;
        break;
    case D3DCMP_NOTEQUAL:
        pCtx->iZAndMask = 0x7fffffff; pCtx->iZNeg = 1; pCtx->iZXorMask = 0;
        break;

    default:
    case D3DCMP_LESSEQUAL:
        pCtx->iZAndMask = ~0; pCtx->iZNeg = 1; pCtx->iZXorMask = iXorMask;
        break;
    case D3DCMP_GREATER:
        pCtx->iZAndMask = ~0; pCtx->iZNeg = 1; pCtx->iZXorMask = 0;
        break;
    }

    if (bIsMMX)
    {
        pCtx->iZXorMask = ~pCtx->iZXorMask;
    }

}

//-----------------------------------------------------------------------------
//
// DoACompareSetup
//
// Initializes arithmetic alpha compare state based on the alpha test function.
//
//-----------------------------------------------------------------------------
void DoACompareSetup(PD3DI_RASTCTX pCtx, BOOL bIsMMX)
{
    INT32 iXorMask;
    if (bIsMMX)
    {
        iXorMask = -1;
    }
    else
    {
        iXorMask = 1;
    }
    switch ((D3DCMPFUNC)pCtx->pdwRenderState[D3DRENDERSTATE_ALPHAFUNC])
    {
    case D3DCMP_NEVER:
        pCtx->iAAndMask = 0; pCtx->iANeg = 0; pCtx->iAXorMask = iXorMask;
        break;
    default:
    case D3DCMP_ALWAYS:
        pCtx->iAAndMask = 0; pCtx->iANeg = 0; pCtx->iAXorMask = 0;
        break;

    case D3DCMP_LESS:
        pCtx->iAAndMask = ~0; pCtx->iANeg = 0; pCtx->iAXorMask = iXorMask;
        break;
    case D3DCMP_GREATEREQUAL:
        pCtx->iAAndMask = ~0; pCtx->iANeg = 0; pCtx->iAXorMask = 0;
        break;

    case D3DCMP_EQUAL:
        pCtx->iAAndMask = 0x7fffffff; pCtx->iANeg = 1; pCtx->iAXorMask =
            iXorMask;
        break;
    case D3DCMP_NOTEQUAL:
        pCtx->iAAndMask = 0x7fffffff; pCtx->iANeg = 1; pCtx->iAXorMask = 0;
        break;

    case D3DCMP_LESSEQUAL:
        pCtx->iAAndMask = ~0; pCtx->iANeg = 1; pCtx->iAXorMask = iXorMask;
        break;
    case D3DCMP_GREATER:
        pCtx->iAAndMask = ~0; pCtx->iANeg = 1; pCtx->iAXorMask = 0;
        break;
    }

    if (bIsMMX)
    {
        pCtx->iAXorMask = ~pCtx->iAXorMask;
    }

    // iARef is an 8.8 ALPHAREF value for use by RGB and MMX.
    // D3DRENDERSTATE_ALPHAREF is now an 8 bit (0xff max) value.
    pCtx->iARef = pCtx->pdwRenderState[D3DRENDERSTATE_ALPHAREF] << 8;
}

//-----------------------------------------------------------------------------
//
// DoSCompareSetup
//
// Initializes arithmetic stencil compare state based on the stencil function.
//
//-----------------------------------------------------------------------------
void DoSCompareSetup(PD3DI_RASTCTX pCtx, BOOL bIsMMX)
{
    INT32 iXorMask;
    if (bIsMMX)
    {
        iXorMask = -1;
    }
    else
    {
        iXorMask = 1;
    }
    switch ((D3DCMPFUNC)pCtx->pdwRenderState[D3DRENDERSTATE_STENCILFUNC])
    {
    case D3DCMP_NEVER:
        pCtx->iSAndMask = 0; pCtx->iSNeg = 0; pCtx->iSXorMask = iXorMask;
        break;
    default:
    case D3DCMP_ALWAYS:
        pCtx->iSAndMask = 0; pCtx->iSNeg = 0; pCtx->iSXorMask = 0;
        break;

    case D3DCMP_LESS:
        pCtx->iSAndMask = ~0; pCtx->iSNeg = 0; pCtx->iSXorMask = iXorMask;
        break;
    case D3DCMP_GREATEREQUAL:
        pCtx->iSAndMask = ~0; pCtx->iSNeg = 0; pCtx->iSXorMask = 0;
        break;

    case D3DCMP_EQUAL:
        pCtx->iSAndMask = 0x7fffffff; pCtx->iSNeg = 1; pCtx->iSXorMask =
            iXorMask;
        break;
    case D3DCMP_NOTEQUAL:
        pCtx->iSAndMask = 0x7fffffff; pCtx->iSNeg = 1; pCtx->iSXorMask = 0;
        break;

    case D3DCMP_LESSEQUAL:
        pCtx->iSAndMask = ~0; pCtx->iSNeg = 1; pCtx->iSXorMask = iXorMask;
        break;
    case D3DCMP_GREATER:
        pCtx->iSAndMask = ~0; pCtx->iSNeg = 1; pCtx->iSXorMask = 0;
        break;
    }
    if (bIsMMX)
    {
        pCtx->iSXorMask = ~pCtx->iSXorMask;
    }

}

//-----------------------------------------------------------------------------
//
// DoTexAddrSetup
//
// Initializes arithmetic texture address state state based on the texture
// address function.  iTex is the texure to setup.
//
//-----------------------------------------------------------------------------
void DoTexAddrSetup(PD3DI_RASTCTX pCtx, INT32 iTex)
{
    PD3DI_SPANTEX pTex = pCtx->pTexture[iTex];

    // Note that it is essential to turn on mirroring when in CLAMP/BORDER mode
    // to avoid filtering artifacts at the edge of the texture
    switch (pTex->TexAddrU)
    {
        default:
        case D3DTADDRESS_WRAP:
            pTex->iFlipMaskU = 0; pTex->iClampMinU = 0;
            pTex->iClampMaxU = 0; pTex->iClampEnU = 0; break;
        case D3DTADDRESS_MIRROR:
            pTex->iFlipMaskU = pTex->uMaskU+1; pTex->iClampMinU = 0;
            pTex->iClampMaxU = 0; pTex->iClampEnU = 0; break;
        case D3DTADDRESS_CLAMP:
            pTex->iFlipMaskU = pTex->uMaskU+1; pTex->iClampMinU = 0;
            pTex->iClampMaxU = pTex->uMaskU; pTex->iClampEnU = -1; break;
        case D3DTADDRESS_BORDER:
            pTex->iFlipMaskU = pTex->uMaskU+1; pTex->iClampMinU = -1;
            pTex->iClampMaxU = -1; pTex->iClampEnU = -1; break;
    }
    switch (pTex->TexAddrV)
    {
        default:
        case D3DTADDRESS_WRAP:
            pTex->iFlipMaskV = 0; pTex->iClampMinV = 0;
            pTex->iClampMaxV = 0; pTex->iClampEnV = 0; break;
        case D3DTADDRESS_MIRROR:
            pTex->iFlipMaskV = pTex->uMaskV+1; pTex->iClampMinV = 0;
            pTex->iClampMaxV = 0; pTex->iClampEnV = 0; break;
        case D3DTADDRESS_CLAMP:
            pTex->iFlipMaskV = pTex->uMaskV+1; pTex->iClampMinV = 0;
            pTex->iClampMaxV = pTex->uMaskV; pTex->iClampEnV = -1; break;
        case D3DTADDRESS_BORDER:
            pTex->iFlipMaskV = pTex->uMaskV+1; pTex->iClampMinV = -1;
            pTex->iClampMaxV = -1; pTex->iClampEnV = -1; break;
    }
}

// CMMX is no longer linked in
// extern BEADTABLE g_CMMX_BeadTbl;

extern BEADTABLE g_C_BeadTbl;

#ifdef _X86_
extern BEADTABLE g_MMX_BeadTbl;
#else
BEADTABLE g_MMX_BeadTbl = g_C_BeadTbl;
#endif

extern RAMPBEADTABLE g_Ramp_BeadTbl;
HRESULT RampSpanInit(PD3DI_RASTCTX pCtx, PRAMPBEADTABLE pRBT);
extern void Ramp_InitBeadTbl(void);

#if DBG
#define RANGE_CHECK(val,max)    DDASSERT(((val) >= 0) && ((val) < (max)))
#else
#define RANGE_CHECK(val,max)
#endif

#undef DPF_MODNAME
#define DPF_MODNAME "SpanInit"

//-----------------------------------------------------------------------------
//
// SpanInit
//
// Initializes derived state (function pointers and arithmetic compare values)
// based on the render state, surface type, etc.
//
//-----------------------------------------------------------------------------
HRESULT SpanInit(PD3DI_RASTCTX pCtx)
{
    int iZTest,
        iZFormat,
        iZWrite,
        iZFunc,
        iZDeferred,
        iStencil,
        iAlphaTest,
        iShadeMode,
        iSpecular,
        iVertexFog,
        iTexture,
        iTextureAddr[2],
        iTextureBorder[2],
        iTexturePerspective,
        iTextureFilter[2],
        iTextureMip[2],
        iTextureLOD[2],
        iTextureFormat[2],
        iTextureColorKey[2],
        iTextureBlend,
        iTextureAlphaOverride[2],
        iMono,
        iAlphaBlend,
        iAlphaDither[2],
        iBlend,
        iROP,
        iSrcBlend,
        iDestBlend,
        iTargetPixelFormat,
        iDither;
    PFNRENDERSPANS  pfnRenderSpans;
    PFNSPANLAYER    pfnTex1Addr,
                    pfnTex2Addr,
                    pfnColorBlend,
                    pfnColorGen;
    PBEADTABLE      pBeadTable;
    CRastCapRecord  RastCapRec;

#if DBG
    if (SPIGETFLAGS(DBG_USER_FLAGS) & SPIU_BREAK_ON_SPANINIT)
    {
        DebugBreak();
    }
#endif
    // make sure this is always NULL unless it is valid
    pCtx->pfnRampOld = NULL;

    switch (pCtx->BeadSet)
    {
#ifdef _X86_
//    Uncomment these (and comment out cases below) to test MMX on legacy code
//    case D3DIBS_CMMX:
//    case D3DIBS_C:
    case D3DIBS_MMXASRGB:   // this is only different in pCtx->BeadSet for identification
    case D3DIBS_MMX:
        pBeadTable = &g_MMX_BeadTbl;
        break;
#endif
    default:
        SPIDPFM((SPIM_INVALID,"Invalid BeadSet %d\n",
            pCtx->BeadSet));
        // fall through
    case D3DIBS_CMMX:       // CMMX code is no longer used, make this behave the same as C
    case D3DIBS_C:
        pBeadTable = &g_C_BeadTbl;
        break;
    case D3DIBS_RAMP:
        return RampSpanInit(pCtx, &g_Ramp_BeadTbl);
        break;
    }

    DoZCompareSetup(pCtx, (pBeadTable == &g_MMX_BeadTbl));
    DoACompareSetup(pCtx, (pBeadTable == &g_MMX_BeadTbl));
    DoSCompareSetup(pCtx, (pBeadTable == &g_MMX_BeadTbl));

    // The function pointers that point to various beads are stored in
    // multi-dimensional arrays.  In order to access the correct bead, we
    // use numerical indices into these arrays.  The indices are either
    // the exact value of the renderstate used to choose the bead, or are
    // values chosen by looking at the value of the renderstate.

    // values needed to choose Test and AlphaTest beads
    iZTest = (pCtx->pdwRenderState[D3DRENDERSTATE_ZENABLE] ||
              pCtx->pdwRenderState[D3DRENDERSTATE_STENCILENABLE]) ? 1 : 0;
    RastCapRec.Set_ZTest(iZTest);
    switch (pCtx->iZBitCount)
    {
    default :
        SPIDPFM((SPIM_INVALID,"Invalid Z surface bit count, iZBitCount == 0x%x\n",
            pCtx->iZBitCount));
    case 0 :
    case 16 :
        iZFormat = 0;
        break;
    case 32 :
        iZFormat = 1;
        break;
    }
    RastCapRec.Set_ZFormat(iZFormat);
    iZWrite = pCtx->pdwRenderState[D3DRENDERSTATE_ZWRITEENABLE] ? 1 : 0;
    RastCapRec.Set_ZWrite(iZWrite);
    switch (pCtx->pdwRenderState[D3DRENDERSTATE_ZFUNC])
    {
    case D3DCMP_NEVER :
    case D3DCMP_ALWAYS :
        iZFunc = 0;
        break;
    case D3DCMP_LESS :
    case D3DCMP_GREATEREQUAL :
        iZFunc = 1;
        break;
    case D3DCMP_EQUAL :
    case D3DCMP_NOTEQUAL :
        iZFunc = 2;
        break;
    default :
        SPIDPFM((SPIM_INVALID,"Invalid renderstate value, D3DRENDERSTATE_ZFUNC == 0x%x\n",
            pCtx->pdwRenderState[D3DRENDERSTATE_ZFUNC]));
    case D3DCMP_LESSEQUAL :
    case D3DCMP_GREATER :
        iZFunc = 3;
        break;
    }
    if (!pCtx->pdwRenderState[D3DRENDERSTATE_ZENABLE])
    {
        // setup ALWAYS if Z is not enabled, since we may be going into
        // the test beads for other reasons (like stencil)
        iZFunc = 0;
        iZWrite = 0;    // do not write iterated Z, but stencil will be written if needed
    }
    RastCapRec.Set_ZFunc(iZFunc);
    // Ignore stipple (D3DRENDERSTATE_STIPPLEENABLE), since no software rasterizers do it.
    RastCapRec.Set_Stipple(0);
    iAlphaTest = pCtx->pdwRenderState[D3DRENDERSTATE_ALPHATESTENABLE] ? 1 : 0;
    RastCapRec.Set_AlphaTest(iAlphaTest);
    iStencil = pCtx->pdwRenderState[D3DRENDERSTATE_STENCILENABLE] ? 1 : 0;
    RastCapRec.Set_Stencil(iStencil);

    // values needed for TestFail, TexAddr1 and ColorGen beads
    switch (pCtx->pdwRenderState[D3DRENDERSTATE_SHADEMODE])
    {
    case D3DSHADE_FLAT :
        iShadeMode = 0;
        break;
    default :
        SPIDPFM((SPIM_INVALID,"Invalid renderstate value, D3DRENDERSTATE_SHADEMODE == 0x%x\n",
            pCtx->pdwRenderState[D3DRENDERSTATE_SHADEMODE]));
    case D3DSHADE_GOURAUD :
    case D3DSHADE_PHONG :
        iShadeMode = 1;
        break;
    }
    RastCapRec.Set_ShadeMode(iShadeMode);
    iSpecular = pCtx->pdwRenderState[D3DRENDERSTATE_SPECULARENABLE] ? 1 : 0;
    RastCapRec.Set_Specular(iSpecular);
    iVertexFog = pCtx->pdwRenderState[D3DRENDERSTATE_FOGENABLE] ? 1 : 0;
    RastCapRec.Set_VertexFog(iVertexFog);

    // are we texturing at all?
    if (pCtx->cActTex == 0) {

        iTexture = 0;
        RastCapRec.Set_Texture(iTexture);
        iTextureBlend = 0;
        RastCapRec.Set_TextureBlend(iTextureBlend);
        iTexturePerspective = 0;
        RastCapRec.Set_TexturePersp(iTexturePerspective);
        iTextureAlphaOverride[0] = 0;
        RastCapRec.Set_TextureAlphaOverride(0, iTextureAlphaOverride[0]);
        iTextureColorKey[0] = 0;
        RastCapRec.Set_TextureColorKey(0, iTextureColorKey[0]);

        if (pCtx->uDevVer >= 1)
        {
            // DX6, DX5 required legacy behavior
            iAlphaDither[0] = pCtx->pdwRenderState[D3DRENDERSTATE_COLORKEYENABLE] ? 1 : 0;
        }
        else
        {
            // DX3, required legacy behavior
            iAlphaDither[0] =
                (pCtx->pdwRenderState[D3DRENDERSTATE_ALPHABLENDENABLE] ? 1 : 0) ||
                (pCtx->pdwRenderState[D3DRENDERSTATE_COLORKEYENABLE] ? 1 : 0);
        }
    } else {
        iTexturePerspective =
            pCtx->pdwRenderState[D3DRENDERSTATE_TEXTUREPERSPECTIVE] ? 1 : 0;
        RastCapRec.Set_TexturePersp(iTexturePerspective);

        if (iTexturePerspective) {
            iTexture = 2;
        } else {
            iTexture = 1;
        }

        // If Multi-texture then iTexture must be incremented by two.  This only effects fail cases.
        if (!(pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(1,D3DTSS_COLOROP)] == D3DTOP_DISABLE))
        {
            iTexture += 2;
        }
        RastCapRec.Set_Texture(iTexture);

        for (INT32 i = 0; i < (INT32)pCtx->cActTex; i++)
        {
            DoTexAddrSetup(pCtx, i);

            // values needed to choose TexAddr1 bead, TexRead routine
            // easiest to deal with border separately
            if ((pCtx->pTexture[i]->TexAddrU == D3DTADDRESS_BORDER) ||
                (pCtx->pTexture[i]->TexAddrV == D3DTADDRESS_BORDER)) {
                iTextureBorder[i] = 1;
            } else {
                iTextureBorder[i] = 0;
            }
            RastCapRec.Set_TextureBorder(i, iTextureBorder[i]);
            switch (pCtx->pTexture[i]->TexAddrU)
            {
            default :
                SPIDPFM((SPIM_INVALID,"Invalid texture address mode, TexAddrU == 0x%x\n",
                    pCtx->pTexture[i]->TexAddrU));
            case D3DTADDRESS_WRAP :
                if ((pCtx->pTexture[i]->TexAddrV == D3DTADDRESS_WRAP) ||
                    (pCtx->pTexture[i]->TexAddrV == D3DTADDRESS_MIRROR)) {
                    iTextureAddr[i] = 0;
                } else {
                    iTextureAddr[i] = 1;
                }
                break;
            case D3DTADDRESS_MIRROR :
                if ((pCtx->pTexture[i]->TexAddrV == D3DTADDRESS_WRAP) ||
                    (pCtx->pTexture[i]->TexAddrV == D3DTADDRESS_MIRROR)) {
                    iTextureAddr[i] = 0;
                } else {
                    iTextureAddr[i] = 1;
                }
                break;
            case D3DTADDRESS_CLAMP :
                iTextureAddr[i] = 1;
                break;
            case D3DTADDRESS_BORDER :
                iTextureAddr[i] = 1;
                break;
            }
            RastCapRec.Set_TextureAddr(i, iTextureAddr[i]);

            if (i >= 1)
            {
                // no LOD info for second texture, just use uMagFilter
                switch (pCtx->pTexture[i]->uMagFilter)
                {
                default :
                    SPIDPFM((SPIM_INVALID,"Invalid texture filter mode, uMagFilter == 0x%x\n",
                        pCtx->pTexture[i]->uMagFilter));
                case D3DTFG_POINT :
                    iTextureFilter[i] = 0;
                    break;
                case D3DTFG_LINEAR :
                case D3DTFG_FLATCUBIC:
                case D3DTFG_GAUSSIANCUBIC:
                case D3DTFG_ANISOTROPIC:
                    iTextureFilter[i] = 1;
                    break;
                }
                iTextureMip[i] = 0;
                iTextureLOD[i] = 0;
            }
            else
            {
                switch (pCtx->pTexture[i]->uMagFilter)
                {
                default :
                    SPIDPFM((SPIM_INVALID,"Invalid texture filter mode, uMagFilter == 0x%x\n",
                        pCtx->pTexture[i]->uMagFilter));
                case D3DTFG_POINT :
                    if (pCtx->pTexture[i]->uMinFilter == D3DTFN_POINT)
                    {
                        iTextureFilter[i] = 0;
                    }
                    else
                    {
                        iTextureFilter[i] = 2;
                    }
                    break;
                case D3DTFG_LINEAR :
                case D3DTFG_FLATCUBIC:
                case D3DTFG_GAUSSIANCUBIC:
                case D3DTFG_ANISOTROPIC:
                    if (pCtx->pTexture[i]->uMinFilter == D3DTFN_LINEAR)
                    {
                        iTextureFilter[i] = 1;
                    }
                    else
                    {
                        iTextureFilter[i] = 2;
                    }
                    break;
                }
                iTextureLOD[i] = 1;
                if ( (i == 0) && (pCtx->pTexture[i]->uMipFilter == D3DTFP_LINEAR) )
                {
                    iTextureMip[i] = 1;
                }
                else
                {
                    iTextureMip[i] = 0;
                    // only set LOD to 0 if not mip filtering AND it is NOT the maybe
                    // bilinear filter case
                    if ( (pCtx->pTexture[i]->uMipFilter == D3DTFP_NONE) && (iTextureFilter[i] != 2) )
                    {
                        iTextureLOD[i] = 0;
                    }

                }
            }
            RastCapRec.Set_TextureFilter(i, iTextureFilter[i]);
            RastCapRec.Set_TextureMip(i, iTextureMip[i]);
            RastCapRec.Set_TextureLOD(i, iTextureLOD[i]);

            // set iTextureAlphaOverride if texture doesn't have an alpha and should use
            // iterated alpha
            iTextureAlphaOverride[i] = 0;
            RastCapRec.Set_TextureAlphaOverride(i, iTextureAlphaOverride[i]);

            // values needed to chose TexRead routine
            switch(pCtx->pTexture[i]->Format)
            {
            default :
                SPIDPFM((SPIM_INVALID,"Invalid texture surface bit count, "
                    "Format == 0x%x\n",(DWORD) pCtx->pTexture[i]->Format));
                return DDERR_INVALIDPARAMS;
            case D3DI_SPTFMT_B8G8R8 :
                iTextureFormat[i] = 0;
                iTextureAlphaOverride[i] = 1;
                break;
            case D3DI_SPTFMT_B8G8R8A8 :
                iTextureFormat[i] = 1;
                break;
            case D3DI_SPTFMT_B8G8R8X8 :
                // still necessary to select texture read that sets alpha to 0xff
                // for alpha dither
                iTextureFormat[i] = 0;
                iTextureAlphaOverride[i] = 1;
                break;
            case D3DI_SPTFMT_B5G6R5 :
                iTextureFormat[i] = 2;
                iTextureAlphaOverride[i] = 1;
                break;
            case D3DI_SPTFMT_B5G5R5 :
                iTextureFormat[i] = 3;
                iTextureAlphaOverride[i] = 1;
                break;
            case D3DI_SPTFMT_PALETTE4 :
                if (pCtx->pTexture[i]->pPalette == NULL)
                {
                    D3D_ERR("(Rast) NULL palette in paletted texture");
                    return DDERR_INVALIDPARAMS;
                }
                if (pCtx->pTexture[i]->uFlags & D3DI_SPANTEX_ALPHAPALETTE)
                {
                    iTextureFormat[i] = 11;
                }
                else
                {
                    iTextureFormat[i] = 4;
                    iTextureAlphaOverride[i] = 1;
                }
                break;
            case D3DI_SPTFMT_PALETTE8 :
                if (pCtx->pTexture[i]->pPalette == NULL)
                {
                    D3D_ERR("(Rast) NULL palette in paletted texture");
                    return DDERR_INVALIDPARAMS;
                }
                if (pCtx->pTexture[i]->uFlags & D3DI_SPANTEX_ALPHAPALETTE)
                {
                    iTextureFormat[i] = 12;
                }
                else
                {
                    iTextureFormat[i] = 5;
                    iTextureAlphaOverride[i] = 1;
                }
                break;
            case D3DI_SPTFMT_B5G5R5A1 :
                iTextureFormat[i] = 6;
                break;
            case D3DI_SPTFMT_B4G4R4 :
                iTextureFormat[i] = 7;
                iTextureAlphaOverride[i] = 1;
                break;
            case D3DI_SPTFMT_B4G4R4A4 :
                iTextureFormat[i] = 8;
                break;
            case D3DI_SPTFMT_L8 :
                iTextureFormat[i] = 9;
                iTextureAlphaOverride[i] = 1;
                break;
            case D3DI_SPTFMT_L8A8 :
                iTextureFormat[i] = 10;
                break;
            }
            RastCapRec.Set_TextureFormat(i, iTextureFormat[i]);

            if (pCtx->uDevVer >= 1)
            {
                // DX6, DX5 required legacy behavior
                iTextureColorKey[i] =
                    pCtx->pdwRenderState[D3DRENDERSTATE_COLORKEYENABLE] ?
                    ((pCtx->pTexture[i]->uFlags & D3DI_SPANTEX_HAS_TRANSPARENT) != 0) : 0;
                // DX5 required.  Only alpha dither only when color keying
                iAlphaDither[i] = iTextureColorKey[i];
            }
            else
            {
                // Pre-DX5 Enable ColorKey for COLORKEY OR BLENDENABLE
                iTextureColorKey[i] = (pCtx->pdwRenderState[D3DRENDERSTATE_COLORKEYENABLE] ||
                                       pCtx->pdwRenderState[D3DRENDERSTATE_ALPHABLENDENABLE]) ?
                    ((pCtx->pTexture[i]->uFlags & D3DI_SPANTEX_HAS_TRANSPARENT) != 0) : 0;
                // Alpha dither if Color Key OR Alpha Blend
                iAlphaDither[i] = iTextureColorKey[i] ||
                    (pCtx->pdwRenderState[D3DRENDERSTATE_ALPHABLENDENABLE] != 0);
            }
            RastCapRec.Set_TextureColorKey(i, iTextureColorKey[i]);
        }

        // choose TexBlend bead
        iTextureBlend = -1;
        if ( (pCtx->uDevVer <= 1) && (pCtx->uFlags & RASTCTXFLAGS_APPHACK_MSGOLF)
            && (D3DTBLEND_DECAL == pCtx->pdwRenderState[D3DRENDERSTATE_TEXTUREMAPBLEND]) )
        {
            // MSGolf98 App Hack - use modulate for decal, but also make sure that alpha
            // gets set to 0 on 555 rendertargets so colorkey works
            iTextureBlend = 2;
        }
        else if ((pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(1,D3DTSS_COLOROP)] == D3DTOP_DISABLE) &&
            (pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(0,D3DTSS_COLORARG1)] == pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(0,D3DTSS_ALPHAARG1)]) &&
            (pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(0,D3DTSS_COLORARG2)] == pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(0,D3DTSS_ALPHAARG2)]))
        {
            // might be legacy texture blend mode
            if ((pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(0,D3DTSS_COLOROP)] == D3DTOP_SELECTARG1) &&
                (pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(0,D3DTSS_ALPHAOP)] == D3DTOP_SELECTARG1) &&
                (pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(0,D3DTSS_COLORARG1)] == D3DTA_TEXTURE))
            {
                // copy, decal, decalmask
                iTextureBlend = 1;
            }
            if ((pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(0,D3DTSS_COLOROP)] == D3DTOP_MODULATE) &&
                (pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(0,D3DTSS_ALPHAOP)] == D3DTOP_SELECTARG1) &&
                (pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(0,D3DTSS_COLORARG1)] == D3DTA_TEXTURE) &&
                (pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(0,D3DTSS_COLORARG2)] == D3DTA_DIFFUSE))
            {
                // modulate, modulatemask
                if (iTextureAlphaOverride[0])
                {
                    iTextureBlend = 3;
                }
                else
                {
                    iTextureBlend = 2;
                }
            }
        }

        if (iTextureBlend == -1)
        {
            INT iCOp = 0;
            INT iCArg1 = 0;
            INT iCArg2 = 0;
            INT iAOp = 0;
            INT iAArg1 = 0;
            INT iAArg2 = 0;

            switch(pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(0,D3DTSS_COLOROP)])
            {
            default:
                SPIDPFM((SPIM_INVALID,"Invalid COLOROP0[0] == 0x%x\n",
                        (DWORD) pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(0,D3DTSS_COLOROP)]));
            case D3DTOP_DISABLE:                iCOp = 0;  break;
            case D3DTOP_SELECTARG1:             iCOp = 1;  break;
            case D3DTOP_SELECTARG2:             iCOp = 2;  break;
            case D3DTOP_MODULATE:               iCOp = 3;  break;
            case D3DTOP_MODULATE2X:             iCOp = 4;  break;
            case D3DTOP_MODULATE4X:             iCOp = 5;  break;
            case D3DTOP_ADD:                    iCOp = 6;  break;
            case D3DTOP_ADDSIGNED:              iCOp = 7;  break;
            case D3DTOP_BLENDDIFFUSEALPHA:      iCOp = 8;  break;
            case D3DTOP_BLENDTEXTUREALPHA:      iCOp = 9;  break;
            case D3DTOP_BLENDFACTORALPHA:       iCOp = 10; break;
            case D3DTOP_BLENDTEXTUREALPHAPM:    iCOp = 11; break;
            }

            switch(pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(0,D3DTSS_COLORARG1)])
            {
            default:
                SPIDPFM((SPIM_INVALID,"Invalid COLORARG1[0] == 0x%x\n",
                        (DWORD) pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(0,D3DTSS_COLORARG1)]));
            case (D3DTA_TEXTURE):
                iCArg1 = 0; break;
            case (D3DTA_TEXTURE|D3DTA_COMPLEMENT):
                iCArg1 = 1; break;
            case (D3DTA_ALPHAREPLICATE|D3DTA_TEXTURE):
                iCArg1 = 2; break;
            case (D3DTA_ALPHAREPLICATE|D3DTA_TEXTURE|D3DTA_COMPLEMENT):
                iCArg1 = 3; break;
            }

            switch(pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(0,D3DTSS_COLORARG2)])
            {
            default:
                SPIDPFM((SPIM_INVALID,"Invalid COLORARG2[0] == 0x%x\n",
                        (DWORD) pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(0,D3DTSS_COLORARG2)]));
            case (D3DTA_DIFFUSE):
                iCArg2 = 0; break;
            case (D3DTA_CURRENT):
                iCArg2 = 1; break;
            case (D3DTA_TFACTOR):
                iCArg2 = 2; break;
            case (D3DTA_COMPLEMENT|D3DTA_DIFFUSE):
                iCArg2 = 3; break;
            case (D3DTA_COMPLEMENT|D3DTA_CURRENT):
                iCArg2 = 4; break;
            case (D3DTA_COMPLEMENT|D3DTA_TFACTOR):
                iCArg2 = 5; break;
            case (D3DTA_ALPHAREPLICATE|D3DTA_DIFFUSE):
                iCArg2 = 6; break;
            case (D3DTA_ALPHAREPLICATE|D3DTA_CURRENT):
                iCArg2 = 7; break;
            case (D3DTA_ALPHAREPLICATE|D3DTA_TFACTOR):
                iCArg2 = 8; break;
            case (D3DTA_ALPHAREPLICATE|D3DTA_COMPLEMENT|D3DTA_DIFFUSE):
                iCArg2 = 9; break;
            case (D3DTA_ALPHAREPLICATE|D3DTA_COMPLEMENT|D3DTA_CURRENT):
                iCArg2 = 10; break;
            case (D3DTA_ALPHAREPLICATE|D3DTA_COMPLEMENT|D3DTA_TFACTOR):
                iCArg2 = 11; break;
            }

            switch(pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(0,D3DTSS_ALPHAOP)])
            {
            default:
                SPIDPFM((SPIM_INVALID,"Invalid ALPHAOP[0] == 0x%x\n",
                        (DWORD) pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(0,D3DTSS_ALPHAOP)]));
            case D3DTOP_DISABLE:                iAOp = 0;  break;
            case D3DTOP_SELECTARG1:             iAOp = 1;  break;
            case D3DTOP_SELECTARG2:             iAOp = 2;  break;
            case D3DTOP_MODULATE:               iAOp = 3;  break;
            case D3DTOP_MODULATE2X:             iAOp = 4;  break;
            case D3DTOP_MODULATE4X:             iAOp = 5;  break;
            case D3DTOP_ADD:                    iAOp = 6;  break;
            case D3DTOP_ADDSIGNED:              iAOp = 7;  break;
            case D3DTOP_BLENDDIFFUSEALPHA:      iAOp = 8;  break;
            case D3DTOP_BLENDTEXTUREALPHA:      iAOp = 9;  break;
            case D3DTOP_BLENDFACTORALPHA:       iAOp = 10; break;
            case D3DTOP_BLENDTEXTUREALPHAPM:    iAOp = 11; break;
            }

            switch(pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(0,D3DTSS_ALPHAARG1)])
            {
            default:
                SPIDPFM((SPIM_INVALID,"Invalid ALPHAARG1[0] == 0x%x\n",
                        (DWORD) pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(0,D3DTSS_ALPHAARG1)]));
            case (D3DTA_TEXTURE):
            case (D3DTA_ALPHAREPLICATE|D3DTA_TEXTURE):
                iAArg1 = 0; break;
            case (D3DTA_TEXTURE|D3DTA_COMPLEMENT):
            case (D3DTA_ALPHAREPLICATE|D3DTA_TEXTURE|D3DTA_COMPLEMENT):
                iAArg1 = 1; break;
            }

            switch(pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(0,D3DTSS_ALPHAARG2)])
            {
            default:
                SPIDPFM((SPIM_INVALID,"Invalid ALPHAARG2[0] == 0x%x\n",
                        (DWORD) pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(0,D3DTSS_ALPHAARG2)]));
            case (D3DTA_DIFFUSE):
            case (D3DTA_ALPHAREPLICATE|D3DTA_DIFFUSE):
                iAArg2 = 0; break;
            case (D3DTA_CURRENT):
            case (D3DTA_ALPHAREPLICATE|D3DTA_CURRENT):
                iAArg2 = 1; break;
            case (D3DTA_TFACTOR):
            case (D3DTA_ALPHAREPLICATE|D3DTA_TFACTOR):
                iAArg2 = 2; break;
            case (D3DTA_COMPLEMENT|D3DTA_DIFFUSE):
            case (D3DTA_ALPHAREPLICATE|D3DTA_COMPLEMENT|D3DTA_DIFFUSE):
                iAArg2 = 3; break;
            case (D3DTA_COMPLEMENT|D3DTA_CURRENT):
            case (D3DTA_ALPHAREPLICATE|D3DTA_COMPLEMENT|D3DTA_CURRENT):
                iAArg2 = 4; break;
            case (D3DTA_COMPLEMENT|D3DTA_TFACTOR):
            case (D3DTA_ALPHAREPLICATE|D3DTA_COMPLEMENT|D3DTA_TFACTOR):
                iAArg2 = 5; break;
            }

            pCtx->pfnTexBlendOpColor[0] = pBeadTable->pTexBlendOpColorBeads->pfnTexBlendOpColor[iCOp];
            pCtx->pfnTexBlendGetColor[0] = pBeadTable->pTexBlendGetColorBeads->pfnTexBlendGetColor[iCArg2][iCArg1];
            pCtx->pfnTexBlendOpAlpha[0] = pBeadTable->pTexBlendOpAlphaBeads->pfnTexBlendOpAlpha[iAOp];
            pCtx->pfnTexBlendGetAlpha[0] = pBeadTable->pTexBlendGetAlphaBeads->pfnTexBlendGetAlpha[iAArg2][iAArg1];

            // general TexBlend
            if (pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(1,D3DTSS_COLOROP)] == D3DTOP_DISABLE)
            {     \
                // Tex1_Gen
                iTextureBlend = 4;
            }
            else
            {
                // TexM_Gen
                iTextureBlend = 5;

                switch(pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(1,D3DTSS_COLOROP)])
                {
                default:
                    SPIDPFM((SPIM_INVALID,"Invalid COLOROP1[1] == 0x%x\n",
                            (DWORD) pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(1,D3DTSS_COLOROP)]));
                case D3DTOP_DISABLE:                iCOp = 0;  break;
                case D3DTOP_SELECTARG1:             iCOp = 1;  break;
                case D3DTOP_SELECTARG2:             iCOp = 2;  break;
                case D3DTOP_MODULATE:               iCOp = 3;  break;
                case D3DTOP_MODULATE2X:             iCOp = 4;  break;
                case D3DTOP_MODULATE4X:             iCOp = 5;  break;
                case D3DTOP_ADD:                    iCOp = 6;  break;
                case D3DTOP_ADDSIGNED:              iCOp = 7;  break;
                case D3DTOP_BLENDDIFFUSEALPHA:      iCOp = 8;  break;
                case D3DTOP_BLENDTEXTUREALPHA:      iCOp = 9;  break;
                case D3DTOP_BLENDFACTORALPHA:       iCOp = 10; break;
                case D3DTOP_BLENDTEXTUREALPHAPM:    iCOp = 11; break;
                }

                switch(pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(1,D3DTSS_COLORARG1)])
                {
                default:
                    SPIDPFM((SPIM_INVALID,"Invalid COLORARG1[1] == 0x%x\n",
                            (DWORD) pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(1,D3DTSS_COLORARG1)]));
                case (D3DTA_TEXTURE):
                    iCArg1 = 0; break;
                case (D3DTA_TEXTURE|D3DTA_COMPLEMENT):
                    iCArg1 = 1; break;
                case (D3DTA_ALPHAREPLICATE|D3DTA_TEXTURE):
                    iCArg1 = 2; break;
                case (D3DTA_ALPHAREPLICATE|D3DTA_TEXTURE|D3DTA_COMPLEMENT):
                    iCArg1 = 3; break;
                }

                switch(pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(1,D3DTSS_COLORARG2)])
                {
                case (D3DTA_DIFFUSE):
                    iCArg2 = 0; break;
                default:
                    SPIDPFM((SPIM_INVALID,"Invalid COLORARG2[1] == 0x%x\n",
                            (DWORD) pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(1,D3DTSS_COLORARG2)]));
                case (D3DTA_CURRENT):
                    iCArg2 = 1; break;
                case (D3DTA_TFACTOR):
                    iCArg2 = 2; break;
                case (D3DTA_COMPLEMENT|D3DTA_DIFFUSE):
                    iCArg2 = 3; break;
                case (D3DTA_COMPLEMENT|D3DTA_CURRENT):
                    iCArg2 = 4; break;
                case (D3DTA_COMPLEMENT|D3DTA_TFACTOR):
                    iCArg2 = 5; break;
                case (D3DTA_ALPHAREPLICATE|D3DTA_DIFFUSE):
                    iCArg2 = 6; break;
                case (D3DTA_ALPHAREPLICATE|D3DTA_CURRENT):
                    iCArg2 = 7; break;
                case (D3DTA_ALPHAREPLICATE|D3DTA_TFACTOR):
                    iCArg2 = 8; break;
                case (D3DTA_ALPHAREPLICATE|D3DTA_COMPLEMENT|D3DTA_DIFFUSE):
                    iCArg2 = 9; break;
                case (D3DTA_ALPHAREPLICATE|D3DTA_COMPLEMENT|D3DTA_CURRENT):
                    iCArg2 = 10; break;
                case (D3DTA_ALPHAREPLICATE|D3DTA_COMPLEMENT|D3DTA_TFACTOR):
                    iCArg2 = 11; break;
                }

                switch(pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(1,D3DTSS_ALPHAOP)])
                {
                default:
                    SPIDPFM((SPIM_INVALID,"Invalid ALPHAOP[1] == 0x%x\n",
                            (DWORD) pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(1,D3DTSS_ALPHAOP)]));
                case D3DTOP_DISABLE:                iAOp = 0;  break;
                case D3DTOP_SELECTARG1:             iAOp = 1;  break;
                case D3DTOP_SELECTARG2:             iAOp = 2;  break;
                case D3DTOP_MODULATE:               iAOp = 3;  break;
                case D3DTOP_MODULATE2X:             iAOp = 4;  break;
                case D3DTOP_MODULATE4X:             iAOp = 5;  break;
                case D3DTOP_ADD:                    iAOp = 6;  break;
                case D3DTOP_ADDSIGNED:              iAOp = 7;  break;
                case D3DTOP_BLENDDIFFUSEALPHA:      iAOp = 8;  break;
                case D3DTOP_BLENDTEXTUREALPHA:      iAOp = 9;  break;
                case D3DTOP_BLENDFACTORALPHA:       iAOp = 10; break;
                case D3DTOP_BLENDTEXTUREALPHAPM:    iAOp = 11; break;
                }

                switch(pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(1,D3DTSS_ALPHAARG1)])
                {
                default:
                    SPIDPFM((SPIM_INVALID,"Invalid ALPHAARG1[1] == 0x%x\n",
                            (DWORD) pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(1,D3DTSS_ALPHAARG1)]));
                case (D3DTA_TEXTURE):
                case (D3DTA_ALPHAREPLICATE|D3DTA_TEXTURE):
                    iAArg1 = 0; break;
                case (D3DTA_TEXTURE|D3DTA_COMPLEMENT):
                case (D3DTA_ALPHAREPLICATE|D3DTA_TEXTURE|D3DTA_COMPLEMENT):
                    iAArg1 = 1; break;
                }

                switch(pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(1,D3DTSS_ALPHAARG2)])
                {
                case (D3DTA_DIFFUSE):
                case (D3DTA_ALPHAREPLICATE|D3DTA_DIFFUSE):
                    iAArg2 = 0; break;
                default:
                    SPIDPFM((SPIM_INVALID,"Invalid ALPHAARG2[1] == 0x%x\n",
                            (DWORD) pCtx->pdwRenderState[D3DHAL_TSS_OFFSET(1,D3DTSS_ALPHAARG2)]));
                case (D3DTA_CURRENT):
                case (D3DTA_ALPHAREPLICATE|D3DTA_CURRENT):
                    iAArg2 = 1; break;
                case (D3DTA_TFACTOR):
                case (D3DTA_ALPHAREPLICATE|D3DTA_TFACTOR):
                    iAArg2 = 2; break;
                case (D3DTA_COMPLEMENT|D3DTA_DIFFUSE):
                case (D3DTA_ALPHAREPLICATE|D3DTA_COMPLEMENT|D3DTA_DIFFUSE):
                    iAArg2 = 3; break;
                case (D3DTA_COMPLEMENT|D3DTA_CURRENT):
                case (D3DTA_ALPHAREPLICATE|D3DTA_COMPLEMENT|D3DTA_CURRENT):
                    iAArg2 = 4; break;
                case (D3DTA_COMPLEMENT|D3DTA_TFACTOR):
                case (D3DTA_ALPHAREPLICATE|D3DTA_COMPLEMENT|D3DTA_TFACTOR):
                    iAArg2 = 5; break;
                }

                pCtx->pfnTexBlendOpColor[1] = pBeadTable->pTexBlendOpColorBeads->pfnTexBlendOpColor[iCOp];
                pCtx->pfnTexBlendGetColor[1] = pBeadTable->pTexBlendGetColorBeads->pfnTexBlendGetColor[iCArg2][iCArg1];
                pCtx->pfnTexBlendOpAlpha[1] = pBeadTable->pTexBlendOpAlphaBeads->pfnTexBlendOpAlpha[iAOp];
                pCtx->pfnTexBlendGetAlpha[1] = pBeadTable->pTexBlendGetAlphaBeads->pfnTexBlendGetAlpha[iAArg2][iAArg1];
            }
        }
        RastCapRec.Set_TextureBlend(iTextureBlend);
    }

    // Ignore mono (D3DRENDERSTATE_MONOENABLE), since no software rasterizers do anything with it.
    iMono = 0;
    RastCapRec.Set_Mono(iMono);

    // values needed to choose ColorBlend bead
    iAlphaBlend =
        pCtx->pdwRenderState[D3DRENDERSTATE_ALPHABLENDENABLE] ? 1 : 0;
    RastCapRec.Set_AlphaBlend(iAlphaBlend);
    if (!iAlphaBlend ||
        ((pCtx->pdwRenderState[D3DRENDERSTATE_SRCBLEND] == D3DBLEND_ONE) &&
         (pCtx->pdwRenderState[D3DRENDERSTATE_DESTBLEND] == D3DBLEND_ZERO))) {
        iBlend = 0;
    } else {
        iBlend = 1;
    }
    RastCapRec.Set_Blend(iBlend);
    if (pCtx->pdwRenderState[D3DRENDERSTATE_ROP2] == R2_COPYPEN) {
        iROP = 0;
    } else {
        iROP = 1;
    }
    RastCapRec.Set_ROP(iROP);

    // value needed to choose DestBlend routine
    switch (pCtx->pdwRenderState[D3DRENDERSTATE_DESTBLEND])
    {
    default :
        SPIDPFM((SPIM_INVALID,"Invalid renderstate value, D3DRENDERSTATE_DESTBLEND == 0x%x\n",
            pCtx->pdwRenderState[D3DRENDERSTATE_DESTBLEND]));
    case D3DBLEND_ZERO :
        iDestBlend = 0;
        break;
    case D3DBLEND_ONE :
        iDestBlend = 1;
        break;
    case D3DBLEND_SRCCOLOR :
        iDestBlend = 2;
        break;
    case D3DBLEND_INVSRCCOLOR :
        iDestBlend = 3;
        break;
    case D3DBLEND_SRCALPHA :
        iDestBlend = 4;
        break;
    case D3DBLEND_INVSRCALPHA :
        iDestBlend = 5;
        break;
    case D3DBLEND_DESTALPHA :
        iDestBlend = 6;
        break;
    case D3DBLEND_INVDESTALPHA :
        iDestBlend = 7;
        break;
    case D3DBLEND_DESTCOLOR :
        iDestBlend = 8;
        break;
    case D3DBLEND_INVDESTCOLOR :
        iDestBlend = 9;
        break;
    case D3DBLEND_SRCALPHASAT :
        iDestBlend = 10;
        break;
    }

    // set iSrcBlend after iDestBlend so BOTHSRCALPHA can override iDestBlend
    // value needed to choose SrcBlend routine
    switch (pCtx->pdwRenderState[D3DRENDERSTATE_SRCBLEND])
    {
    case D3DBLEND_ZERO :
        iSrcBlend = 0;
        break;
    default :
        SPIDPFM((SPIM_INVALID,"Invalid renderstate value, D3DRENDERSTATE_SRCBLEND == 0x%x\n",
            pCtx->pdwRenderState[D3DRENDERSTATE_SRCBLEND]));
    case D3DBLEND_ONE :
        iSrcBlend = 1;
        break;
    case D3DBLEND_SRCCOLOR :
        iSrcBlend = 2;
        break;
    case D3DBLEND_INVSRCCOLOR :
        iSrcBlend = 3;
        break;
    case D3DBLEND_SRCALPHA :
        iSrcBlend = 4;
        break;
    case D3DBLEND_INVSRCALPHA :
        iSrcBlend = 5;
        break;
    case D3DBLEND_DESTALPHA :
        iSrcBlend = 6;
        break;
    case D3DBLEND_INVDESTALPHA :
        iSrcBlend = 7;
        break;
    case D3DBLEND_DESTCOLOR :
        iSrcBlend = 8;
        break;
    case D3DBLEND_INVDESTCOLOR :
        iSrcBlend = 9;
        break;
    case D3DBLEND_SRCALPHASAT :
        iSrcBlend = 10;
        break;
    // these are special and set both source and dest
    case D3DBLEND_BOTHSRCALPHA :
        iSrcBlend = 4;
        iDestBlend = 5;
        break;
    case D3DBLEND_BOTHINVSRCALPHA :
        iSrcBlend = 5;
        iDestBlend = 4;
        break;
    }
    RastCapRec.Set_SrcBlend(iSrcBlend);
    RastCapRec.Set_DestBlend(iDestBlend);

    // values needed to choose BufWrite bead and BufRead routine
    switch (pCtx->iSurfaceType)
    {
    default :
        SPIDPFM((SPIM_INVALID,"Invalid target surface type, iSurfaceType == 0x%x\n",
            pCtx->iSurfaceType));
    case RR_STYPE_B8G8R8X8:
        iTargetPixelFormat = 0;
        break;
    case RR_STYPE_B8G8R8A8:
        iTargetPixelFormat = 1;
        break;
    case RR_STYPE_B5G6R5:
        iTargetPixelFormat = 2;
        break;
    case RR_STYPE_B5G5R5:
        iTargetPixelFormat = 3;
        break;
    case RR_STYPE_B5G5R5A1:
        iTargetPixelFormat = 4;
        break;
    case RR_STYPE_B8G8R8:
        iTargetPixelFormat = 5;
        break;
    case RR_STYPE_PALETTE8:
        iTargetPixelFormat = 6;
        break;
    }
    RastCapRec.Set_TargetPixelFormat(iTargetPixelFormat);
    iDither = pCtx->pdwRenderState[D3DRENDERSTATE_DITHERENABLE] ? 1 : 0;
    RastCapRec.Set_Dither(iDither);
    iZDeferred = iAlphaTest || iAlphaDither[0];

    // Set optional postprocessing beads first so that their addresses
    // can be referenced later.
    pCtx->pfnPixelEnd = pBeadTable->pPixelEndBeads->pfnPixelEnd[0];
    pCtx->pfnSpanEnd = pBeadTable->pSpanEndBeads->pfnSpanEnd[0];

    // start stringing beads together, back to front order avoids a lot of
    // conditional logic

#if DBG
    // null out all bead ptrs
    pCtx->pfnBegin = NULL;
    pCtx->pfnLoopEnd = NULL;
    pCtx->pfnTestPassEnd = NULL;
    pCtx->pfnTestFailEnd = NULL;
    pCtx->pfnTex1AddrEnd = NULL;
    pCtx->pfnTexRead[0] = NULL;
    pCtx->pfnTexRead[1] = NULL;
    pCtx->pfnTex2AddrEnd = NULL;
    pCtx->pfnTexBlendEnd = NULL;
    pCtx->pfnColorGenEnd = NULL;
    pCtx->pfnAlphaTestPassEnd = NULL;
    pCtx->pfnAlphaTestFailEnd = NULL;
    pCtx->pfnSrcBlend =  NULL;
    pCtx->pfnDestBlend =  NULL;
    pCtx->pfnBufRead = NULL;
    pCtx->pfnColorBlendEnd = NULL;
    pCtx->pfnPixelEnd = NULL;
    pCtx->pfnSpanEnd = NULL;
#endif

    // range check indices used to select BufWrite bead
    RANGE_CHECK(iDither,DITHERING_NUM);
    RANGE_CHECK(iTargetPixelFormat,TARGETPIXELFORMAT_NUM);

    // select BufWrite bead, which can be called through pfnColorBlendEnd,
    // pfnAlphaTestPassEnd, pfnColorGenEnd, pfnTexBlendEnd
    pCtx->pfnTexBlendEnd =
        pCtx->pfnColorGenEnd =
        pCtx->pfnAlphaTestPassEnd =
        pCtx->pfnColorBlendEnd = pBeadTable->pBufWriteBeads->pfnBufWrite[iDither][iTargetPixelFormat];
#if DBG
    strcpy(pCtx->szBufWrite,rgszBufWrite[iDither][iTargetPixelFormat]);
#endif

    // range check indices used to select ColorBlend bead
    RANGE_CHECK(iROP,ROP_NUM);
    RANGE_CHECK(iBlend,BLEND_NUM);

    // select ColorBlend bead, which can be called through
    // pfnATextEnd, pfnColorGenEnd, or pfnTexBlendEnd
    if ((pfnColorBlend = pBeadTable->pColorBlendBeads->pfnColorBlend[iROP][iBlend]) == NULL) {
        pCtx->pfnColorBlendEnd = NULL;
    } else {
        pCtx->pfnTexBlendEnd =
            pCtx->pfnColorGenEnd =
            pCtx->pfnAlphaTestPassEnd = pfnColorBlend;
    }
#if DBG
    strcpy(pCtx->szColorBlend,rgszColorBlend[iROP][iBlend]);
#endif

    // range check index used to select BufRead bead
    RANGE_CHECK(iTargetPixelFormat,TARGETPIXELFORMAT_NUM);

    // select Buf Read routine
    pCtx->pfnBufRead = pBeadTable->pBufReadBeads->pfnBufRead[iTargetPixelFormat];
#if DBG
    strcpy(pCtx->szBufRead,rgszBufRead[iTargetPixelFormat]);
#endif

    if (iBlend) {
        // range check index used to select DestBlend bead
        RANGE_CHECK(iDestBlend,DESTBLEND_NUM);

        // select DestBlend routine
        pCtx->pfnDestBlend = pBeadTable->pDestBlendBeads->pfnDestBlend[iDestBlend];
#if DBG
        strcpy(pCtx->szDestBlend,rgszDestBlend[iDestBlend]);
#endif

        // range check index used to select SrcBlend bead
        RANGE_CHECK(iSrcBlend,SRCBLEND_NUM);

        // select SrcBlend routine
        pCtx->pfnSrcBlend = pBeadTable->pSrcBlendBeads->pfnSrcBlend[iSrcBlend];
#if DBG
        strcpy(pCtx->szSrcBlend,rgszSrcBlend[iSrcBlend]);
#endif
    } else {
        pCtx->pfnDestBlend = NULL;
        pCtx->pfnSrcBlend = NULL;
#if DBG
        strcpy(pCtx->szDestBlend,"NULL");
        strcpy(pCtx->szSrcBlend,"NULL");
#endif
    }

    // select AlphaTest/AlphaDitheringTest bead, which can be called through
    // pfnColorBlendEnd, pfnColorGenEnd, or pfnTexBlendEnd

    // range check indices used to select AlphaTest bead
    RANGE_CHECK(iStencil,STENCIL_NUM);
    RANGE_CHECK(iZFormat,ZFORMAT_NUM);
    RANGE_CHECK(iZWrite,ZWRITE_NUM);
    RANGE_CHECK(iAlphaDither[0],COLORKEY_NUM);
    RANGE_CHECK(iAlphaTest,ALPHATEST_NUM);

    if (iAlphaTest || iAlphaDither[0])
    {
        pCtx->pfnTexBlendEnd =
            pCtx->pfnColorGenEnd =
                pBeadTable->pAlphaTestBeads->pfnAlphaTest[iStencil]
                                                         [iZFormat]
                                                         [iZWrite || iStencil]
                                                         [iAlphaDither[0]]
                                                         [iAlphaTest];

        // If AlphaTest fails, it goes to where the BufWrite bead ends
        pCtx->pfnAlphaTestFailEnd = pCtx->pfnPixelEnd;
#if DBG
        strcpy(pCtx->szAlphaTest,rgszAlphaTest[iStencil][iZFormat][iZWrite]
                                              [iAlphaDither[0]][iAlphaTest]);
#endif
    }
    else
    {
        pCtx->pfnAlphaTestPassEnd = NULL;
        pCtx->pfnAlphaTestFailEnd = NULL;
#if DBG
        strcpy(pCtx->szAlphaTest, "NULL");
#endif
    }


    // range check indices used to select ColorGen bead
    RANGE_CHECK(iMono,MONO_NUM);
    RANGE_CHECK(iVertexFog,VERTEXFOG_NUM);
    RANGE_CHECK(iSpecular,SPECULAR_NUM);
    RANGE_CHECK(iShadeMode,SHADEMODE_NUM);

    // select ColorGen bead, which can be called through pfnTexBlendEnd
    if ((pfnColorGen =
        pBeadTable->pColorGenBeads->pfnColorGen[iMono][iVertexFog][iSpecular][iShadeMode]) == NULL) {
        pCtx->pfnColorGenEnd = NULL;
    } else {
        pCtx->pfnTexBlendEnd = pfnColorGen;
    }
#if DBG
    strcpy(pCtx->szColorGen,
        rgszColorGen[iMono][iVertexFog][iSpecular][iShadeMode]);
#endif

    // range check indices used to select TexBlend bead
    RANGE_CHECK(iTextureBlend,TEXTUREBLEND_NUM);

    // select TexBlend bead, which can be called through pfnTexAddr2End,
    // pfnTexAddr1End, pfnTestPassEnd, or pfnLoopEnd
    pCtx->pfnLoopEnd =
        pCtx->pfnTestPassEnd =
        pCtx->pfnTex1AddrEnd =
        pCtx->pfnTex2AddrEnd = pBeadTable->pTexBlendBeads->pfnTexBlend[iTextureBlend];
#if DBG
    strcpy(pCtx->szTexBlend,rgszTexBlend[iTextureBlend]);
#endif

    if (iTexture) {

        if (pCtx->cActTex >= 2)
        {
            // range check indices used to select TexRead bead
            RANGE_CHECK(iTextureColorKey[1],COLORKEY_NUM);
            RANGE_CHECK(iTextureBorder[1],TEXTUREBORDER_NUM);
            RANGE_CHECK(iTextureFormat[1],TEXTUREFORMAT_NUM);

            // select TexAddr2 bead, which can be called through pfnTexAddr1
            // select TexRead routine
            pCtx->pfnTexRead[1] =
                pBeadTable->pTexReadBeads->pfnTexRead[iTextureColorKey[1]][iTextureBorder[1]][iTextureFormat[1]];

#if DBG
            strcpy(pCtx->szTexRead[1],
                rgszTexRead[iTextureColorKey[1]][iTextureBorder[1]][iTextureFormat[1]]);
#endif

            // range check indices used to select Tex1Addr bead
            RANGE_CHECK(iTextureLOD[1],TEXTURELOD_NUM);
            RANGE_CHECK(iTextureFilter[1],TEXTUREFILTER_NUM);
            RANGE_CHECK(iTexturePerspective,TEXTUREPERSPECTIVE_NUM);
            RANGE_CHECK(iTextureAddr[1],TEXTUREADDRESS_NUM);

            // select TexAddr1 bead, which can be called through pfnTestPassEnd or
            // pfnLoopEnd
            if ((pfnTex2Addr = (pBeadTable->pTex2AddrBeads->pfnTex2Addr[iTextureFilter[1]]
                                [iTexturePerspective][iTextureAddr[1]])) == NULL) {
                pCtx->pfnTex2AddrEnd = NULL;
            } else {
                pCtx->pfnLoopEnd =
                    pCtx->pfnTex1AddrEnd = pfnTex2Addr;
            }
#if DBG
            strcpy(pCtx->szTex2Addr,rgszTex2Addr[iTextureFilter[1]]
                [iTexturePerspective][iTextureAddr[1]]);
#endif
        } else {
            pCtx->pfnTex2AddrEnd = NULL;
            pCtx->pfnTexRead[1] = NULL;
#if DBG
            strcpy(pCtx->szTex2Addr,"NULL");
            strcpy(pCtx->szTexRead[1],"NULL");
#endif
        }

        // range check indices used to select TexRead bead
        RANGE_CHECK(iTextureColorKey[0],COLORKEY_NUM);
        RANGE_CHECK(iTextureBorder[0],TEXTUREBORDER_NUM);
        RANGE_CHECK(iTextureFormat[0],TEXTUREFORMAT_NUM);

        // select TexRead routine
        pCtx->pfnTexRead[0] =
            pBeadTable->pTexReadBeads->pfnTexRead[iTextureColorKey[0]][iTextureBorder[0]][iTextureFormat[0]];
#if DBG
        strcpy(pCtx->szTexRead[0],
            rgszTexRead[iTextureColorKey[0]][iTextureBorder[0]][iTextureFormat[0]]);
#endif

        // range check indices used to select Tex1Addr bead
        RANGE_CHECK(iTextureLOD[0],TEXTURELOD_NUM);
        RANGE_CHECK(iTextureFilter[0],TEXTUREFILTER_NUM);
        RANGE_CHECK(iTexturePerspective,TEXTUREPERSPECTIVE_NUM);
        RANGE_CHECK(iTextureAddr[0],TEXTUREADDRESS_NUM);

        // select TexAddr1 bead, which can be called through pfnTestPassEnd or
        // pfnLoopEnd
        if ((pfnTex1Addr = ((iTextureMip[0]) ?
            (pBeadTable->pTex1AddrMipBeads->pfnTex1AddrMip[0]) :
            (pBeadTable->pTex1AddrBeads->pfnTex1Addr[iTextureLOD[0]][iTextureFilter[0]]
                            [iTexturePerspective][iTextureAddr[0]]))) == NULL) {
            pCtx->pfnTex1AddrEnd = NULL;
        } else {
            pCtx->pfnLoopEnd =
                pCtx->pfnTestPassEnd = pfnTex1Addr;
        }
#if DBG
        if (iTextureMip[0])
        {
            strcpy(pCtx->szTex1Addr,rgszTex1AddrMip[0]);
        }
        else
        {
            strcpy(pCtx->szTex1Addr,rgszTex1Addr[iTextureLOD[0]][iTextureFilter[0]]
                [iTexturePerspective][iTextureAddr[0]]);
        }
#endif
    } else {
        pCtx->pfnTex2AddrEnd = NULL;
        pCtx->pfnTexRead[0] = NULL;
        pCtx->pfnTex1AddrEnd = NULL;
#if DBG
        strcpy(pCtx->szTex2Addr,"NULL");
        strcpy(pCtx->szTexRead[0],"NULL");
        strcpy(pCtx->szTex1Addr,"NULL");
#endif
    }

    // select Test bead, which can be called through pfnLoopEnd
    if (iZTest) {

        // range check indices used to select Test bead
        RANGE_CHECK(iStencil,STENCIL_NUM);
        RANGE_CHECK(iZFunc,ZFUNC_NUM);
        RANGE_CHECK(iZWrite,ZWRITE_NUM);
        // ATTENTION range check this
//        RANGE_CHECK(iAlphaTest,ALPHATEST_NUM);
        RANGE_CHECK(iZFormat,ZFORMAT_NUM);
        RANGE_CHECK(iSpecular,SPECULAR_NUM);
        RANGE_CHECK(iVertexFog,VERTEXFOG_NUM);
        RANGE_CHECK(iTexture,TEXTURE_NUM);
        RANGE_CHECK(iShadeMode,SHADEMODE_NUM);

        // if alpha testing, defer Z write
        pCtx->pfnLoopEnd = pBeadTable->pTestBeads->pfnTest[iStencil][iZFunc]
            [iZDeferred][iZWrite][iZFormat];

        // select where this bead is going to go if the test fails
        pCtx->pfnTestFailEnd =
            pBeadTable->pTestFailBeads->pfnTestFail[iSpecular | iVertexFog][iTexture][iShadeMode];

        if (iZDeferred && iStencil)
        {
            // If alpha testing and stenciling, need to
            // defer stencil update until after the alpha test.
            //
            // This is not an issue for Z, since we never want to write Z
            // if the Z test fails (hence we do not care about the outcome of
            // the alpha test.
            pCtx->pfnTestFailEnd = pCtx->pfnTestPassEnd;
        }

#if DBG
        strcpy(pCtx->szTest,rgszTest[iStencil][iZFunc][iZDeferred][iZWrite][iZFormat]);
        strcpy(pCtx->szTestFail,
            rgszTestFail[iSpecular | iVertexFog][iTexture][iShadeMode]);
#endif
    } else {
        pCtx->pfnTestPassEnd = NULL;
        pCtx->pfnTestFailEnd = NULL;
#if DBG
        strcpy(pCtx->szTest,"NULL");
        strcpy(pCtx->szTestFail,"NULL");
#endif
    }

    // select Loop bead
    pCtx->pfnBegin = pBeadTable->pBeginBeads->pfnBegin[0];

    pCtx->pfnRenderSpans = pBeadTable->pRenderSpansBeads->pfnRenderSpans[0];

#if DBG
    SPIDPFM((SPIM_REPORT,"Test = %s\n",pCtx->szTest));
    SPIDPFM((SPIM_REPORT,"TestFail = %s\n",pCtx->szTestFail));
    SPIDPFM((SPIM_REPORT,"Tex1Addr = %s\n",pCtx->szTex1Addr));
    SPIDPFM((SPIM_REPORT,"TexRead1 = %s\n",pCtx->szTexRead[0]));
    SPIDPFM((SPIM_REPORT,"TexRead2 = %s\n",pCtx->szTexRead[1]));
    SPIDPFM((SPIM_REPORT,"Tex2Addr = %s\n",pCtx->szTex2Addr));
    SPIDPFM((SPIM_REPORT,"TexBlend = %s\n",pCtx->szTexBlend));
    SPIDPFM((SPIM_REPORT,"ColorGen = %s\n",pCtx->szColorGen));
    SPIDPFM((SPIM_REPORT,"ColorBlend = %s\n",pCtx->szColorBlend));
    SPIDPFM((SPIM_REPORT,"SrcBlend = %s\n",pCtx->szSrcBlend));
    SPIDPFM((SPIM_REPORT,"DestBlend = %s\n",pCtx->szDestBlend));
    SPIDPFM((SPIM_REPORT,"BufRead = %s\n",pCtx->szBufRead));
    SPIDPFM((SPIM_REPORT,"AlphaTest = %s\n",pCtx->szAlphaTest));
    SPIDPFM((SPIM_REPORT,"BufWrite = %s\n",pCtx->szBufWrite));
    SPIDPFM((SPIM_REPORT,"RastCap = 0x%x 0x%x 0x%x\n",
        RastCapRec.GetCapDWord(0),
        RastCapRec.GetCapDWord(1),
        RastCapRec.GetCapDWord(2)));


#if 0
    DWORD dwCheckSum = RastCapRec.GetCapDWord(0) ^ RastCapRec.GetCapDWord(1) ^ RastCapRec.GetCapDWord(2);
    static DWORD dwCheckSumLast;
    if (dwCheckSum != dwCheckSumLast)
    {
        dwCheckSumLast = dwCheckSum;
        DPF(0, "Spaninit");
        DPF(0, "Test = %s",pCtx->szTest);
        DPF(0, "TestFail = %s",pCtx->szTestFail);
        DPF(0, "Tex1Addr = %s",pCtx->szTex1Addr);
        DPF(0, "TexRead1 = %s",pCtx->szTexRead[0]);
        DPF(0, "TexRead2 = %s",pCtx->szTexRead[1]);
        DPF(0, "Tex2Addr = %s",pCtx->szTex2Addr);
        DPF(0, "TexBlend = %s",pCtx->szTexBlend);
        DPF(0, "ColorGen = %s",pCtx->szColorGen);
        DPF(0, "ColorBlend = %s",pCtx->szColorBlend);
        DPF(0, "SrcBlend = %s",pCtx->szSrcBlend);
        DPF(0, "DestBlend = %s",pCtx->szDestBlend);
        DPF(0, "BufRead = %s",pCtx->szBufRead);
        DPF(0, "AlphaTest = %s",pCtx->szAlphaTest);
        DPF(0, "BufWrite = %s",pCtx->szBufWrite);
        DPF(0, "RastCap = 0x%x 0x%x 0x%x",
            RastCapRec.GetCapDWord(0),
            RastCapRec.GetCapDWord(1),
            RastCapRec.GetCapDWord(2));
    }
#endif
#endif

    // is there a monolithic rasterizer that can do exactly
    // what is needed?
    RASTFNREC* pfnRastFnRec;
    if ((pfnRastFnRec = g_RastCollection.Search(pCtx, &RastCapRec)) != NULL)
    {
        // yes, then replace beaded rasterizer with monolithic
        DDASSERT(pfnRastFnRec->pfnRastFunc != 0);
        pCtx->pfnRenderSpans = pfnRastFnRec->pfnRastFunc;

#if DBG
        // null out all the others
        pCtx->pfnBegin =
            pCtx->pfnLoopEnd =
            pCtx->pfnTestPassEnd =
            pCtx->pfnTestFailEnd =
            pCtx->pfnTex1AddrEnd =
            pCtx->pfnTex2AddrEnd =
            pCtx->pfnTexBlendEnd =
            pCtx->pfnColorGenEnd =
            pCtx->pfnAlphaTestPassEnd =
            pCtx->pfnAlphaTestFailEnd =
            pCtx->pfnColorBlendEnd =
            pCtx->pfnPixelEnd = NULL;
#endif
    }

#if DBG
    static RASTFNREC* pfnLastRastFnRec = (RASTFNREC*)-1;
    if (pfnLastRastFnRec != pfnRastFnRec)
    {
        if (pfnRastFnRec)
        {
            D3D_INFO(1, "SpanInit: Fast path rasterizer %s chosen", pfnRastFnRec->pszRastDesc);
        }
        else
        {
            D3D_WARN(1, "SpanInit: No fast path rasterizer chosen");
        }
        pfnLastRastFnRec = pfnRastFnRec;
    }
#endif

    return S_OK;
}

//-----------------------------------------------------------------------------
//
// RampSpanInit
//
// Initializes derived state (function pointers and arithmetic compare values)
// based on the render state, surface type, etc. for Ramp.  This is independent of
// and quite different from the non-ramp beads.
//
//-----------------------------------------------------------------------------
HRESULT RampSpanInit(PD3DI_RASTCTX pCtx, PRAMPBEADTABLE pBeadTable)
{
    int iTargetPixelFormat,
        iZTest,
        iZWrite,
        iDither,
        iTexture,
        iTrans,
        iTextureCopy = 0,
        iTextureMonoCopy = 0,
        iTextureFormat,
        iTextureColorKey,
        iShadeMode;

    static BOOL bInitRampBeadTbl = FALSE;
    static RAMPOLDBEADS* pRampOld_BeadTbl = NULL;
    static PFNRAMPOLDTRI pfnRampOldTri = NULL;

    if (!bInitRampBeadTbl)
    {
        bInitRampBeadTbl = TRUE;
        Ramp_InitBeadTbl();

#if _X86_
        // also see if there are fast DX5 based ramp routines
        HINSTANCE hRampOldDLL = LoadLibrary("d3dramp.dll");
        if (hRampOldDLL)
        {
            pRampOld_BeadTbl = (RAMPOLDBEADS*) GetProcAddress(hRampOldDLL, "g_RampOld_BeadTbl");
            pfnRampOldTri = (PFNRAMPOLDTRI) GetProcAddress(hRampOldDLL, "RampOldTri");
        }
#endif

    }

    DoZCompareSetup(pCtx, FALSE);

    switch (pCtx->iSurfaceType)
    {
    default :
        SPIDPFM((SPIM_INVALID,"Invalid target surface type, "
                 "iSurfaceType == 0x%x\n",
                 pCtx->iSurfaceType));
        return DDERR_INVALIDPARAMS;
    case RR_STYPE_PALETTE8:
        iTargetPixelFormat = 0;
        break;
    case RR_STYPE_B5G6R5:
    case RR_STYPE_B5G5R5:
    case RR_STYPE_B5G5R5A1:
        iTargetPixelFormat = 1;
        break;
    case RR_STYPE_B8G8R8X8:
    case RR_STYPE_B8G8R8A8:
    case RR_STYPE_B8G8R8:
        iTargetPixelFormat = 2;
        break;
    }
    iZTest = pCtx->pdwRenderState[D3DRENDERSTATE_ZENABLE] ? 1 : 0;
    iZWrite = pCtx->pdwRenderState[D3DRENDERSTATE_ZWRITEENABLE] ? 1 : 0;
    iDither = pCtx->pdwRenderState[D3DRENDERSTATE_DITHERENABLE] ? 1 : 0;

    // are we texturing at all?
    if (pCtx->cActTex == 0)
    {
        iTexture = 0;
        iTextureFormat = 0;
        iTextureColorKey = pCtx->pdwRenderState[D3DRENDERSTATE_COLORKEYENABLE];
    }
    else
    {
        iTexture =
            pCtx->pdwRenderState[D3DRENDERSTATE_TEXTUREPERSPECTIVE] ? 9 : 1;

        // values needed to chose TexRead routine
        switch(pCtx->pTexture[0]->Format)
        {
        case D3DI_SPTFMT_PALETTE4 :
            if (pCtx->pTexture[0]->pPalette == NULL)
            {
                D3D_ERR("(Rast) NULL palette in paletted texture");
                return DDERR_INVALIDPARAMS;
            }
            iTextureFormat = 0;
            break;
        case D3DI_SPTFMT_B5G6R5:
        case D3DI_SPTFMT_B5G5R5:
        case D3DI_SPTFMT_B5G5R5A1:
            if (pCtx->pdwRenderState[D3DRENDERSTATE_TEXTUREMAPBLEND]
                 == D3DTBLEND_COPY)
            {
                iTextureFormat = 2;
                break;
            }
        default :
            SPIDPFM((SPIM_INVALID,"Invalid texture surface bit count, "
                "Format == 0x%x\n",(DWORD) pCtx->pTexture[0]->Format));
            return DDERR_INVALIDPARAMS;
        case D3DI_SPTFMT_PALETTE8 :
            if (pCtx->pTexture[0]->pPalette == NULL)
            {
                D3D_ERR("(Rast) NULL palette in paletted texture");
                return DDERR_INVALIDPARAMS;
            }
            iTextureFormat = 1;
            break;
        }

        iTexture += iTextureFormat;

        if ((pCtx->pdwRenderState[D3DRENDERSTATE_COLORKEYENABLE] ||
             pCtx->pdwRenderState[D3DRENDERSTATE_ALPHABLENDENABLE]) &&
             ((pCtx->pTexture[0]->uFlags & D3DI_SPANTEX_HAS_TRANSPARENT) != 0))
        {
            iTextureColorKey = 1;
            iTexture += 2;
        }
        else
        {
            iTextureColorKey = 0;
        }

        if (pCtx->pdwRenderState[D3DRENDERSTATE_TEXTUREMAPBLEND] ==
            D3DTBLEND_COPY)
        {
            iTextureCopy = 1;
            if ( (D3DI_SPTFMT_PALETTE4 == pCtx->pTexture[0]->Format) ||
                 (D3DI_SPTFMT_PALETTE8 == pCtx->pTexture[0]->Format) )
            {
                iTextureMonoCopy = 1;
            }
            else
            {
                iTextureMonoCopy = 2;
            }
            iTexture += 4;
        }
    }

    iTrans = pCtx->pdwRenderState[D3DRENDERSTATE_ALPHABLENDENABLE] ||
        iTextureColorKey;

    switch (pCtx->pdwRenderState[D3DRENDERSTATE_SHADEMODE])
    {
    case D3DSHADE_FLAT :
        iShadeMode = 0;
        break;
    default :
        SPIDPFM((SPIM_INVALID,"Invalid renderstate value, "
                 "D3DRENDERSTATE_SHADEMODE == 0x%x\n",
                 pCtx->pdwRenderState[D3DRENDERSTATE_SHADEMODE]));
    case D3DSHADE_GOURAUD :
    case D3DSHADE_PHONG :
        iShadeMode = 1;
        break;
    }

#if DBG
    static PFNRAMPOLD pfnRampOldOld = NULL;
#endif

    // see if we can use an old DX5 ramp assembly routine
    if ( (pRampOld_BeadTbl) &&
         (iTargetPixelFormat <= 1) && (iDither == 0) &&
         ((iTexture == 0) || ((iTextureFormat == 1) && (iTextureCopy == 0))) )
    {

        int iRampOldTexture = 0;
        if (iTexture)
        {
            if (iTexture >= 9)
            {
                iRampOldTexture = 2;
            }
            else
            {
                iRampOldTexture = 1;
            }
        }

        int iRampOldTrans = iTrans;
        if (iRampOldTexture)
        {
            iRampOldTrans = iTextureColorKey;
        }

        pCtx->pfnRampOld = pRampOld_BeadTbl->pfnRampOld[iTargetPixelFormat][iZTest][iShadeMode][iRampOldTexture][iRampOldTrans];
        if (pCtx->pfnRampOld)
        {
            pCtx->pfnRampOldTri = pfnRampOldTri;
        }
    }

#if DBG
    if ((pfnRampOldOld == NULL) && (pCtx->pfnRampOld != NULL))
    {
        D3D_INFO(1, "Starting to use DX5 Ramp routines.");
        pfnRampOldOld = pCtx->pfnRampOld;
    }

    if ((pfnRampOldOld != NULL) && (pCtx->pfnRampOld == NULL))
    {
        D3D_INFO(1, "Starting to use DX6 Ramp routines.");
// Uncomment this to see why DX5 rasterizer was not chosen
//#define WHY_IS_RAMP_SLOW_DEBUG 1
//
#if WHY_IS_RAMP_SLOW_DEBUG
        D3D_INFO(1, "Not using DX5 Ramp routines because:");
        D3D_INFO(1, "    pRampOld_BeadTbl 0x%x, iTargetPixelFormat %d, iDither %d",
                 pRampOld_BeadTbl, iTargetPixelFormat, iDither);
        D3D_INFO(1, "    iTexture %d, iTextureFormat %d, iTextureCopy %d",
                 iTexture, iTextureFormat, iTextureCopy);
        D3D_INFO(1, "    pCtx->pfnRampOld 0x%x, iZTest %d, iShadeMode %d, iTrans %d",
                 pCtx->pfnRampOld, iZTest, iShadeMode, iTrans);
#endif

        pfnRampOldOld = pCtx->pfnRampOld;
    }
#endif

    // Select TexRead routine.
    pCtx->pfnTexRead[0] =
        pBeadTable->pTexReadBeads->pfnTexRead[iTextureCopy][iTextureColorKey]
        [iTextureFormat];

    // Select Mono routine.
    pCtx->pfnLoopEnd = pBeadTable->pMonoBeads->pfnMono[iTextureMonoCopy];

    // Select Begin routine.
    pCtx->pfnBegin = pBeadTable->pBeginBeads->pfnBegin[0];

    // Select RenderSpans routine.
    // Specialized beads can only be used when:
    //    Z compare is less-equal.
    //    Target surface is 8 or 16 bit.
    //    When in COPY mode, target surface is 8.
    if ((iZTest &&
         pCtx->pdwRenderState[D3DRENDERSTATE_ZFUNC] != D3DCMP_LESSEQUAL) ||
        iTargetPixelFormat > 1 ||
        iTextureMonoCopy > 1)
    {
        pCtx->pfnRenderSpans = pBeadTable->pfnRenderSpansAny;
    }
    else
    {
        pCtx->pfnRenderSpans = pBeadTable->pRenderSpansBeads->pfnRenderSpans
            [iTexture][iShadeMode][iTrans][iDither][iZWrite][iZTest]
            [iTargetPixelFormat];
    }

#define DBG_RAMPCHOICE
// #define DBG_RAMPCHOICE_ALL
#ifdef DBG_RAMPCHOICE
#ifndef DBG_RAMPCHOICE_ALL
    static BOOL bShowedChoice = FALSE;
#endif
    char msg[80];
    static UINT32 iOldRampRsIndex = 0xffffffff;
    UINT32 iRampRsIndex;

    iRampRsIndex =
        iTargetPixelFormat +
        iZTest * RAMPFORMAT_NUM +
        iZWrite * (RAMPZTEST_NUM * RAMPFORMAT_NUM) +
        iDither * (RAMPZWRITE_NUM * RAMPZTEST_NUM * RAMPFORMAT_NUM) +
        iTrans * (RAMPDITHER_NUM * RAMPZWRITE_NUM * RAMPZTEST_NUM *
                  RAMPFORMAT_NUM) +
        iShadeMode * (RAMPTRANS_NUM * RAMPDITHER_NUM * RAMPZWRITE_NUM *
                      RAMPZTEST_NUM * RAMPFORMAT_NUM) +
        iTexture * (RAMPSHADEMODE_NUM * RAMPTRANS_NUM * RAMPDITHER_NUM *
                    RAMPZWRITE_NUM * RAMPZTEST_NUM * RAMPFORMAT_NUM);
#ifndef DBG_RAMPCHOICE_ALL
    if (!bShowedChoice)
#endif
    {
        if (iRampRsIndex != iOldRampRsIndex)
        {
            if (pCtx->pfnRenderSpans == pBeadTable->pfnRenderSpansAny)
            {
                OutputDebugStringA("!! GENERIC RAMP !!: ");
#ifndef DBG_RAMPCHOICE_ALL
                bShowedChoice = TRUE;
#else
            }
#endif
            sprintf(msg, "Ramp %d:%d:%d:%d:%d:%d:%d = %d\n",
                    iTexture, iShadeMode, iTrans, iDither, iZWrite, iZTest,
                    iTargetPixelFormat, iRampRsIndex);
            OutputDebugStringA(msg);
            iOldRampRsIndex = iRampRsIndex;
#ifndef DBG_RAMPCHOICE_ALL
            }
#endif
        }
    }
#endif

    return S_OK;
}