|
|
///////////////////////////////////////////////////////////////////////////////
// Copyright (C) Microsoft Corporation, 2000.
//
// pixshade.cpp
//
// Direct3D Reference Device - Pixel Shader
//
///////////////////////////////////////////////////////////////////////////////
#include "pch.cpp"
#pragma hdrstop
//-----------------------------------------------------------------------------
RDPShader::RDPShader(void){ m_pRD = NULL; m_pCode = NULL; m_CodeSize = 0; m_cActiveTextureStages = 0; m_ReferencedTexCoordMask = 0; m_cInst = 0; m_pInst = NULL; m_cConstDefs = 0; m_pConstDefs = NULL;}
//-----------------------------------------------------------------------------
RDPShader::~RDPShader(){ if (NULL != m_pCode) delete[] m_pCode; if (NULL != m_pInst) delete[] m_pInst; if (NULL != m_pConstDefs) delete[] m_pConstDefs;}
#define _DWordCount() (pToken - pCode)
#define _RegisterNeedsToBeInitializedWithTexcoords(Reg) (*pReferencedTexCoordMask)|=(1<<Reg);
//-----------------------------------------------------------------------------
//
// UpdateReferencedTexCoords
//
// Called for each instruction while parsing a 1.3 pixelshader.
// Updates pReferencedTexCoordMask (bitfield) to represent
// which texture coordinate sets are actually used by the shader.
// This is used to eliminate unnecessary attribute setup/sampling during
// primitive rasterization.
//
//-----------------------------------------------------------------------------
void UpdateReferencedTexCoords(PixelShaderInstruction* pInst, DWORD* pReferencedTexCoordMask ){ switch( pInst->Opcode & D3DSI_OPCODE_MASK ) { case D3DSIO_TEX: case D3DSIO_TEXCOORD: case D3DSIO_TEXDEPTH: { for( UINT i = 0; i < 3; i++ ) { UINT RegNum = pInst->SrcParam[i] & 0xFF; if( D3DSPR_TEXTURE == (pInst->SrcParam[i] & D3DSP_REGTYPE_MASK) ) _RegisterNeedsToBeInitializedWithTexcoords(RegNum); } } break; case D3DSIO_TEXKILL: // treat dest param as source
{ UINT RegNum = pInst->DstParam & 0xFF; if( D3DSPR_TEXTURE == (pInst->DstParam & D3DSP_REGTYPE_MASK) ) _RegisterNeedsToBeInitializedWithTexcoords(RegNum); } break; }}
void CalculateSourceReadMasks(PixelShaderInstruction* pInst, BYTE* pSourceReadMasks, BOOL bAfterSwizzle, DWORD dwVersion){ UINT i, j; DWORD Opcode = pInst->Opcode & D3DSI_OPCODE_MASK; BYTE ComponentMask[4]= {RDPS_COMPONENTMASK_0, RDPS_COMPONENTMASK_1, RDPS_COMPONENTMASK_2, RDPS_COMPONENTMASK_3};
for( i = 0; i < pInst->SrcParamCount; i++ ) { BYTE NeededComponents; BYTE ReadComponents = 0;
switch( Opcode ) { case D3DSIO_TEX: // only in ps.1.4 does texld have source parameter
if( D3DPS_VERSION(1,4) == dwVersion ) { // for ps.1.4, texld has a source parameter
NeededComponents = RDPS_COMPONENTMASK_0 | RDPS_COMPONENTMASK_1 | RDPS_COMPONENTMASK_2; } else // versions < ps.1.4 don't have a src param on tex, so we shouldn't get here. But maybe in ps.2.0...
{ NeededComponents = RDPS_COMPONENTMASK_0 | RDPS_COMPONENTMASK_1 | RDPS_COMPONENTMASK_2 | RDPS_COMPONENTMASK_3; } break; case D3DSIO_TEXCOORD: if( D3DPS_VERSION(1,4) == dwVersion ) { // for ps.1.4, texcrd has a source parameter
NeededComponents = RDPS_COMPONENTMASK_0 | RDPS_COMPONENTMASK_1 | RDPS_COMPONENTMASK_2; } else // versions < ps.1.4 don't have a src param on texcoord, so we shouldn't get here. But maybe in ps.2.0...
{ NeededComponents = RDPS_COMPONENTMASK_0 | RDPS_COMPONENTMASK_1 | RDPS_COMPONENTMASK_2 | RDPS_COMPONENTMASK_3; } break; case D3DSIO_TEXBEM: case D3DSIO_TEXBEML: NeededComponents = RDPS_COMPONENTMASK_0 | RDPS_COMPONENTMASK_1; break; case D3DSIO_DP3: NeededComponents = RDPS_COMPONENTMASK_0 | RDPS_COMPONENTMASK_1 | RDPS_COMPONENTMASK_2; break; case D3DSIO_DP4: NeededComponents = RDPS_COMPONENTMASK_0 | RDPS_COMPONENTMASK_1 | RDPS_COMPONENTMASK_2 | RDPS_COMPONENTMASK_3; break; case D3DSIO_BEM: // ps.1.4
NeededComponents = RDPS_COMPONENTMASK_0 | RDPS_COMPONENTMASK_1; break; default: // standard component-wise instruction,
// OR an op we know reads .rgba and we also know it will be validated to .rgba writemask
NeededComponents = (pInst->DstParam & D3DSP_WRITEMASK_ALL) >> RDPS_COMPONENTMASK_SHIFT; break; }
if( bAfterSwizzle ) { pSourceReadMasks[i] = NeededComponents; } else { // Figure out which components of this source parameter are read (taking into account swizzle)
for(j = 0; j < 4; j++) { if( NeededComponents & ComponentMask[j] ) ReadComponents |= ComponentMask[((pInst->SrcParam[i] & D3DSP_SWIZZLE_MASK) >> (D3DVS_SWIZZLE_SHIFT + 2*j)) & 0x3]; } pSourceReadMasks[i] = ReadComponents; } }}
void RDPSRegister::Set(RDPS_REGISTER_TYPE RegType, UINT RegNum, RefRast* pRast){ m_RegType = RegType; m_RegNum = RegNum;
UINT MaxRegNum = 0;
switch( RegType ) { case RDPSREG_INPUT: MaxRegNum = RDPS_MAX_NUMINPUTREG - 1; m_pReg = pRast->m_InputReg[RegNum]; break; case RDPSREG_TEMP: MaxRegNum = RDPS_MAX_NUMTEMPREG - 1; m_pReg = pRast->m_TempReg[RegNum]; break; case RDPSREG_CONST: MaxRegNum = RDPS_MAX_NUMCONSTREG - 1; m_pReg = pRast->m_ConstReg[RegNum]; break; case RDPSREG_TEXTURE: MaxRegNum = RDPS_MAX_NUMTEXTUREREG - 1; m_pReg = pRast->m_TextReg[RegNum]; break; case RDPSREG_POSTMODSRC: MaxRegNum = RDPS_MAX_NUMPOSTMODSRCREG - 1; m_pReg = pRast->m_PostModSrcReg[RegNum]; break; case RDPSREG_SCRATCH: MaxRegNum = RDPS_MAX_NUMSCRATCHREG - 1; m_pReg = pRast->m_ScratchReg[RegNum]; break; case RDPSREG_QUEUEDWRITE: MaxRegNum = RDPS_MAX_NUMQUEUEDWRITEREG - 1; m_pReg = pRast->m_QueuedWriteReg[RegNum]; break; case RDPSREG_ZERO: MaxRegNum = 0; m_pReg = pRast->m_ZeroReg; break; case RDPSREG_ONE: MaxRegNum = 0; m_pReg = pRast->m_OneReg; break; case RDPSREG_TWO: MaxRegNum = 0; m_pReg = pRast->m_TwoReg; break; default: m_pReg = NULL; _ASSERT(FALSE,"RDPSRegister::SetReg - Unknown register type."); break; } if( RegNum > MaxRegNum ) { _ASSERT(FALSE,"RDPSRegister::SetReg - Register number too high."); } return;}
//-----------------------------------------------------------------------------
//
// Initialize
//
// - Copies pixel shader token stream from DDI token stream.
// - Counts the number of active texture stages for m_cActiveTextureStages.
// - Translates shader into "RISC" instruction set to be executed
// by refrast's shader VM
//
//-----------------------------------------------------------------------------
HRESULTRDPShader::Initialize( RefDev* pRD, DWORD* pCode, DWORD ByteCodeSize, D3DCAPS8* pCaps ){ m_pRD = pRD; m_CodeSize = ByteCodeSize/4; // bytecount -> dword count
FLOAT fMin = -(pCaps->MaxPixelShaderValue); FLOAT fMax = (pCaps->MaxPixelShaderValue);
// ------------------------------------------------------------------------
//
// First pass through shader to find the number of instructions,
// figure out how many constants there are.
//
// ------------------------------------------------------------------------
{ DWORD* pToken = pCode; pToken++; // version token
while (*pToken != D3DPS_END()) { DWORD Inst = *pToken; if (*pToken++ & (1L<<31)) // instruction token
{ DPFERR("PixelShader Token #%d: instruction token error",_DWordCount()); return E_FAIL; } if ( (Inst & D3DSI_OPCODE_MASK) == D3DSIO_COMMENT ) { pToken += (Inst & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT; m_cInst++; } else if( (Inst & D3DSI_OPCODE_MASK) == D3DSIO_DEF ) { m_cConstDefs++; pToken += 5; } else { if (*pToken & (1L<<31)) pToken++; // destination param token
while (*pToken & (1L<<31)) pToken++; // source param tokens
m_cInst++; } if (_DWordCount() > (int)m_CodeSize) { DPFERR("PixelShader(%d tokens, %d expected): count error",_DWordCount(),m_CodeSize); return E_FAIL; } } pToken++; // step over END token
if (_DWordCount() != (int)m_CodeSize) { DPFERR("PixelShader(%d tokens, %d expected): count error",_DWordCount(),m_CodeSize); return E_FAIL; }
// make copy of original shader
m_pCode = new DWORD[m_CodeSize]; if (NULL == m_pCode) return E_OUTOFMEMORY; memcpy( m_pCode, pCode, ByteCodeSize );
// allocate instruction array
m_pInst = new PixelShaderInstruction[m_cInst]; if (NULL == m_pInst) return E_OUTOFMEMORY; memset( m_pInst, 0x0, sizeof(PixelShaderInstruction)*m_cInst );
m_pConstDefs = new ConstDef[m_cConstDefs]; if (NULL == m_pConstDefs) return E_OUTOFMEMORY; }
// ------------------------------------------------------------------------
//
// Second pass through shader to:
// - produce a list of instructions, each one including opcodes,
// comments, and disassembled text for access by shader debuggers.
// - figure out the TSS # used (if any) by each instruction
// - figure out the max texture stage # used
// - figure out when the ref. pixel shader executor should
// queue writes up and when to flush the queue, in order to
// simulate co-issue.
// - figure out which texture coordinate sets get used
// - process constant DEF instructions into a list that can be
// executed whenever SetPixelShader is done.
//
// ------------------------------------------------------------------------
{ DWORD* pToken = m_pCode; PixelShaderInstruction* pInst = m_pInst; PixelShaderInstruction* pPrevious_NonTrivial_Inst = NULL; pToken++; // skip over version
BOOL bMinimizeReferencedTexCoords;
if( (D3DPS_VERSION(1,3) >= *pCode) || (D3DPS_VERSION(254,254) == *pCode ) )//legacy
{ bMinimizeReferencedTexCoords = FALSE; } else { bMinimizeReferencedTexCoords = TRUE; }
UINT CurrConstDef = 0;
while (*pToken != D3DPS_END()) { switch( (*pToken) & D3DSI_OPCODE_MASK ) { case D3DSIO_COMMENT: pInst->Opcode = *pToken; pInst->pComment = (pToken+1); pInst->CommentSize = ((*pToken) & D3DSI_COMMENTSIZE_MASK) >> D3DSI_COMMENTSIZE_SHIFT; pToken += (pInst->CommentSize+1); pInst++; continue; case D3DSIO_DEF: { pToken++; m_pConstDefs[CurrConstDef].RegNum = (*pToken++) & D3DSP_REGNUM_MASK;
// clamp constants on input to range of values in pixel shaders
for( UINT i = 0; i < 4; i++ ) { m_pConstDefs[CurrConstDef].f[i] = MAX( fMin, MIN( fMax, *(FLOAT*)pToken)); pToken++; }
CurrConstDef++; continue; } case D3DSIO_NOP: // get disasm string
PixelShaderInstDisAsm( pInst->Text, 128, pToken, 0x0 ); pInst->Opcode = *pToken++; pInst++; continue; }
// get disasm string
PixelShaderInstDisAsm( pInst->Text, 128, pToken, 0x0 );
// get next instruction and parameters
pInst->Opcode = *pToken++;
pInst->SrcParamCount = 0; if (*pToken & (1L<<31)) { pInst->DstParam = *pToken++; } while (*pToken & (1L<<31)) { pInst->SrcParam[pInst->SrcParamCount++] = *pToken++; }
// process TEX ops
//
BOOL bLegacyTexOp = FALSE; switch (pInst->Opcode & D3DSI_OPCODE_MASK) { default: break; case D3DSIO_TEXBEM_LEGACY: case D3DSIO_TEXBEML_LEGACY: bLegacyTexOp = TRUE; // fall through
case D3DSIO_TEXCOORD: case D3DSIO_TEXKILL: case D3DSIO_TEX: case D3DSIO_TEXBEM: case D3DSIO_TEXBEML: case D3DSIO_TEXREG2AR: case D3DSIO_TEXREG2GB: case D3DSIO_TEXM3x2PAD: case D3DSIO_TEXM3x2TEX: case D3DSIO_TEXM3x3PAD: case D3DSIO_TEXM3x3TEX: case D3DSIO_TEXM3x3SPEC: case D3DSIO_TEXM3x3VSPEC: case D3DSIO_TEXM3x2DEPTH: case D3DSIO_TEXDP3: case D3DSIO_TEXREG2RGB: case D3DSIO_TEXDEPTH: case D3DSIO_TEXDP3TEX: case D3DSIO_TEXM3x3: pInst->bTexOp = TRUE; break; } if (pInst->bTexOp) { // update stage count and assign ptr to TSS for this op
if (bLegacyTexOp) { m_cActiveTextureStages = max(m_cActiveTextureStages,(pInst->DstParam&D3DSP_REGNUM_MASK)+1); pInst->uiTSSNum = (pInst->DstParam&D3DSP_REGNUM_MASK)-1; } else { UINT Stage; BOOL bStageUsed = TRUE;
switch(pInst->Opcode & D3DSI_OPCODE_MASK) { case D3DSIO_TEXCOORD: case D3DSIO_TEXDEPTH: case D3DSIO_TEXKILL: if( bMinimizeReferencedTexCoords ) { bStageUsed = FALSE; break; } // falling through
case D3DSIO_TEX: default: Stage = pInst->DstParam&D3DSP_REGNUM_MASK; break; }
if( bStageUsed ) { m_cActiveTextureStages = max(m_cActiveTextureStages,Stage+1); pInst->uiTSSNum = Stage; } } }
if( pPrevious_NonTrivial_Inst ) { // Queue write of last instruction if the current instruction has the
// COISSUE flag.
if( pInst->Opcode & D3DSI_COISSUE ) { pPrevious_NonTrivial_Inst->bQueueWrite = TRUE; }
// Flush writes after the previous instruction if it had the COISSUE
// flag and the current instruction doesn't have it.
if( !(pInst->Opcode & D3DSI_COISSUE) && (pPrevious_NonTrivial_Inst->Opcode & D3DSI_COISSUE) ) { pPrevious_NonTrivial_Inst->bFlushQueue = TRUE; } }
pPrevious_NonTrivial_Inst = pInst;
if( bMinimizeReferencedTexCoords ) { UpdateReferencedTexCoords(pInst, &m_ReferencedTexCoordMask); }
pInst++; }
if( !bMinimizeReferencedTexCoords ) { m_ReferencedTexCoordMask = (1<<m_cActiveTextureStages) - 1; } }
// ------------------------------------------------------------------------
//
// Third pass through the shader (through the list of instructions made
// in the last pass) to translate instructions into a more basic ("RISC")
// instruction set for the refrast executor.
//
// ------------------------------------------------------------------------
{ #define _Set(RegType, RegNum) Set(RegType,RegNum,pRast)
#define _NewPSInst(__INST) \
{ \ RDPSOffset = pRDPSInst - pRDPSInstBuffer + LastRDPSInstSize; \ m_RDPSInstBuffer.SetGrowSize(MAX(512,RDPSOffset)); \ if( FAILED(m_RDPSInstBuffer.Grow(RDPSOffset + sizeof(__INST##_PARAMS)))) \ {return E_OUTOFMEMORY;} \ pRDPSInstBuffer = &m_RDPSInstBuffer[0]; \ pRDPSInst = pRDPSInstBuffer + RDPSOffset; \ ((__INST##_PARAMS UNALIGNED64*)pRDPSInst)->Inst = __INST; \ LastRDPSInstSize = sizeof(__INST##_PARAMS); \ }
#define _InstParam(__INST) (*(__INST##_PARAMS UNALIGNED64*)pRDPSInst)
#define _NoteInstructionEvent _NewPSInst(RDPSINST_NEXTD3DPSINST); \
_InstParam(RDPSINST_NEXTD3DPSINST).pInst = pInst;
#define _EnterQuadPixelLoop if(!bInQuadPixelLoop) \
{ \ _NewPSInst(RDPSINST_QUADLOOPBEGIN); \ RDPSLoopOffset = RDPSOffset + sizeof(RDPSINST_QUADLOOPBEGIN_PARAMS); \ bInQuadPixelLoop = TRUE; \ }
#define _LeaveQuadPixelLoop if(bInQuadPixelLoop) \
{ \ _NewPSInst(RDPSINST_QUADLOOPEND); \ _InstParam(RDPSINST_QUADLOOPEND).JumpBackByOffset = \ RDPSOffset - RDPSLoopOffset;\ bInQuadPixelLoop = FALSE; \ }
#define _EmitDstMod(__dstReg,__mask) _NewPSInst(RDPSINST_DSTMOD); \
_InstParam(RDPSINST_DSTMOD).DstReg = __dstReg; \ _InstParam(RDPSINST_DSTMOD).WriteMask = __mask; \ _InstParam(RDPSINST_DSTMOD).fScale = DstScale; \ _InstParam(RDPSINST_DSTMOD).fRangeMin = DstRange[0]; \ _InstParam(RDPSINST_DSTMOD).fRangeMax = DstRange[1];
// Th macro _EmitProj emits instructions to do the following:
// - Put reciprocal of source (x,y,z,w) component __COMPONENT (ex. w) into scratch register 0 component (for w example:) 4
// - Replicate reciprocal to rgb components of scratch register 0 (w example yields: 1/,1/w,1/w, <--1/w)
// - Multiply source register register by scratch register (x/w,y/w,z/w,1) and put the result into the dest register.
#define _EmitProj(__DESTTYPE,__DESTNUM,__SRCTYPE,__SRCNUM,__COMPONENT) \
_NewPSInst(RDPSINST_RCP); \ _InstParam(RDPSINST_RCP).DstReg._Set(RDPSREG_SCRATCH,0); \ _InstParam(RDPSINST_RCP).SrcReg0._Set(__SRCTYPE,__SRCNUM); \ _InstParam(RDPSINST_RCP).bSrcReg0_Negate = FALSE; \ _InstParam(RDPSINST_RCP).WriteMask = __COMPONENT; \ \ _NewPSInst(RDPSINST_SWIZZLE); \ _InstParam(RDPSINST_SWIZZLE).DstReg._Set(RDPSREG_SCRATCH,0); \ _InstParam(RDPSINST_SWIZZLE).SrcReg0._Set(RDPSREG_SCRATCH,0); \ _InstParam(RDPSINST_SWIZZLE).WriteMask = RDPS_COMPONENTMASK_0 | RDPS_COMPONENTMASK_1 \ | RDPS_COMPONENTMASK_2 | RDPS_COMPONENTMASK_3; \ _InstParam(RDPSINST_SWIZZLE).Swizzle = \ (RDPS_COMPONENTMASK_0 == __COMPONENT) ? RDPS_REPLICATERED : \ (RDPS_COMPONENTMASK_1 == __COMPONENT) ? RDPS_REPLICATEGREEN : \ (RDPS_COMPONENTMASK_2 == __COMPONENT) ? RDPS_REPLICATEBLUE : RDPS_REPLICATEALPHA; \ \ _NewPSInst(RDPSINST_MUL); \ _InstParam(RDPSINST_MUL).DstReg._Set(__DESTTYPE,__DESTNUM); \ _InstParam(RDPSINST_MUL).SrcReg0._Set(RDPSREG_SCRATCH,0); \ _InstParam(RDPSINST_MUL).SrcReg1._Set(__SRCTYPE,__SRCNUM); \ _InstParam(RDPSINST_MUL).bSrcReg0_Negate = FALSE; \ _InstParam(RDPSINST_MUL).bSrcReg1_Negate = FALSE; \ _InstParam(RDPSINST_MUL).WriteMask = \ (RDPS_COMPONENTMASK_0 == __COMPONENT) ? RDPS_COMPONENTMASK_0 : \ (RDPS_COMPONENTMASK_1 == __COMPONENT) ? RDPS_COMPONENTMASK_0 | RDPS_COMPONENTMASK_1 : \ (RDPS_COMPONENTMASK_2 == __COMPONENT) ? RDPS_COMPONENTMASK_0 | RDPS_COMPONENTMASK_1 | \ RDPS_COMPONENTMASK_2 : RDPS_COMPONENTMASK_ALL;
BYTE ComponentSwizzle[4] = {RDPS_REPLICATERED, RDPS_REPLICATEGREEN, RDPS_REPLICATEBLUE, RDPS_REPLICATEALPHA}; BYTE ComponentMask[4] = {RDPS_COMPONENTMASK_0, RDPS_COMPONENTMASK_1, RDPS_COMPONENTMASK_2, RDPS_COMPONENTMASK_3}; int QueueIndex = -1; // current queue location (for staging results when simulating coissue)
UINT i; BOOL bInQuadPixelLoop = FALSE;
RefRast* pRast = &m_pRD->m_Rast;
RDPSRegister ZeroReg; ZeroReg._Set(RDPSREG_ZERO,0); RDPSRegister OneReg; OneReg._Set(RDPSREG_ONE,0); RDPSRegister TwoReg; TwoReg._Set(RDPSREG_TWO,0);
// destination parameter controls
RDPSRegister DstReg; FLOAT DstScale; // Result Shift Scale - +/- 2**n only
FLOAT DstRange[2]; // clamp dest to this range
BYTE DstWriteMask; // per-component write mask
PRGBAVEC pDstReg; // address of dest register
// source parameter controls
RDPSRegister SrcReg[3];
BYTE* pRDPSInstBuffer = NULL; BYTE* pRDPSInst = pRDPSInstBuffer; size_t RDPSOffset, RDPSLoopOffset; size_t LastRDPSInstSize = 0;
DWORD Version = *m_pCode; for (UINT CurrentPSInst=0; CurrentPSInst < m_cInst; CurrentPSInst++) { PixelShaderInstruction* pInst = m_pInst + CurrentPSInst; DWORD Opcode = pInst->Opcode & D3DSI_OPCODE_MASK; DWORD SrcSwizzle[3]; BYTE SourceReadMasks[3]; BYTE SourceReadMasksAfterSwizzle[3]; BOOL bForceNeg1To1Clamp[3] = {FALSE, FALSE, FALSE}; BOOL bEmitQueueWrite = FALSE; RDPSRegister QueuedWriteDstReg; BYTE QueuedWriteDstWriteMask; BYTE ProjComponent[3] = {0,0,0}; BOOL bEmitProj[3] = {FALSE, FALSE, FALSE}; BOOL bProjOnEval[3] = {FALSE, FALSE, FALSE}; BOOL bEmitSrcMod[3] = {FALSE, FALSE, FALSE}; BOOL bEmitSwizzle[3] = {FALSE, FALSE, FALSE}; BOOL bSrcNegate[3] = {FALSE, FALSE, FALSE}; BOOL bSrcBias[3] = {FALSE, FALSE, FALSE}; BOOL bSrcTimes2[3] = {FALSE, FALSE, FALSE}; BOOL bSrcComplement[3] = {FALSE, FALSE, FALSE}; switch( Opcode ) { continue; case D3DSIO_DEF: // nothing to do -> DEF has already been processed out and is not an true instruction
continue; case D3DSIO_COMMENT: continue; case D3DSIO_PHASE: case D3DSIO_NOP: #if DBG
_NoteInstructionEvent #endif
continue; }
#if DBG
_NoteInstructionEvent #endif
// do some preliminary setup for this instruction
UINT RegNum = pInst->DstParam & D3DSP_REGNUM_MASK; switch (pInst->DstParam & D3DSP_REGTYPE_MASK) { case D3DSPR_TEXTURE: DstReg._Set(RDPSREG_TEXTURE, RegNum); break; case D3DSPR_TEMP: DstReg._Set(RDPSREG_TEMP, RegNum); break; default: _ASSERT( FALSE, "RDPShader::Initialize - Unexpected destination register type." ); break; }
DstWriteMask = (pInst->DstParam & D3DSP_WRITEMASK_ALL) >> RDPS_COMPONENTMASK_SHIFT;
if( pInst->bQueueWrite ) { QueueIndex++;
QueuedWriteDstReg = DstReg; QueuedWriteDstWriteMask = DstWriteMask; DstReg._Set(RDPSREG_QUEUEDWRITE,QueueIndex); _ASSERT(QueueIndex <= RDPS_MAX_NUMQUEUEDWRITEREG, "Too many queued writes in pixelshader (improperly handled co-issue)." ); bEmitQueueWrite = TRUE; }
CalculateSourceReadMasks(pInst, SourceReadMasks, FALSE,Version); CalculateSourceReadMasks(pInst, SourceReadMasksAfterSwizzle, TRUE,Version); for (i=0; i < pInst->SrcParamCount; i++) { RegNum = pInst->SrcParam[i]&D3DSP_REGNUM_MASK; switch (pInst->SrcParam[i] & D3DSP_REGTYPE_MASK) { case D3DSPR_TEMP: SrcReg[i]._Set(RDPSREG_TEMP, RegNum); break; case D3DSPR_TEXTURE: SrcReg[i]._Set(RDPSREG_TEXTURE, RegNum); break; case D3DSPR_INPUT: SrcReg[i]._Set(RDPSREG_INPUT, RegNum); break; case D3DSPR_CONST: SrcReg[i]._Set(RDPSREG_CONST, RegNum); // Force a [-1,1] clamp after applying modifier (for constants only)
// This overrides the the standard [-MaxPixelShaderValue,MaxPixelShaderValue] clamp.
// An IHV that supports MaxPixelShaderValue > 1 forgot to do this for constants.
bForceNeg1To1Clamp[i] = TRUE; break; default: _ASSERT( FALSE, "RDPShader::Initialize - Unexpected source register type." ); break; }
if( (D3DSPSM_DZ == (pInst->SrcParam[i] & D3DSP_SRCMOD_MASK)) || (D3DSPSM_DW == (pInst->SrcParam[i] & D3DSP_SRCMOD_MASK)) ) { if( D3DSPSM_DZ == (pInst->SrcParam[i] & D3DSP_SRCMOD_MASK)) { ProjComponent[i] = RDPS_COMPONENTMASK_2; } else // _DW
{ if( D3DPS_VERSION(1,4) == Version ) ProjComponent[i] = RDPS_COMPONENTMASK_2; else ProjComponent[i] = RDPS_COMPONENTMASK_3; }
if( D3DSPR_TEXTURE == (pInst->SrcParam[i] & D3DSP_REGTYPE_MASK ) ) // t# register being used to represent evaluated texcoord.
{ bProjOnEval[i] = TRUE; } else bEmitProj[i] = TRUE; } else { bEmitSrcMod[i] = TRUE;
switch (pInst->SrcParam[i] & D3DSP_SRCMOD_MASK) { default: case D3DSPSM_NONE: if( !bForceNeg1To1Clamp[i] ) bEmitSrcMod[i] = FALSE; break; case D3DSPSM_NEG: bSrcNegate[i] = TRUE; // negate is not part of source modifier
if( !bForceNeg1To1Clamp[i] ) bEmitSrcMod[i] = FALSE; break; case D3DSPSM_BIAS: bSrcBias[i] = TRUE; break; case D3DSPSM_BIASNEG: bSrcNegate[i] = TRUE; bSrcBias[i] = TRUE; break; case D3DSPSM_SIGN: // _bx2
bSrcBias[i] = TRUE; bSrcTimes2[i] = TRUE; break; case D3DSPSM_SIGNNEG: // negative _bx2
bSrcNegate[i] = TRUE; // negate is not part of source modifier
bSrcBias[i] = TRUE; bSrcTimes2[i] = TRUE; break; case D3DSPSM_COMP: bSrcComplement[i] = TRUE; break; case D3DSPSM_X2: bSrcTimes2[i] = TRUE; break; case D3DSPSM_X2NEG: bSrcNegate[i] = TRUE; // negate is not part of source modifier
bSrcTimes2[i] = TRUE; break; }
_ASSERT(!(bSrcComplement[i] && (bSrcTimes2[i]||bSrcBias[i]||bSrcNegate[i])),"RDPShader::Initialize - Complement cannot be combined with other modifiers."); }
SrcSwizzle[i] = (pInst->SrcParam[i] & D3DSP_SWIZZLE_MASK) >> D3DSP_SWIZZLE_SHIFT; bEmitSwizzle[i] = (D3DSP_NOSWIZZLE != (pInst->SrcParam[i] & D3DSP_SWIZZLE_MASK)); }
// set clamp values
switch (pInst->DstParam & D3DSP_DSTMOD_MASK) { default: case D3DSPDM_NONE: if(pInst->bTexOp) { DstRange[0] = -FLT_MAX; DstRange[1] = FLT_MAX; } else { DstRange[0] = fMin; DstRange[1] = fMax; } break; case D3DSPDM_SATURATE: DstRange[0] = 0.F; DstRange[1] = 1.F; break; }
UINT ShiftScale = (pInst->DstParam & D3DSP_DSTSHIFT_MASK) >> D3DSP_DSTSHIFT_SHIFT; if (ShiftScale & 0x8) { ShiftScale = ((~ShiftScale)&0x7)+1; // negative magnitude
DstScale = 1.f/(FLOAT)(1<<ShiftScale); } else { DstScale = (FLOAT)(1<<ShiftScale); }
// finished preliminary setup, now start emitting ops...
_EnterQuadPixelLoop
if( bEmitQueueWrite ) { _NewPSInst(RDPSINST_QUEUEWRITE); _InstParam(RDPSINST_QUEUEWRITE).DstReg = QueuedWriteDstReg; _InstParam(RDPSINST_QUEUEWRITE).WriteMask = QueuedWriteDstWriteMask; }
for (i=0; i < pInst->SrcParamCount; i++) { if( bEmitProj[i] ) { _EmitProj(RDPSREG_POSTMODSRC,i,SrcReg[i].GetRegType(),SrcReg[i].GetRegNum(),ProjComponent[i]); SrcReg[i]._Set(RDPSREG_POSTMODSRC,i); }
if( bEmitSrcMod[i] ) { _NewPSInst(RDPSINST_SRCMOD); _InstParam(RDPSINST_SRCMOD).DstReg._Set(RDPSREG_POSTMODSRC,i); _InstParam(RDPSINST_SRCMOD).SrcReg0 = SrcReg[i]; _InstParam(RDPSINST_SRCMOD).WriteMask = SourceReadMasks[i]; _InstParam(RDPSINST_SRCMOD).bBias = bSrcBias[i]; _InstParam(RDPSINST_SRCMOD).bTimes2 = bSrcTimes2[i]; _InstParam(RDPSINST_SRCMOD).bComplement = bSrcComplement[i]; _InstParam(RDPSINST_SRCMOD).fRangeMin = bForceNeg1To1Clamp[i] ? -1.0f : fMin; _InstParam(RDPSINST_SRCMOD).fRangeMax = bForceNeg1To1Clamp[i] ? 1.0f : fMax; SrcReg[i]._Set(RDPSREG_POSTMODSRC,i); }
if( bEmitSwizzle[i] && !bProjOnEval[i] ) { _NewPSInst(RDPSINST_SWIZZLE); _InstParam(RDPSINST_SWIZZLE).DstReg._Set(RDPSREG_POSTMODSRC,i); _InstParam(RDPSINST_SWIZZLE).SrcReg0 = SrcReg[i]; _InstParam(RDPSINST_SWIZZLE).WriteMask = SourceReadMasksAfterSwizzle[i]; _InstParam(RDPSINST_SWIZZLE).Swizzle = SrcSwizzle[i]; SrcReg[i]._Set(RDPSREG_POSTMODSRC,i); } }
switch(Opcode) { case D3DSIO_TEXCOORD: case D3DSIO_TEXKILL: { if( !( (D3DSIO_TEXKILL == Opcode) && (D3DSPR_TEMP == (pInst->DstParam & D3DSP_REGTYPE_MASK)) ) ) { UINT CoordSet = pInst->SrcParam[0] ? (pInst->SrcParam[0] & D3DSP_REGNUM_MASK) : (pInst->DstParam & D3DSP_REGNUM_MASK);
RDPSRegister CoordReg; if(bProjOnEval[0]) CoordReg._Set(RDPSREG_POSTMODSRC,0); else CoordReg = DstReg;
// For TEXCOORD, clamp 0. to 1 only there is no source parameter (ps.1.0, ps.1.1)
// For TEXKILL, never clamp
// NOTE: the TEXCOORD clamp is a temporary limitation for DX8 shader models
BOOL bTexCoordClamp = ((D3DSIO_TEXCOORD == Opcode) && (!pInst->SrcParam[0])) ? TRUE : FALSE;
_NewPSInst(RDPSINST_EVAL); _InstParam(RDPSINST_EVAL).DstReg = CoordReg; _InstParam(RDPSINST_EVAL).uiCoordSet = CoordSet; _InstParam(RDPSINST_EVAL).bIgnoreD3DTTFF_PROJECTED = TRUE; // projection disabled (unless _p modifier used -> _EmitProj below)
_InstParam(RDPSINST_EVAL).bClamp = bTexCoordClamp;
if( bProjOnEval[0] ) { if( bEmitSwizzle[0] ) { _NewPSInst(RDPSINST_SWIZZLE); _InstParam(RDPSINST_SWIZZLE).DstReg = DstReg; _InstParam(RDPSINST_SWIZZLE).SrcReg0 = CoordReg; _InstParam(RDPSINST_SWIZZLE).WriteMask = SourceReadMasksAfterSwizzle[0]; _InstParam(RDPSINST_SWIZZLE).Swizzle = SrcSwizzle[0]; } _EmitProj(DstReg.GetRegType(),DstReg.GetRegNum(),DstReg.GetRegType(),DstReg.GetRegNum(),ProjComponent[0]); }
// check version (first DWORD of code token stream), and always
// set 4th component to 1.0 for ps.1.3 or earlier
if ( D3DPS_VERSION(1,3) >= Version ) { _NewPSInst(RDPSINST_MOV); _InstParam(RDPSINST_MOV).DstReg = DstReg; _InstParam(RDPSINST_MOV).SrcReg0 = OneReg; // 1.0f
_InstParam(RDPSINST_MOV).bSrcReg0_Negate = FALSE; _InstParam(RDPSINST_MOV).WriteMask = RDPS_COMPONENTMASK_3; } }
_EmitDstMod(DstReg,DstWriteMask)
if( D3DSIO_TEXKILL == Opcode ) { _NewPSInst(RDPSINST_KILL); _InstParam(RDPSINST_KILL).DstReg = DstReg; } } break; case D3DSIO_TEX: { RDPSRegister CoordReg; BOOL bDoSampleCoords = TRUE;
UINT CoordSet = pInst->SrcParam[0] ? (pInst->SrcParam[0] & D3DSP_REGNUM_MASK) : (pInst->DstParam & D3DSP_REGNUM_MASK);
if( pInst->SrcParam[0] ) { CoordReg = SrcReg[0]; if( D3DSPR_TEMP == (pInst->SrcParam[0] & D3DSP_REGTYPE_MASK) ) bDoSampleCoords = FALSE; } else // no source param.
{ CoordReg._Set(RDPSREG_SCRATCH,0); }
if( bDoSampleCoords ) { _NewPSInst(RDPSINST_EVAL); _InstParam(RDPSINST_EVAL).DstReg = CoordReg; _InstParam(RDPSINST_EVAL).uiCoordSet = CoordSet; _InstParam(RDPSINST_EVAL).bIgnoreD3DTTFF_PROJECTED = bProjOnEval[0]; // if we have _p modifier, we do _EmitProj below
_InstParam(RDPSINST_EVAL).bClamp = FALSE; }
if( bProjOnEval[0] ) { if( bEmitSwizzle[0] ) { _NewPSInst(RDPSINST_SWIZZLE); _InstParam(RDPSINST_SWIZZLE).DstReg._Set(RDPSREG_POSTMODSRC,0); _InstParam(RDPSINST_SWIZZLE).SrcReg0 = CoordReg; _InstParam(RDPSINST_SWIZZLE).WriteMask = SourceReadMasksAfterSwizzle[0]; _InstParam(RDPSINST_SWIZZLE).Swizzle = SrcSwizzle[0]; CoordReg._Set(RDPSREG_POSTMODSRC,0); } _EmitProj(RDPSREG_POSTMODSRC,0,CoordReg.GetRegType(),CoordReg.GetRegNum(),ProjComponent[0]); CoordReg._Set(RDPSREG_POSTMODSRC,0); }
_LeaveQuadPixelLoop
PRGBAVEC pCoordReg = CoordReg.GetRegPtr();
_NewPSInst(RDPSINST_TEXCOVERAGE); _InstParam(RDPSINST_TEXCOVERAGE).uiStage = pInst->DstParam & D3DSP_REGNUM_MASK; _InstParam(RDPSINST_TEXCOVERAGE).pGradients = pRast->m_Gradients; // where to store gradients
// data from which to compute gradients. i.e.: du/dx = DUDX_0 - DUDX_1
_InstParam(RDPSINST_TEXCOVERAGE).pDUDX_0 = &pCoordReg[1][0]; // du/dx
_InstParam(RDPSINST_TEXCOVERAGE).pDUDX_1 = &pCoordReg[0][0]; _InstParam(RDPSINST_TEXCOVERAGE).pDUDY_0 = &pCoordReg[2][0]; // du/dy
_InstParam(RDPSINST_TEXCOVERAGE).pDUDY_1 = &pCoordReg[0][0]; _InstParam(RDPSINST_TEXCOVERAGE).pDVDX_0 = &pCoordReg[1][1]; // dv/dx
_InstParam(RDPSINST_TEXCOVERAGE).pDVDX_1 = &pCoordReg[0][1]; _InstParam(RDPSINST_TEXCOVERAGE).pDVDY_0 = &pCoordReg[2][1]; // dv/dy
_InstParam(RDPSINST_TEXCOVERAGE).pDVDY_1 = &pCoordReg[0][1]; _InstParam(RDPSINST_TEXCOVERAGE).pDWDX_0 = &pCoordReg[1][2]; // dw/dx
_InstParam(RDPSINST_TEXCOVERAGE).pDWDX_1 = &pCoordReg[0][2]; _InstParam(RDPSINST_TEXCOVERAGE).pDWDY_0 = &pCoordReg[2][2]; // dw/dy
_InstParam(RDPSINST_TEXCOVERAGE).pDWDY_1 = &pCoordReg[0][2];
_EnterQuadPixelLoop
_NewPSInst(RDPSINST_SAMPLE); _InstParam(RDPSINST_SAMPLE).DstReg = DstReg; _InstParam(RDPSINST_SAMPLE).CoordReg = CoordReg; _InstParam(RDPSINST_SAMPLE).uiStage = pInst->DstParam & D3DSP_REGNUM_MASK;
_EmitDstMod(DstReg,DstWriteMask) } break; case D3DSIO_TEXDP3: case D3DSIO_TEXDP3TEX: { RDPSRegister CoordReg; CoordReg._Set(RDPSREG_SCRATCH,0);
_NewPSInst(RDPSINST_EVAL); _InstParam(RDPSINST_EVAL).DstReg = CoordReg; _InstParam(RDPSINST_EVAL).uiCoordSet = pInst->DstParam & D3DSP_REGNUM_MASK; _InstParam(RDPSINST_EVAL).bIgnoreD3DTTFF_PROJECTED = TRUE; // no projection
_InstParam(RDPSINST_EVAL).bClamp = FALSE;
if( D3DSIO_TEXDP3 == Opcode ) { _NewPSInst(RDPSINST_DP3); _InstParam(RDPSINST_DP3).DstReg = DstReg; _InstParam(RDPSINST_DP3).SrcReg0 = SrcReg[0]; _InstParam(RDPSINST_DP3).SrcReg1 = CoordReg; _InstParam(RDPSINST_DP3).bSrcReg0_Negate = FALSE; _InstParam(RDPSINST_DP3).bSrcReg1_Negate = FALSE; _InstParam(RDPSINST_DP3).WriteMask = RDPS_COMPONENTMASK_ALL; _EmitDstMod(DstReg,DstWriteMask) } else // D3DSIO_TEXDP3TEX
{ _NewPSInst(RDPSINST_DP3); _InstParam(RDPSINST_DP3).DstReg = CoordReg; _InstParam(RDPSINST_DP3).SrcReg0 = SrcReg[0]; _InstParam(RDPSINST_DP3).SrcReg1 = CoordReg; _InstParam(RDPSINST_DP3).bSrcReg0_Negate = FALSE; _InstParam(RDPSINST_DP3).bSrcReg1_Negate = FALSE; _InstParam(RDPSINST_DP3).WriteMask = RDPS_COMPONENTMASK_0;
_NewPSInst(RDPSINST_MOV); _InstParam(RDPSINST_MOV).DstReg = CoordReg; _InstParam(RDPSINST_MOV).SrcReg0 = ZeroReg; // 0.0f
_InstParam(RDPSINST_MOV).bSrcReg0_Negate = FALSE; _InstParam(RDPSINST_MOV).WriteMask = RDPS_COMPONENTMASK_1 | RDPS_COMPONENTMASK_2;
_LeaveQuadPixelLoop
PRGBAVEC pCoordReg = CoordReg.GetRegPtr();
_NewPSInst(RDPSINST_TEXCOVERAGE); _InstParam(RDPSINST_TEXCOVERAGE).uiStage = pInst->DstParam & D3DSP_REGNUM_MASK; _InstParam(RDPSINST_TEXCOVERAGE).pGradients = pRast->m_Gradients; // where to store gradients
// data from which to compute gradients. i.e.: du/dx = DUDX_0 - DUDX_1
_InstParam(RDPSINST_TEXCOVERAGE).pDUDX_0 = &pCoordReg[1][0]; // du/dx
_InstParam(RDPSINST_TEXCOVERAGE).pDUDX_1 = &pCoordReg[0][0]; _InstParam(RDPSINST_TEXCOVERAGE).pDUDY_0 = &pCoordReg[2][0]; // du/dy
_InstParam(RDPSINST_TEXCOVERAGE).pDUDY_1 = &pCoordReg[0][0]; _InstParam(RDPSINST_TEXCOVERAGE).pDVDX_0 = // dv/dx
_InstParam(RDPSINST_TEXCOVERAGE).pDVDX_1 = _InstParam(RDPSINST_TEXCOVERAGE).pDVDY_0 = // dv/dy
_InstParam(RDPSINST_TEXCOVERAGE).pDVDY_1 = _InstParam(RDPSINST_TEXCOVERAGE).pDWDX_0 = // dw/dx
_InstParam(RDPSINST_TEXCOVERAGE).pDWDX_1 = _InstParam(RDPSINST_TEXCOVERAGE).pDWDY_0 = // dw/dy
_InstParam(RDPSINST_TEXCOVERAGE).pDWDY_1 = &ZeroReg.GetRegPtr()[0][0]; // 0.0f
_EnterQuadPixelLoop
_NewPSInst(RDPSINST_SAMPLE); _InstParam(RDPSINST_SAMPLE).DstReg = DstReg; _InstParam(RDPSINST_SAMPLE).CoordReg = CoordReg; _InstParam(RDPSINST_SAMPLE).uiStage = pInst->DstParam & D3DSP_REGNUM_MASK;
_EmitDstMod(DstReg,DstWriteMask) } } break; case D3DSIO_TEXREG2AR: case D3DSIO_TEXREG2GB: case D3DSIO_TEXREG2RGB: { UINT I0, I1; PRGBAVEC pSrcReg0 = SrcReg[0].GetRegPtr();
switch( Opcode ) { case D3DSIO_TEXREG2AR: I0 = 3; I1 = 0; break; case D3DSIO_TEXREG2GB: I0 = 1; I1 = 2; break; case D3DSIO_TEXREG2RGB: I0 = 0; I1 = 1; break; }
_LeaveQuadPixelLoop
_NewPSInst(RDPSINST_TEXCOVERAGE); _InstParam(RDPSINST_TEXCOVERAGE).uiStage = pInst->DstParam & D3DSP_REGNUM_MASK; _InstParam(RDPSINST_TEXCOVERAGE).pGradients = pRast->m_Gradients; // where to store gradients
// data from which to compute gradients. i.e.: du/dx = DUDX_0 - DUDX_1
_InstParam(RDPSINST_TEXCOVERAGE).pDUDX_0 = &pSrcReg0[1][I0]; // du/dx
_InstParam(RDPSINST_TEXCOVERAGE).pDUDX_1 = &pSrcReg0[0][I0]; _InstParam(RDPSINST_TEXCOVERAGE).pDUDY_0 = &pSrcReg0[2][I0]; // du/dy
_InstParam(RDPSINST_TEXCOVERAGE).pDUDY_1 = &pSrcReg0[0][I0]; _InstParam(RDPSINST_TEXCOVERAGE).pDVDX_0 = &pSrcReg0[1][I1]; // dv/dx
_InstParam(RDPSINST_TEXCOVERAGE).pDVDX_1 = &pSrcReg0[0][I1]; _InstParam(RDPSINST_TEXCOVERAGE).pDVDY_0 = &pSrcReg0[2][I1]; // dv/dy
_InstParam(RDPSINST_TEXCOVERAGE).pDVDY_1 = &pSrcReg0[0][I1]; switch( Opcode ) { case D3DSIO_TEXREG2AR: case D3DSIO_TEXREG2GB: _InstParam(RDPSINST_TEXCOVERAGE).pDWDX_0 = // dw/dx
_InstParam(RDPSINST_TEXCOVERAGE).pDWDX_1 = _InstParam(RDPSINST_TEXCOVERAGE).pDWDY_0 = // dw/dy
_InstParam(RDPSINST_TEXCOVERAGE).pDWDY_1 = &ZeroReg.GetRegPtr()[0][0]; // 0.0f
break; case D3DSIO_TEXREG2RGB: _InstParam(RDPSINST_TEXCOVERAGE).pDWDX_0 = &pSrcReg0[1][2]; // dw/dx
_InstParam(RDPSINST_TEXCOVERAGE).pDWDX_1 = &pSrcReg0[0][2]; _InstParam(RDPSINST_TEXCOVERAGE).pDWDY_0 = &pSrcReg0[2][2]; // dw/dy
_InstParam(RDPSINST_TEXCOVERAGE).pDWDY_1 = &pSrcReg0[0][2]; break; }
_EnterQuadPixelLoop
RDPSRegister CoordReg; CoordReg._Set(RDPSREG_SCRATCH,0);
_NewPSInst(RDPSINST_SWIZZLE); _InstParam(RDPSINST_SWIZZLE).DstReg = CoordReg; _InstParam(RDPSINST_SWIZZLE).SrcReg0 = SrcReg[0]; _InstParam(RDPSINST_SWIZZLE).WriteMask = RDPS_COMPONENTMASK_0; _InstParam(RDPSINST_SWIZZLE).Swizzle = ComponentSwizzle[I0];
_NewPSInst(RDPSINST_SWIZZLE); _InstParam(RDPSINST_SWIZZLE).DstReg = CoordReg; _InstParam(RDPSINST_SWIZZLE).SrcReg0 = SrcReg[0]; _InstParam(RDPSINST_SWIZZLE).WriteMask = RDPS_COMPONENTMASK_1; _InstParam(RDPSINST_SWIZZLE).Swizzle = ComponentSwizzle[I1];
_NewPSInst(RDPSINST_MOV); _InstParam(RDPSINST_MOV).DstReg = CoordReg; _InstParam(RDPSINST_MOV).SrcReg0 = (D3DSIO_TEXREG2RGB == Opcode ? SrcReg[0] : ZeroReg ); _InstParam(RDPSINST_MOV).bSrcReg0_Negate = FALSE; _InstParam(RDPSINST_MOV).WriteMask = RDPS_COMPONENTMASK_2;
_NewPSInst(RDPSINST_SAMPLE); _InstParam(RDPSINST_SAMPLE).DstReg = DstReg; _InstParam(RDPSINST_SAMPLE).CoordReg = CoordReg; _InstParam(RDPSINST_SAMPLE).uiStage = pInst->DstParam & D3DSP_REGNUM_MASK;
_EmitDstMod(DstReg,DstWriteMask) } break; case D3DSIO_TEXBEM: case D3DSIO_TEXBEML: case D3DSIO_TEXBEM_LEGACY: // refrast only -> used with legacy fixed function rasterizer
case D3DSIO_TEXBEML_LEGACY: // refrast only -> used with legacy fixed function rasterizer
{ BOOL bDoLuminance = ((D3DSIO_TEXBEML == Opcode) || (D3DSIO_TEXBEML_LEGACY == Opcode)); RDPSRegister CoordReg; CoordReg._Set(RDPSREG_SCRATCH,0);
_NewPSInst(RDPSINST_EVAL); _InstParam(RDPSINST_EVAL).DstReg = CoordReg; _InstParam(RDPSINST_EVAL).uiCoordSet = pInst->DstParam & D3DSP_REGNUM_MASK; _InstParam(RDPSINST_EVAL).bIgnoreD3DTTFF_PROJECTED = FALSE; _InstParam(RDPSINST_EVAL).bClamp = FALSE;
_NewPSInst(RDPSINST_BEM); _InstParam(RDPSINST_BEM).DstReg = CoordReg; _InstParam(RDPSINST_BEM).SrcReg0 = CoordReg; _InstParam(RDPSINST_BEM).SrcReg1 = SrcReg[0]; _InstParam(RDPSINST_BEM).bSrcReg0_Negate = FALSE; _InstParam(RDPSINST_BEM).bSrcReg1_Negate = FALSE; _InstParam(RDPSINST_BEM).WriteMask = RDPS_COMPONENTMASK_0 | RDPS_COMPONENTMASK_1; _InstParam(RDPSINST_BEM).uiStage = pInst->uiTSSNum;
_EmitDstMod(CoordReg,RDPS_COMPONENTMASK_0 | RDPS_COMPONENTMASK_1)
_LeaveQuadPixelLoop
PRGBAVEC pCoordReg = CoordReg.GetRegPtr();
_NewPSInst(RDPSINST_TEXCOVERAGE); _InstParam(RDPSINST_TEXCOVERAGE).uiStage = pInst->DstParam & D3DSP_REGNUM_MASK; _InstParam(RDPSINST_TEXCOVERAGE).pGradients = pRast->m_Gradients; // where to store gradients
// data from which to compute gradients. i.e.: du/dx = DUDX_0 - DUDX_1
_InstParam(RDPSINST_TEXCOVERAGE).pDUDX_0 = &pCoordReg[1][0]; // du/dx
_InstParam(RDPSINST_TEXCOVERAGE).pDUDX_1 = &pCoordReg[0][0]; _InstParam(RDPSINST_TEXCOVERAGE).pDUDY_0 = &pCoordReg[2][0]; // du/dy
_InstParam(RDPSINST_TEXCOVERAGE).pDUDY_1 = &pCoordReg[0][0]; _InstParam(RDPSINST_TEXCOVERAGE).pDVDX_0 = &pCoordReg[1][1]; // dv/dx
_InstParam(RDPSINST_TEXCOVERAGE).pDVDX_1 = &pCoordReg[0][1]; _InstParam(RDPSINST_TEXCOVERAGE).pDVDY_0 = &pCoordReg[2][1]; // dv/dy
_InstParam(RDPSINST_TEXCOVERAGE).pDVDY_1 = &pCoordReg[0][1]; _InstParam(RDPSINST_TEXCOVERAGE).pDWDX_0 = // dw/dx
_InstParam(RDPSINST_TEXCOVERAGE).pDWDX_1 = _InstParam(RDPSINST_TEXCOVERAGE).pDWDY_0 = // dw/dy
_InstParam(RDPSINST_TEXCOVERAGE).pDWDY_1 = &ZeroReg.GetRegPtr()[0][0]; // 0.0f
_EnterQuadPixelLoop
_NewPSInst(RDPSINST_SAMPLE); _InstParam(RDPSINST_SAMPLE).DstReg = DstReg; _InstParam(RDPSINST_SAMPLE).CoordReg = CoordReg; _InstParam(RDPSINST_SAMPLE).uiStage = pInst->DstParam & D3DSP_REGNUM_MASK;
if( bDoLuminance ) { _NewPSInst(RDPSINST_LUMINANCE); _InstParam(RDPSINST_LUMINANCE).DstReg = DstReg; _InstParam(RDPSINST_LUMINANCE).SrcReg0 = DstReg; _InstParam(RDPSINST_LUMINANCE).SrcReg1 = SrcReg[0]; _InstParam(RDPSINST_LUMINANCE).bSrcReg0_Negate = FALSE; _InstParam(RDPSINST_LUMINANCE).bSrcReg1_Negate = FALSE; _InstParam(RDPSINST_LUMINANCE).uiStage = pInst->uiTSSNum; }
_EmitDstMod(DstReg,DstWriteMask) } break; case D3DSIO_TEXDEPTH: _NewPSInst(RDPSINST_DEPTH); _InstParam(RDPSINST_DEPTH).DstReg = DstReg; break; case D3DSIO_TEXM3x2PAD: { RDPSRegister CoordReg; CoordReg._Set(RDPSREG_SCRATCH,0);
// do dot product for first row of matrix multiply
// evaluate texture coordinate; projection disabled
_NewPSInst(RDPSINST_EVAL); _InstParam(RDPSINST_EVAL).DstReg = CoordReg; _InstParam(RDPSINST_EVAL).uiCoordSet = pInst->DstParam & D3DSP_REGNUM_MASK; _InstParam(RDPSINST_EVAL).bIgnoreD3DTTFF_PROJECTED = TRUE; // no projection
_InstParam(RDPSINST_EVAL).bClamp = FALSE; // do row of transform - tex coord * vector loaded from texture (on previous stage)
_NewPSInst(RDPSINST_DP3); _InstParam(RDPSINST_DP3).DstReg._Set(DstReg.GetRegType(),DstReg.GetRegNum()+1); _InstParam(RDPSINST_DP3).SrcReg0 = SrcReg[0]; _InstParam(RDPSINST_DP3).SrcReg1 = CoordReg; _InstParam(RDPSINST_DP3).bSrcReg0_Negate = FALSE; _InstParam(RDPSINST_DP3).bSrcReg1_Negate = FALSE; _InstParam(RDPSINST_DP3).WriteMask = RDPS_COMPONENTMASK_0; } break; case D3DSIO_TEXM3x3PAD: { BOOL bSecondPad = (D3DSIO_TEXM3x3PAD != ((pInst + 1)->Opcode & D3DSI_OPCODE_MASK)); BOOL bInVSPECSequence = (D3DSIO_TEXM3x3VSPEC == (((pInst + (bSecondPad?1:2))->Opcode) & D3DSI_OPCODE_MASK)); RDPSRegister CoordReg, EyeReg; CoordReg._Set(RDPSREG_SCRATCH,0); EyeReg._Set(RDPSREG_SCRATCH,1);
// do dot product for first row of matrix multiply
// evaluate texture coordinate; projection disabled
_NewPSInst(RDPSINST_EVAL); _InstParam(RDPSINST_EVAL).DstReg = CoordReg; _InstParam(RDPSINST_EVAL).uiCoordSet = pInst->DstParam & D3DSP_REGNUM_MASK; _InstParam(RDPSINST_EVAL).bIgnoreD3DTTFF_PROJECTED = TRUE; // no projection
_InstParam(RDPSINST_EVAL).bClamp = FALSE; // do row of transform - tex coord * vector loaded from texture (on previous stage)
_NewPSInst(RDPSINST_DP3); _InstParam(RDPSINST_DP3).DstReg._Set(DstReg.GetRegType(),DstReg.GetRegNum()+(bSecondPad?1:2)); _InstParam(RDPSINST_DP3).SrcReg0 = SrcReg[0]; _InstParam(RDPSINST_DP3).SrcReg1 = CoordReg; _InstParam(RDPSINST_DP3).bSrcReg0_Negate = FALSE; _InstParam(RDPSINST_DP3).bSrcReg1_Negate = FALSE; _InstParam(RDPSINST_DP3).WriteMask = bSecondPad?RDPS_COMPONENTMASK_1:RDPS_COMPONENTMASK_0;
if(bInVSPECSequence) { // eye vector encoded in 4th element of texture coordinates
_NewPSInst(RDPSINST_SWIZZLE); _InstParam(RDPSINST_SWIZZLE).DstReg = EyeReg; _InstParam(RDPSINST_SWIZZLE).SrcReg0 = CoordReg; _InstParam(RDPSINST_SWIZZLE).WriteMask = bSecondPad?RDPS_COMPONENTMASK_1:RDPS_COMPONENTMASK_0; _InstParam(RDPSINST_SWIZZLE).Swizzle = RDPS_REPLICATEALPHA; } } break; case D3DSIO_TEXM3x2TEX: case D3DSIO_TEXM3x3: case D3DSIO_TEXM3x3TEX: case D3DSIO_TEXM3x3SPEC: case D3DSIO_TEXM3x3VSPEC: case D3DSIO_TEXM3x2DEPTH: { BOOL bIs3D = (D3DSIO_TEXM3x2TEX != Opcode) && (D3DSIO_TEXM3x2DEPTH != Opcode); RDPSRegister CoordReg, EyeReg; CoordReg._Set(RDPSREG_SCRATCH,0); EyeReg._Set(RDPSREG_SCRATCH,1);
// do dot product for last row of matrix multiply
// evaluate texture coordinate; projection disabled
_NewPSInst(RDPSINST_EVAL); _InstParam(RDPSINST_EVAL).DstReg = CoordReg; _InstParam(RDPSINST_EVAL).uiCoordSet = pInst->DstParam & D3DSP_REGNUM_MASK; _InstParam(RDPSINST_EVAL).bIgnoreD3DTTFF_PROJECTED = TRUE; // no projection
_InstParam(RDPSINST_EVAL).bClamp = FALSE; // do row of transform - tex coord * vector loaded from texture (on previous stage)
_NewPSInst(RDPSINST_DP3); _InstParam(RDPSINST_DP3).DstReg = DstReg; _InstParam(RDPSINST_DP3).SrcReg0 = SrcReg[0]; _InstParam(RDPSINST_DP3).SrcReg1 = CoordReg; _InstParam(RDPSINST_DP3).bSrcReg0_Negate = FALSE; _InstParam(RDPSINST_DP3).bSrcReg1_Negate = FALSE; _InstParam(RDPSINST_DP3).WriteMask = bIs3D ? RDPS_COMPONENTMASK_2 : RDPS_COMPONENTMASK_1;
if(D3DSIO_TEXM3x3VSPEC == Opcode) { // eye vector encoded in 4th element of texture coordinates
_NewPSInst(RDPSINST_SWIZZLE); _InstParam(RDPSINST_SWIZZLE).DstReg = EyeReg; _InstParam(RDPSINST_SWIZZLE).SrcReg0 = CoordReg; _InstParam(RDPSINST_SWIZZLE).WriteMask = RDPS_COMPONENTMASK_2; _InstParam(RDPSINST_SWIZZLE).Swizzle = RDPS_REPLICATEALPHA; }
// Now do stuff that depends on which TEXM3x* instruction this is...
if( D3DSIO_TEXM3x3 == Opcode ) { _NewPSInst(RDPSINST_MOV); _InstParam(RDPSINST_MOV).DstReg = DstReg; _InstParam(RDPSINST_MOV).SrcReg0 = OneReg; // 1.0f
_InstParam(RDPSINST_MOV).bSrcReg0_Negate = FALSE; _InstParam(RDPSINST_MOV).WriteMask = RDPS_COMPONENTMASK_3; _EmitDstMod(DstReg,DstWriteMask) } else if ( (D3DSIO_TEXM3x2TEX == Opcode) || (D3DSIO_TEXM3x3TEX == Opcode) ) { // do straight lookup with transformed tex coords - this
// vector is not normalized, but normalization is not necessary
// for a cubemap lookup
// compute gradients for diffuse lookup
_LeaveQuadPixelLoop
PRGBAVEC pDstReg = DstReg.GetRegPtr();
_NewPSInst(RDPSINST_TEXCOVERAGE); _InstParam(RDPSINST_TEXCOVERAGE).uiStage = pInst->DstParam & D3DSP_REGNUM_MASK; _InstParam(RDPSINST_TEXCOVERAGE).pGradients = pRast->m_Gradients; // where to store gradients
// data from which to compute gradients. i.e.: du/dx = DUDX_0 - DUDX_1
_InstParam(RDPSINST_TEXCOVERAGE).pDUDX_0 = &pDstReg[1][0]; // du/dx
_InstParam(RDPSINST_TEXCOVERAGE).pDUDX_1 = &pDstReg[0][0]; _InstParam(RDPSINST_TEXCOVERAGE).pDUDY_0 = &pDstReg[2][0]; // du/dy
_InstParam(RDPSINST_TEXCOVERAGE).pDUDY_1 = &pDstReg[0][0]; _InstParam(RDPSINST_TEXCOVERAGE).pDVDX_0 = &pDstReg[1][1]; // dv/dx
_InstParam(RDPSINST_TEXCOVERAGE).pDVDX_1 = &pDstReg[0][1]; _InstParam(RDPSINST_TEXCOVERAGE).pDVDY_0 = &pDstReg[2][1]; // dv/dy
_InstParam(RDPSINST_TEXCOVERAGE).pDVDY_1 = &pDstReg[0][1]; if( bIs3D ) { _InstParam(RDPSINST_TEXCOVERAGE).pDWDX_0 = &pDstReg[1][2]; // dw/dx
_InstParam(RDPSINST_TEXCOVERAGE).pDWDX_1 = &pDstReg[0][2]; _InstParam(RDPSINST_TEXCOVERAGE).pDWDY_0 = &pDstReg[2][2]; // dw/dy
_InstParam(RDPSINST_TEXCOVERAGE).pDWDY_1 = &pDstReg[0][2]; } else { _InstParam(RDPSINST_TEXCOVERAGE).pDWDX_0 = // dw/dx
_InstParam(RDPSINST_TEXCOVERAGE).pDWDX_1 = _InstParam(RDPSINST_TEXCOVERAGE).pDWDY_0 = // dw/dy
_InstParam(RDPSINST_TEXCOVERAGE).pDWDY_1 = &ZeroReg.GetRegPtr()[0][0]; // 0.0f
}
_EnterQuadPixelLoop
// do lookup
if( !bIs3D ) { _NewPSInst(RDPSINST_MOV); _InstParam(RDPSINST_MOV).DstReg = DstReg; _InstParam(RDPSINST_MOV).SrcReg0 = ZeroReg; // 0.0f
_InstParam(RDPSINST_MOV).bSrcReg0_Negate = FALSE; _InstParam(RDPSINST_MOV).WriteMask = RDPS_COMPONENTMASK_2; }
_NewPSInst(RDPSINST_SAMPLE); _InstParam(RDPSINST_SAMPLE).DstReg = DstReg; _InstParam(RDPSINST_SAMPLE).CoordReg = DstReg; _InstParam(RDPSINST_SAMPLE).uiStage = pInst->DstParam & D3DSP_REGNUM_MASK;
_EmitDstMod(DstReg,DstWriteMask) } else if ( Opcode == D3DSIO_TEXM3x2DEPTH ) { // Take resulting u,v values and compute u/v, which
// can be interpreted is z/w = perspective correct depth.
// Then perturb the z coord for the pixel.
_NewPSInst(RDPSINST_DEPTH); _InstParam(RDPSINST_DEPTH).DstReg = DstReg; } else if ( (Opcode == D3DSIO_TEXM3x3SPEC) || (Opcode == D3DSIO_TEXM3x3VSPEC) ) { RDPSRegister NdotE, NdotN, RCPNdotN, Scale, ReflReg; NdotE._Set(RDPSREG_SCRATCH,2); NdotN._Set(RDPSREG_SCRATCH,3); RCPNdotN = NdotN; // reuse same register
Scale = NdotE; // reuse same register
ReflReg = CoordReg; // reuse same register
// compute reflection vector and do lookup - the normal needs
// to be normalized here, which is included in this expression
if (D3DSIO_TEXM3x3SPEC == Opcode) { // eye vector is constant register
EyeReg = SrcReg[1]; } // else (TEXM3x3VSPEC) -> eye is what was copied out of the 4th component of 3 texcoords
// Compute reflection vector: 2(NdotE/NdotN) * N - E ...
// Calculate NdotE
_NewPSInst(RDPSINST_DP3); _InstParam(RDPSINST_DP3).DstReg = NdotE; _InstParam(RDPSINST_DP3).SrcReg0 = DstReg; // N
_InstParam(RDPSINST_DP3).SrcReg1 = EyeReg; // E
_InstParam(RDPSINST_DP3).bSrcReg0_Negate = FALSE; _InstParam(RDPSINST_DP3).bSrcReg1_Negate = FALSE; _InstParam(RDPSINST_DP3).WriteMask = RDPS_COMPONENTMASK_3;
// Calculate NdotN
_NewPSInst(RDPSINST_DP3); _InstParam(RDPSINST_DP3).DstReg = NdotN; _InstParam(RDPSINST_DP3).SrcReg0 = DstReg; // N
_InstParam(RDPSINST_DP3).SrcReg1 = DstReg; // N
_InstParam(RDPSINST_DP3).bSrcReg0_Negate = FALSE; _InstParam(RDPSINST_DP3).bSrcReg1_Negate = FALSE; _InstParam(RDPSINST_DP3).WriteMask = RDPS_COMPONENTMASK_3;
// Calculate scale = 2(NdotE/NdotN):
// a) Calculate reciprocal of NdotN
_NewPSInst(RDPSINST_RCP); _InstParam(RDPSINST_RCP).DstReg = RCPNdotN; _InstParam(RDPSINST_RCP).SrcReg0 = NdotN; _InstParam(RDPSINST_RCP).bSrcReg0_Negate = FALSE; _InstParam(RDPSINST_RCP).WriteMask = RDPS_COMPONENTMASK_3;
// b) Multiply NdotE by reciprocal NdotN
_NewPSInst(RDPSINST_MUL); _InstParam(RDPSINST_MUL).DstReg = Scale; _InstParam(RDPSINST_MUL).SrcReg0 = NdotE; _InstParam(RDPSINST_MUL).SrcReg1 = RCPNdotN; _InstParam(RDPSINST_MUL).bSrcReg0_Negate = FALSE; _InstParam(RDPSINST_MUL).bSrcReg1_Negate = FALSE; _InstParam(RDPSINST_MUL).WriteMask = RDPS_COMPONENTMASK_3;
// c) Multiply by 2
_NewPSInst(RDPSINST_MUL); _InstParam(RDPSINST_MUL).DstReg = Scale; _InstParam(RDPSINST_MUL).SrcReg0 = Scale; _InstParam(RDPSINST_MUL).SrcReg1 = TwoReg; // 2.0f
_InstParam(RDPSINST_MUL).bSrcReg0_Negate = FALSE; _InstParam(RDPSINST_MUL).bSrcReg1_Negate = FALSE; _InstParam(RDPSINST_MUL).WriteMask = RDPS_COMPONENTMASK_3;
// d) Replicate result to rgb
_NewPSInst(RDPSINST_SWIZZLE); _InstParam(RDPSINST_SWIZZLE).DstReg = Scale; _InstParam(RDPSINST_SWIZZLE).SrcReg0 = Scale; _InstParam(RDPSINST_SWIZZLE).WriteMask = RDPS_COMPONENTMASK_0 | RDPS_COMPONENTMASK_1 | RDPS_COMPONENTMASK_2; _InstParam(RDPSINST_SWIZZLE).Swizzle = RDPS_REPLICATEALPHA;
// Calculate reflection = scale * N - E
_NewPSInst(RDPSINST_MUL); _InstParam(RDPSINST_MUL).DstReg = ReflReg; _InstParam(RDPSINST_MUL).SrcReg0 = Scale; // scale *
_InstParam(RDPSINST_MUL).SrcReg1 = DstReg; // N
_InstParam(RDPSINST_MUL).bSrcReg0_Negate = FALSE; _InstParam(RDPSINST_MUL).bSrcReg1_Negate = FALSE; _InstParam(RDPSINST_MUL).WriteMask = RDPS_COMPONENTMASK_0 | RDPS_COMPONENTMASK_1 | RDPS_COMPONENTMASK_2;
_NewPSInst(RDPSINST_SUB); _InstParam(RDPSINST_SUB).DstReg = ReflReg; _InstParam(RDPSINST_SUB).SrcReg0 = ReflReg; // (scale * N) -
_InstParam(RDPSINST_SUB).SrcReg1 = EyeReg; // E
_InstParam(RDPSINST_SUB).bSrcReg0_Negate = FALSE; _InstParam(RDPSINST_SUB).bSrcReg1_Negate = FALSE; _InstParam(RDPSINST_SUB).WriteMask = RDPS_COMPONENTMASK_0 | RDPS_COMPONENTMASK_1 | RDPS_COMPONENTMASK_2;
// compute gradients for reflection lookup
_LeaveQuadPixelLoop
PRGBAVEC pReflReg = ReflReg.GetRegPtr();
_NewPSInst(RDPSINST_TEXCOVERAGE); _InstParam(RDPSINST_TEXCOVERAGE).uiStage = pInst->DstParam & D3DSP_REGNUM_MASK; _InstParam(RDPSINST_TEXCOVERAGE).pGradients = pRast->m_Gradients; // where to store gradients
// data from which to compute gradients. i.e.: du/dx = DUDX_0 - DUDX_1
_InstParam(RDPSINST_TEXCOVERAGE).pDUDX_0 = &pReflReg[1][0]; // du/dx
_InstParam(RDPSINST_TEXCOVERAGE).pDUDX_1 = &pReflReg[0][0]; _InstParam(RDPSINST_TEXCOVERAGE).pDUDY_0 = &pReflReg[2][0]; // du/dy
_InstParam(RDPSINST_TEXCOVERAGE).pDUDY_1 = &pReflReg[0][0]; _InstParam(RDPSINST_TEXCOVERAGE).pDVDX_0 = &pReflReg[1][1]; // dv/dx
_InstParam(RDPSINST_TEXCOVERAGE).pDVDX_1 = &pReflReg[0][1]; _InstParam(RDPSINST_TEXCOVERAGE).pDVDY_0 = &pReflReg[2][1]; // dv/dy
_InstParam(RDPSINST_TEXCOVERAGE).pDVDY_1 = &pReflReg[0][1]; _InstParam(RDPSINST_TEXCOVERAGE).pDWDX_0 = &pReflReg[1][2]; // dw/dx
_InstParam(RDPSINST_TEXCOVERAGE).pDWDX_1 = &pReflReg[0][2]; _InstParam(RDPSINST_TEXCOVERAGE).pDWDY_0 = &pReflReg[2][2]; // dw/dy
_InstParam(RDPSINST_TEXCOVERAGE).pDWDY_1 = &pReflReg[0][2];
_EnterQuadPixelLoop
// do lookup
_NewPSInst(RDPSINST_SAMPLE); _InstParam(RDPSINST_SAMPLE).DstReg = DstReg; _InstParam(RDPSINST_SAMPLE).CoordReg = ReflReg; _InstParam(RDPSINST_SAMPLE).uiStage = pInst->DstParam & D3DSP_REGNUM_MASK;
_EmitDstMod(DstReg,DstWriteMask) } } break; case D3DSIO_BEM: _NewPSInst(RDPSINST_BEM); _InstParam(RDPSINST_BEM).DstReg = DstReg; _InstParam(RDPSINST_BEM).SrcReg0 = SrcReg[0]; _InstParam(RDPSINST_BEM).SrcReg1 = SrcReg[1]; _InstParam(RDPSINST_BEM).bSrcReg0_Negate = bSrcNegate[0]; _InstParam(RDPSINST_BEM).bSrcReg1_Negate = bSrcNegate[1]; _InstParam(RDPSINST_BEM).WriteMask = DstWriteMask; _InstParam(RDPSINST_BEM).uiStage = pInst->DstParam & D3DSP_REGNUM_MASK; _EmitDstMod(DstReg,DstWriteMask) break; case D3DSIO_MOV: _NewPSInst(RDPSINST_MOV); _InstParam(RDPSINST_MOV).DstReg = DstReg; _InstParam(RDPSINST_MOV).SrcReg0 = SrcReg[0]; _InstParam(RDPSINST_MOV).bSrcReg0_Negate = bSrcNegate[0]; _InstParam(RDPSINST_MOV).WriteMask = DstWriteMask; _EmitDstMod(DstReg,DstWriteMask) break; case D3DSIO_FRC: _NewPSInst(RDPSINST_FRC); _InstParam(RDPSINST_FRC).DstReg = DstReg; _InstParam(RDPSINST_FRC).SrcReg0 = SrcReg[0]; _InstParam(RDPSINST_FRC).bSrcReg0_Negate = bSrcNegate[0]; _InstParam(RDPSINST_FRC).WriteMask = DstWriteMask; _EmitDstMod(DstReg,DstWriteMask) break; case D3DSIO_ADD: _NewPSInst(RDPSINST_ADD); _InstParam(RDPSINST_ADD).DstReg = DstReg; _InstParam(RDPSINST_ADD).SrcReg0 = SrcReg[0]; _InstParam(RDPSINST_ADD).SrcReg1 = SrcReg[1]; _InstParam(RDPSINST_ADD).bSrcReg0_Negate = bSrcNegate[0]; _InstParam(RDPSINST_ADD).bSrcReg1_Negate = bSrcNegate[1]; _InstParam(RDPSINST_ADD).WriteMask = DstWriteMask; _EmitDstMod(DstReg,DstWriteMask) break; case D3DSIO_SUB: _NewPSInst(RDPSINST_SUB); _InstParam(RDPSINST_SUB).DstReg = DstReg; _InstParam(RDPSINST_SUB).SrcReg0 = SrcReg[0]; _InstParam(RDPSINST_SUB).SrcReg1 = SrcReg[1]; _InstParam(RDPSINST_SUB).bSrcReg0_Negate = bSrcNegate[0]; _InstParam(RDPSINST_SUB).bSrcReg1_Negate = bSrcNegate[1]; _InstParam(RDPSINST_SUB).WriteMask = DstWriteMask; _EmitDstMod(DstReg,DstWriteMask) break; case D3DSIO_MUL: _NewPSInst(RDPSINST_MUL); _InstParam(RDPSINST_MUL).DstReg = DstReg; _InstParam(RDPSINST_MUL).SrcReg0 = SrcReg[0]; _InstParam(RDPSINST_MUL).SrcReg1 = SrcReg[1]; _InstParam(RDPSINST_MUL).bSrcReg0_Negate = bSrcNegate[0]; _InstParam(RDPSINST_MUL).bSrcReg1_Negate = bSrcNegate[1]; _InstParam(RDPSINST_MUL).WriteMask = DstWriteMask; _EmitDstMod(DstReg,DstWriteMask) break; case D3DSIO_DP3: _NewPSInst(RDPSINST_DP3); _InstParam(RDPSINST_DP3).DstReg = DstReg; _InstParam(RDPSINST_DP3).SrcReg0 = SrcReg[0]; _InstParam(RDPSINST_DP3).SrcReg1 = SrcReg[1]; _InstParam(RDPSINST_DP3).bSrcReg0_Negate = bSrcNegate[0]; _InstParam(RDPSINST_DP3).bSrcReg1_Negate = bSrcNegate[1]; _InstParam(RDPSINST_DP3).WriteMask = DstWriteMask; _EmitDstMod(DstReg,DstWriteMask) break; case D3DSIO_DP4: _NewPSInst(RDPSINST_DP4); _InstParam(RDPSINST_DP4).DstReg = DstReg; _InstParam(RDPSINST_DP4).SrcReg0 = SrcReg[0]; _InstParam(RDPSINST_DP4).SrcReg1 = SrcReg[1]; _InstParam(RDPSINST_DP4).bSrcReg0_Negate = bSrcNegate[0]; _InstParam(RDPSINST_DP4).bSrcReg1_Negate = bSrcNegate[1]; _InstParam(RDPSINST_DP4).WriteMask = DstWriteMask; _EmitDstMod(DstReg,DstWriteMask) break; case D3DSIO_MAD: _NewPSInst(RDPSINST_MAD); _InstParam(RDPSINST_MAD).DstReg = DstReg; _InstParam(RDPSINST_MAD).SrcReg0 = SrcReg[0]; _InstParam(RDPSINST_MAD).SrcReg1 = SrcReg[1]; _InstParam(RDPSINST_MAD).SrcReg2 = SrcReg[2]; _InstParam(RDPSINST_MAD).bSrcReg0_Negate = bSrcNegate[0]; _InstParam(RDPSINST_MAD).bSrcReg1_Negate = bSrcNegate[1]; _InstParam(RDPSINST_MAD).bSrcReg2_Negate = bSrcNegate[2]; _InstParam(RDPSINST_MAD).WriteMask = DstWriteMask; _EmitDstMod(DstReg,DstWriteMask) break; case D3DSIO_LRP: _NewPSInst(RDPSINST_LRP); _InstParam(RDPSINST_LRP).DstReg = DstReg; _InstParam(RDPSINST_LRP).SrcReg0 = SrcReg[0]; _InstParam(RDPSINST_LRP).SrcReg1 = SrcReg[1]; _InstParam(RDPSINST_LRP).SrcReg2 = SrcReg[2]; _InstParam(RDPSINST_LRP).bSrcReg0_Negate = bSrcNegate[0]; _InstParam(RDPSINST_LRP).bSrcReg1_Negate = bSrcNegate[1]; _InstParam(RDPSINST_LRP).bSrcReg2_Negate = bSrcNegate[2]; _InstParam(RDPSINST_LRP).WriteMask = DstWriteMask; _EmitDstMod(DstReg,DstWriteMask) break; case D3DSIO_CND: _NewPSInst(RDPSINST_CND); _InstParam(RDPSINST_CND).DstReg = DstReg; _InstParam(RDPSINST_CND).SrcReg0 = SrcReg[0]; _InstParam(RDPSINST_CND).SrcReg1 = SrcReg[1]; _InstParam(RDPSINST_CND).SrcReg2 = SrcReg[2]; _InstParam(RDPSINST_CND).bSrcReg0_Negate = bSrcNegate[0]; _InstParam(RDPSINST_CND).bSrcReg1_Negate = bSrcNegate[1]; _InstParam(RDPSINST_CND).bSrcReg2_Negate = bSrcNegate[2]; _InstParam(RDPSINST_CND).WriteMask = DstWriteMask; _EmitDstMod(DstReg,DstWriteMask) break; case D3DSIO_CMP: _NewPSInst(RDPSINST_CMP); _InstParam(RDPSINST_CMP).DstReg = DstReg; _InstParam(RDPSINST_CMP).SrcReg0 = SrcReg[0]; _InstParam(RDPSINST_CMP).SrcReg1 = SrcReg[1]; _InstParam(RDPSINST_CMP).SrcReg2 = SrcReg[2]; _InstParam(RDPSINST_CMP).bSrcReg0_Negate = bSrcNegate[0]; _InstParam(RDPSINST_CMP).bSrcReg1_Negate = bSrcNegate[1]; _InstParam(RDPSINST_CMP).bSrcReg2_Negate = bSrcNegate[2]; _InstParam(RDPSINST_CMP).WriteMask = DstWriteMask; _EmitDstMod(DstReg,DstWriteMask) break; default: break; }
if( pInst->bFlushQueue ) { _EnterQuadPixelLoop _NewPSInst(RDPSINST_FLUSHQUEUE); QueueIndex = -1; }
#if DBG
_LeaveQuadPixelLoop#endif
}
// Flush queue at end of shader if there is anything on it
if( -1 != QueueIndex ) { _EnterQuadPixelLoop _NewPSInst(RDPSINST_FLUSHQUEUE); QueueIndex = -1; }
_LeaveQuadPixelLoop
_NewPSInst(RDPSINST_END);
#if DBG
if( pRast->m_bDebugPrintTranslatedPixelShaderTokens ) RDPSDisAsm(pRDPSInstBuffer, m_pConstDefs, m_cConstDefs,pCaps->MaxPixelShaderValue, Version);#endif
}
return S_OK;}
///////////////////////////////////////////////////////////////////////////////
// end
|
