|
|
#if 0 // this whole thing is turned off...
//------------------------------------------------------------------------------
// DX9AsmToGL.cpp
//------------------------------------------------------------------------------
#include "tier0/dbg.h"
#include "tier1/strtools.h"
#include "tier1/utlbuffer.h"
#include "togl/rendermechansim.h"
#include "dx9asmtogL.h"
#ifdef POSIX
#include "glmgr/glmgrbasics.h"
#else
// normally we would get this form glmgr.h. on a non-POSIX build of this code, we just sneak it in here
#define kGLMUserClipPlaneParamBase 253
#endif
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#ifdef POSIX
#define strcat_s( a, b, c) V_strcat( a, c, b )
#endif
#define DST_REGISTER 0
#define SRC_REGISTER 1
// Tracking and naming sampler dimensions
#define SAMPLER_TYPE_2D 0
#define SAMPLER_TYPE_CUBE 1
#define SAMPLER_TYPE_3D 2
// Code for which component of the "dummy" address register is needed by an instruction
#define ARL_DEST_NONE -1
#define ARL_DEST_X 0
#define ARL_DEST_Y 1
#define ARL_DEST_Z 2
#define ARL_DEST_W 3
#ifndef POSIX
#define Debugger() Assert(0)
#endif
char g_pSamplerStrings[3][5] = { "2D", "CUBE", "3D" };
float uint32ToFloat_ASM( uint32 dw ){ return *((float*)&dw);}
uint32 D3DToGL_ASM::GetNextToken( void ){ uint32 dwToken = *m_pdwNextToken; m_pdwNextToken++; return dwToken;}
void D3DToGL_ASM::SkipTokens( uint32 numToSkip ){ m_pdwNextToken += numToSkip;}
uint32 D3DToGL_ASM::Opcode( uint32 dwToken ){ return ( dwToken & D3DSI_OPCODE_MASK );}
uint32 D3DToGL_ASM::OpcodeSpecificData (uint32 dwToken){ return ( ( dwToken & D3DSP_OPCODESPECIFICCONTROL_MASK ) >> D3DSP_OPCODESPECIFICCONTROL_SHIFT );}
uint32 D3DToGL_ASM::TextureType ( uint32 dwToken ){ return ( dwToken & D3DSP_TEXTURETYPE_MASK ); // Note this one doesn't shift due to weird D3DSAMPLER_TEXTURE_TYPE enum
}
// Print GLSL intrinsic corresponding to particular instruction
void D3DToGL_ASM::OpenIntrinsic( uint32 inst, char* buff, int nBufLen ){ switch ( inst ) { case D3DSIO_RSQ: V_snprintf( buff, nBufLen, "inversesqrt( " ); break; case D3DSIO_DP3: case D3DSIO_DP4: V_snprintf( buff, nBufLen, "dot( " ); break; case D3DSIO_MIN: V_snprintf( buff, nBufLen, "min( " ); break; case D3DSIO_MAX: V_snprintf( buff, nBufLen, "max( " ); break; case D3DSIO_SLT: V_snprintf( buff, nBufLen, "lessThan( " ); break; case D3DSIO_SGE: V_snprintf( buff, nBufLen, "greaterThan( " ); break; case D3DSIO_EXP: V_snprintf( buff, nBufLen, "exp( " ); // exp2 ?
break; case D3DSIO_LOG: V_snprintf( buff, nBufLen, "log( " ); // log2 ?
break; case D3DSIO_LIT: Assert(0); V_snprintf( buff, nBufLen, "lit( " ); // gonna have to write this one
break; case D3DSIO_DST: Assert(0); V_snprintf( buff, nBufLen, "dst( " ); // gonna have to write this one
break; case D3DSIO_LRP: Assert( !m_bVertexShader ); V_snprintf( buff, nBufLen, "mix( " ); break; case D3DSIO_FRC: V_snprintf( buff, nBufLen, "fract( " ); break; case D3DSIO_M4x4: Assert(0); V_snprintf( buff, nBufLen, "m4x4" ); break; case D3DSIO_M4x3: case D3DSIO_M3x4: case D3DSIO_M3x3: case D3DSIO_M3x2: case D3DSIO_CALL: case D3DSIO_CALLNZ: case D3DSIO_LOOP: case D3DSIO_RET: case D3DSIO_ENDLOOP: case D3DSIO_LABEL: case D3DSIO_DCL: Assert(0); break; case D3DSIO_POW: V_snprintf( buff, nBufLen, "pow( " ); break; case D3DSIO_CRS: V_snprintf( buff, nBufLen, "cross( " ); break; case D3DSIO_SGN: Assert(0); V_snprintf( buff, nBufLen, "sign( " ); break; case D3DSIO_ABS: V_snprintf( buff, nBufLen, "abs( " ); break; case D3DSIO_NRM: Assert( 0 ); V_snprintf( buff, nBufLen, "normalize( " ); break; case D3DSIO_SINCOS: Assert( 0 ); V_snprintf( buff, nBufLen, "sincos( " ); // gonna have to write this one
break; case D3DSIO_REP: case D3DSIO_ENDREP: case D3DSIO_IF: case D3DSIO_IFC: case D3DSIO_ELSE: case D3DSIO_ENDIF: case D3DSIO_BREAK: case D3DSIO_BREAKC: // TODO: these are the reason we even need GLSL...gotta make these work
Assert(0); break; case D3DSIO_DEFB: case D3DSIO_DEFI: Assert(0); break; case D3DSIO_TEXCOORD: V_snprintf( buff, nBufLen, "texcoord" ); break; case D3DSIO_TEXKILL: V_snprintf( buff, nBufLen, "kill( " ); // wrap the discard instruction?
break; case D3DSIO_TEX: Assert(0); V_snprintf( buff, nBufLen, "TEX" ); // We shouldn'g get here
break; 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: Assert(0); break; case D3DSIO_EXPP: V_snprintf( buff, nBufLen, "exp( " ); break; case D3DSIO_LOGP: V_snprintf( buff, nBufLen, "log( " ); break; case D3DSIO_CND: Assert(0); break; case D3DSIO_DEF: Assert(0); V_snprintf( buff, nBufLen, "DEF" ); break; case D3DSIO_TEXREG2RGB: case D3DSIO_TEXDP3TEX: case D3DSIO_TEXM3x2DEPTH: case D3DSIO_TEXDP3: case D3DSIO_TEXM3x3: Assert(0); break; case D3DSIO_TEXDEPTH: V_snprintf( buff, nBufLen, "texdepth" ); break; case D3DSIO_CMP: Assert(0); Assert( !m_bVertexShader ); V_snprintf( buff, nBufLen, "CMP" ); break; case D3DSIO_BEM: Assert(0); break; case D3DSIO_DP2ADD: Assert(0); break; case D3DSIO_DSX: case D3DSIO_DSY: Assert(0); break; case D3DSIO_TEXLDD: V_snprintf( buff, nBufLen, "texldd" ); break; case D3DSIO_SETP: Assert(0); break; case D3DSIO_TEXLDL: V_snprintf( buff, nBufLen, "texldl" ); break; case D3DSIO_BREAKP: case D3DSIO_PHASE: Assert(0); break; }}
// Print ASM opcode
void D3DToGL_ASM::PrintOpcode( uint32 inst, char* buff, int nBufLen ){ switch ( inst ) { case D3DSIO_NOP: V_snprintf( buff, nBufLen, "NOP" ); Assert(0); break; case D3DSIO_MOV: V_snprintf( buff, nBufLen, "MOV" ); break; case D3DSIO_ADD: V_snprintf( buff, nBufLen, "ADD" ); break; case D3DSIO_SUB: V_snprintf( buff, nBufLen, "SUB" ); break; case D3DSIO_MAD: V_snprintf( buff, nBufLen, "MAD" ); break; case D3DSIO_MUL: V_snprintf( buff, nBufLen, "MUL" ); break; case D3DSIO_RCP: V_snprintf( buff, nBufLen, "RCP" ); break; case D3DSIO_RSQ: V_snprintf( buff, nBufLen, "RSQ" ); break; case D3DSIO_DP3: V_snprintf( buff, nBufLen, "DP3" ); break; case D3DSIO_DP4: V_snprintf( buff, nBufLen, "DP4" ); break; case D3DSIO_MIN: V_snprintf( buff, nBufLen, "MIN" ); break; case D3DSIO_MAX: V_snprintf( buff, nBufLen, "MAX" ); break; case D3DSIO_SLT: V_snprintf( buff, nBufLen, "SLT" ); break; case D3DSIO_SGE: V_snprintf( buff, nBufLen, "SGE" ); break; case D3DSIO_EXP: V_snprintf( buff, nBufLen, "EX2" ); break; case D3DSIO_LOG: V_snprintf( buff, nBufLen, "LG2" ); break; case D3DSIO_LIT: V_snprintf( buff, nBufLen, "LIT" ); break; case D3DSIO_DST: V_snprintf( buff, nBufLen, "DST" ); break; case D3DSIO_LRP: Assert( !m_bVertexShader ); V_snprintf( buff, nBufLen, "LRP" ); break; case D3DSIO_FRC: V_snprintf( buff, nBufLen, "FRC" ); break; case D3DSIO_M4x4: V_snprintf( buff, nBufLen, "m4x4" ); break; case D3DSIO_M4x3: case D3DSIO_M3x4: case D3DSIO_M3x3: case D3DSIO_M3x2: case D3DSIO_CALL: case D3DSIO_CALLNZ: case D3DSIO_LOOP: case D3DSIO_RET: case D3DSIO_ENDLOOP: case D3DSIO_LABEL: Assert(0); break; case D3DSIO_DCL: V_snprintf( buff, nBufLen, "DCL" ); break; case D3DSIO_POW: V_snprintf( buff, nBufLen, "POW" ); break; case D3DSIO_CRS: V_snprintf( buff, nBufLen, "XPD" ); break; case D3DSIO_SGN: Assert(0); V_snprintf( buff, nBufLen, "SGN" ); break; case D3DSIO_ABS: V_snprintf( buff, nBufLen, "ABS" ); break; case D3DSIO_NRM: Assert( 0 ); V_snprintf( buff, nBufLen, "NRM" ); break; case D3DSIO_SINCOS: Assert( !m_bVertexShader ); V_snprintf( buff, nBufLen, "SCS" ); break; case D3DSIO_REP: case D3DSIO_ENDREP: case D3DSIO_IF: case D3DSIO_IFC: case D3DSIO_ELSE: case D3DSIO_ENDIF: case D3DSIO_BREAK: case D3DSIO_BREAKC: Assert(0); break; case D3DSIO_MOVA: Assert( m_bVertexShader ); V_snprintf( buff, nBufLen, "MOV" ); // We're always moving into a temp instead, so this is MOV instead of ARL
break; case D3DSIO_DEFB: case D3DSIO_DEFI: Assert(0); break; case D3DSIO_TEXCOORD: V_snprintf( buff, nBufLen, "texcoord" ); break; case D3DSIO_TEXKILL: V_snprintf( buff, nBufLen, "KIL" ); break; case D3DSIO_TEX: V_snprintf( buff, nBufLen, "TEX" ); break; 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: Assert(0); break; case D3DSIO_EXPP: V_snprintf( buff, nBufLen, "EXP" ); break; case D3DSIO_LOGP: V_snprintf( buff, nBufLen, "LOG" ); break; case D3DSIO_CND: Assert(0); break; case D3DSIO_DEF: V_snprintf( buff, nBufLen, "DEF" ); break; case D3DSIO_TEXREG2RGB: case D3DSIO_TEXDP3TEX: case D3DSIO_TEXM3x2DEPTH: case D3DSIO_TEXDP3: case D3DSIO_TEXM3x3: Assert(0); break; case D3DSIO_TEXDEPTH: V_snprintf( buff, nBufLen, "texdepth" ); break; case D3DSIO_CMP: Assert( !m_bVertexShader ); V_snprintf( buff, nBufLen, "CMP" ); break; case D3DSIO_BEM: Assert(0); break; case D3DSIO_DP2ADD: Assert(0); break; case D3DSIO_DSX: case D3DSIO_DSY: Assert(0); break; case D3DSIO_TEXLDD: V_snprintf( buff, nBufLen, "texldd" ); break; case D3DSIO_SETP: Assert(0); break; case D3DSIO_TEXLDL: V_snprintf( buff, nBufLen, "texldl" ); break; case D3DSIO_BREAKP: case D3DSIO_PHASE: Assert(0); break; }}
//------------------------------------------------------------------------------
// Helper function which prints ASCII representation of usage-usageindex pair to string
//
// Strictly used by vertex shaders
// not used any more now that we have attribmap metadata
//------------------------------------------------------------------------------
void D3DToGL_ASM::PrintUsageAndIndexToString( uint32 dwToken, char* strUsageUsageIndexName, int nBufLen, bool bGLSL ){ uint32 dwUsage = ( dwToken & D3DSP_DCL_USAGE_MASK ); uint32 dwUsageIndex = ( dwToken & D3DSP_DCL_USAGEINDEX_MASK ) >> D3DSP_DCL_USAGEINDEX_SHIFT;
switch ( dwUsage ) { case D3DDECLUSAGE_POSITION: V_snprintf( strUsageUsageIndexName, nBufLen, "vertex.attrib[0]" ); //"vertex.position" ); // aka generic [0]
break; case D3DDECLUSAGE_BLENDWEIGHT: V_snprintf( strUsageUsageIndexName, nBufLen, "vertex.attrib[1]" ); // "vertex.attrib[12]" ); // or [1]
break; case D3DDECLUSAGE_BLENDINDICES: V_snprintf( strUsageUsageIndexName, nBufLen, "vertex.attrib[13]" ); // "vertex.attrib[13]" ); // or [ 7 ]
break; case D3DDECLUSAGE_NORMAL: V_snprintf( strUsageUsageIndexName, nBufLen, "vertex.attrib[2]" ); // "vertex.normal" ); // aka [ 2 ]
break; case D3DDECLUSAGE_PSIZE: Assert(0); V_snprintf( strUsageUsageIndexName, nBufLen, "_psize" ); // no analog
break; case D3DDECLUSAGE_TEXCOORD: V_snprintf( strUsageUsageIndexName, nBufLen, "vertex.attrib[%d]", 8+dwUsageIndex ); // "vertex.texcoord[%d]", dwUsageIndex ); // aka [8] - [15] ?
break; case D3DDECLUSAGE_TANGENT: V_snprintf( strUsageUsageIndexName, nBufLen, "vertex.attrib[15]" ); // aka texc[7]
break; case D3DDECLUSAGE_BINORMAL: V_snprintf( strUsageUsageIndexName, nBufLen, "vertex.attrib[14]" ); // aka texc[6]
break;// case D3DDECLUSAGE_TESSFACTOR:
// Assert(0);
// V_snprintf( strUsageUsageIndexName, nBufLen, "_position" ); // no analog
// break;
// case D3DDECLUSAGE_POSITIONT:
// Assert(0);
// V_snprintf( strUsageUsageIndexName, nBufLen, "_positiont" ); // no analog
// break;
case D3DDECLUSAGE_COLOR: V_snprintf( strUsageUsageIndexName, nBufLen, "vertex.attrib[%d]", 3+dwUsageIndex ); //dwUsageIndex ); // != 0 ? "vertex.color.secondary" : "vertex.color" ); // aka [3] / [4] (second)
break; case D3DDECLUSAGE_FOG: V_snprintf( strUsageUsageIndexName, nBufLen, "vertex.attrib[5]" ); //"vertex.position" /* "_fog" */ ); //FIXME, evil // aka [5] / vertex.fogcoord
break; case D3DDECLUSAGE_DEPTH: Assert(0); V_snprintf( strUsageUsageIndexName, nBufLen, "_depth" ); // no analog
break; case D3DDECLUSAGE_SAMPLE: Assert(0); V_snprintf( strUsageUsageIndexName, nBufLen, "_sample" ); // no analog
break; default: Debugger(); break; }}
uint32 D3DToGL_ASM::GetRegType( uint32 dwRegToken ){ return ( ( dwRegToken & D3DSP_REGTYPE_MASK2 ) >> D3DSP_REGTYPE_SHIFT2 ) | ( ( dwRegToken & D3DSP_REGTYPE_MASK ) >> D3DSP_REGTYPE_SHIFT );}
void D3DToGL_ASM::PrintIndentation( char *pBuf, int nBufLen ){ for( int i=0; i<m_NumIndentTabs; i++ ) { strcat_s( pBuf, nBufLen, "\t" ); }}
void D3DToGL_ASM::FlagIndirectRegister( uint32 dwToken, int *pARLDestReg ){ switch ( dwToken & D3DVS_SWIZZLE_MASK & D3DVS_X_W ) { case D3DVS_X_X: *pARLDestReg = ARL_DEST_X; break; case D3DVS_X_Y: *pARLDestReg = ARL_DEST_Y; break; case D3DVS_X_Z: *pARLDestReg = ARL_DEST_Z; break; case D3DVS_X_W: *pARLDestReg = ARL_DEST_W; break; }}
//------------------------------------------------------------------------------
// PrintParameterToString()
//
// Helper function which prints ASCII representation of passed Parameter dwToken
// to string. Token defines parameter details. The dwSourceOrDest parameter says
// whether or not this is a source or destination register
//------------------------------------------------------------------------------
void D3DToGL_ASM::PrintParameterToString ( uint32 dwToken, uint32 dwSourceOrDest, char *pRegisterName, int nBufLen, bool bGLSL, int *pARLDestReg = NULL ){ char buff[32]; bool bAllowWriteMask = true;
uint32 dwRegNum = dwToken & D3DSP_REGNUM_MASK;
uint32 dwRegType, dwSwizzle; uint32 dwSrcModifier = D3DSPSM_NONE;
// Clear string to zero length
V_snprintf( pRegisterName, nBufLen, "" );
// Weird one...bits are split apart in the dwToken
dwRegType = ( ( dwToken & D3DSP_REGTYPE_MASK2 ) >> D3DSP_REGTYPE_SHIFT2 ) | ( ( dwToken & D3DSP_REGTYPE_MASK ) >> D3DSP_REGTYPE_SHIFT );
// If this is a dest register
if ( dwSourceOrDest == DST_REGISTER ) { // Instruction modifiers
if ( dwToken & D3DSPDM_PARTIALPRECISION ) {// strcat_s( pRegisterName, nBufLen, "_pp" );
}
if ( dwToken & D3DSPDM_SATURATE) { strcat_s( pRegisterName, nBufLen, "_SAT" ); }
if ( dwToken & D3DSPDM_MSAMPCENTROID) {// strcat_s( pRegisterName, nBufLen, "_centroid" );
}
if ( !bGLSL ) { strcat_s( pRegisterName, nBufLen, " " ); } }
// If this is a source register
if ( dwSourceOrDest == SRC_REGISTER ) { dwSrcModifier = dwToken & D3DSP_SRCMOD_MASK;
// If there are any source modifiers, check to see if they're at
// least partially "prefix" and prepend appropriately
if ( dwSrcModifier != D3DSPSM_NONE ) { switch ( dwSrcModifier ) { // These four start with just minus... (some may result in "postfix" notation as well later on)
case D3DSPSM_NEG: // negate
strcat_s( pRegisterName, nBufLen, "-" ); break; case D3DSPSM_BIASNEG: // bias and negate
case D3DSPSM_SIGNNEG: // sign and negate
case D3DSPSM_X2NEG: // *2 and negate
Assert(0); strcat_s( pRegisterName, nBufLen, "-" ); break; case D3DSPSM_COMP: // complement
Assert(0); strcat_s( pRegisterName, nBufLen, "1-" ); break; case D3DSPSM_ABS: // abs()
Assert(0); strcat_s( pRegisterName, nBufLen, "abs(" ); break; case D3DSPSM_ABSNEG: // -abs()
Assert(0); strcat_s( pRegisterName, nBufLen, "-abs(" ); break; case D3DSPSM_NOT: // for predicate register: "!p0"
Assert(0); strcat_s( pRegisterName, nBufLen, "!" ); break; } } }
// Register name (from type and number)
switch ( dwRegType ) { case D3DSPR_TEMP: V_snprintf( buff, sizeof( buff ), "r%d", dwRegNum ); strcat_s( pRegisterName, nBufLen, buff ); m_dwTempUsageMask |= 0x00000001 << dwRegNum; // Keep track of the use of this temp
break; case D3DSPR_INPUT: if ( m_bVertexShader || ( dwSourceOrDest == SRC_REGISTER ) || bGLSL ) { V_snprintf( buff, sizeof( buff ), "v%d", dwRegNum ); strcat_s( pRegisterName, nBufLen, buff ); } else // asm pixel shader declaration syntax:
{ V_snprintf( buff, sizeof( buff ), dwRegNum == 0 ? "v0 = fragment.color" : "v1 = fragment.color.secondary" ); strcat_s( pRegisterName, nBufLen, buff ); bAllowWriteMask = false; } break; case D3DSPR_CONST: if ( m_bConstantRegisterDefined[dwRegNum] ) { // Put defined constants into their own namespace "d"
V_snprintf( buff, sizeof( buff ), "d%d", dwRegNum ); strcat_s( pRegisterName, nBufLen, buff ); } else if ( dwToken & D3DSHADER_ADDRESSMODE_MASK ) { // Index into single c[] register array with relative addressing
FlagIndirectRegister( GetNextToken(), pARLDestReg );
V_snprintf( buff, sizeof( buff ), "c[a0.x + %d]", dwRegNum ); strcat_s( pRegisterName, nBufLen, buff ); m_bConstantRegisterReferenced[dwRegNum] = true; } else { // Index into single c[] register array with absolute addressing
V_snprintf( buff, sizeof( buff ), "c[%d]", dwRegNum ); strcat_s( pRegisterName, nBufLen, buff ); m_bConstantRegisterReferenced[dwRegNum] = true; } break; case D3DSPR_ADDR: // aliases to D3DSPR_TEXTURE
if ( m_bVertexShader ) { V_snprintf( buff, sizeof( buff ), "VEC_ADDRESS_REG" ); // Move into our temp, rather than a0
} else { if ( dwSourceOrDest == DST_REGISTER ) { V_snprintf( buff, sizeof( buff ), "t%d = fragment.texcoord[%d]", dwRegNum, dwRegNum ); bAllowWriteMask = false; } else { V_snprintf( buff, sizeof( buff ), "t%d", dwRegNum ); } } strcat_s( pRegisterName, nBufLen, buff ); break; case D3DSPR_RASTOUT: // vertex shader oPos
//V_snprintf( buff, sizeof( buff ), "oPos", dwRegNum ); // that stray parameter should have been a clue :)
switch( dwRegNum ) { case D3DSRO_POSITION: strcat_s( pRegisterName, nBufLen, "oPos" ); m_bDeclareVSOPos = true; break; case D3DSRO_FOG: strcat_s( pRegisterName, nBufLen, "oFog" ); m_bDeclareVSOFog = true; break;
default: printf("\nD3DSPR_RASTOUT: dwRegNum is %08x and token is %08x",dwRegNum,dwToken); Assert(0); break; } break; case D3DSPR_ATTROUT: Assert( m_bVertexShader ); V_snprintf( buff, sizeof( buff ), "oD%d", dwRegNum ); strcat_s( pRegisterName, nBufLen, buff ); m_bOutputColorRegister[dwRegNum] = true; break; case D3DSPR_TEXCRDOUT: // aliases to D3DSPR_OUTPUT
if ( m_bVertexShader ) { V_snprintf( buff, sizeof( buff ), "oT%d", dwRegNum ); m_dwTexCoordOutMask |= ( 0x00000001 << dwRegNum ); } else { V_snprintf( buff, sizeof( buff ), "oC%d", dwRegNum ); } strcat_s( pRegisterName, nBufLen, buff ); break; case D3DSPR_CONSTINT: Assert(0); V_snprintf( buff, sizeof( buff ), "xxx%d", dwRegNum ); strcat_s( pRegisterName, nBufLen, buff ); break; case D3DSPR_COLOROUT: if ( bGLSL ) { Assert( dwRegNum == 0 ); V_snprintf( buff, sizeof( buff ), "gl_FragmentColor" ); } else { V_snprintf( buff, sizeof( buff ), "oC%d", dwRegNum ); } strcat_s( pRegisterName, nBufLen, buff ); m_bOutputColorRegister[dwRegNum] = true; break; case D3DSPR_DEPTHOUT: V_snprintf( buff, sizeof( buff ), "oDepth" ); strcat_s( pRegisterName, nBufLen, buff ); m_bOutputDepthRegister = true; break; case D3DSPR_SAMPLER: V_snprintf( buff, sizeof( buff ), "texture[%d]", dwRegNum ); strcat_s( pRegisterName, nBufLen, buff ); break; case D3DSPR_CONST2: Assert(0); V_snprintf( buff, sizeof( buff ), "c%d", dwRegNum+2048); strcat_s( pRegisterName, nBufLen, buff ); break; case D3DSPR_CONST3: Assert(0); V_snprintf( buff, sizeof( buff ), "c%d", dwRegNum+4096); strcat_s( pRegisterName, nBufLen, buff ); break; case D3DSPR_CONST4: Assert(0); V_snprintf( buff, sizeof( buff ), "c%d", dwRegNum+6144); strcat_s( pRegisterName, nBufLen, buff ); break; case D3DSPR_CONSTBOOL: Assert(0); V_snprintf( buff, sizeof( buff ), "b%d", dwRegNum ); strcat_s( pRegisterName, nBufLen, buff ); break; case D3DSPR_LOOP: Assert(0); V_snprintf( buff, sizeof( buff ), "aL%d", dwRegNum ); strcat_s( pRegisterName, nBufLen, buff ); break; case D3DSPR_TEMPFLOAT16: Assert(0); V_snprintf( buff, sizeof( buff ), "temp_float16_xxx%d", dwRegNum ); strcat_s( pRegisterName, nBufLen, buff ); break; case D3DSPR_MISCTYPE: Assert(0); V_snprintf( buff, sizeof( buff ), "misc%d", dwRegNum ); strcat_s( pRegisterName, nBufLen, buff ); break; case D3DSPR_LABEL: Assert(0); V_snprintf( buff, sizeof( buff ), "label%d", dwRegNum ); strcat_s( pRegisterName, nBufLen, buff ); break; case D3DSPR_PREDICATE: Assert(0); V_snprintf( buff, sizeof( buff ), "p%d", dwRegNum ); strcat_s( pRegisterName, nBufLen, buff ); break; }
// If this is a dest register
if ( dwSourceOrDest == DST_REGISTER ) { //
// Write masks
//
// If some (not all, not none) of the write masks are set, we should include them
//
if ( bAllowWriteMask && ( !((dwToken & D3DSP_WRITEMASK_ALL) == D3DSP_WRITEMASK_ALL) || ((dwToken & D3DSP_WRITEMASK_ALL) == 0x00000000) ) ) { // Put the dot on there
strcat_s( pRegisterName, nBufLen, "." );
// Optionally put on the x, y, z or w
if ( dwToken & D3DSP_WRITEMASK_0 ) { strcat_s( pRegisterName, nBufLen, "x" ); } if ( dwToken & D3DSP_WRITEMASK_1 ) { strcat_s( pRegisterName, nBufLen, "y" ); } if ( dwToken & D3DSP_WRITEMASK_2 ) { strcat_s( pRegisterName, nBufLen, "z" ); } if ( dwToken & D3DSP_WRITEMASK_3 ) { strcat_s( pRegisterName, nBufLen, "w" ); } } } else // must be a source register
{ uint32 dwXSwizzle, dwYSwizzle, dwZSwizzle, dwWSwizzle;
// Mask out the swizzle modifier
dwSwizzle = dwToken & D3DVS_SWIZZLE_MASK;
// If there are any swizzles at all, tack on the appropriate notation
if ( dwSwizzle != D3DVS_NOSWIZZLE ) { // Separate out the two-bit codes for each component swizzle
dwXSwizzle = dwSwizzle & D3DVS_X_W; dwYSwizzle = dwSwizzle & D3DVS_Y_W; dwZSwizzle = dwSwizzle & D3DVS_Z_W; dwWSwizzle = dwSwizzle & D3DVS_W_W;
// Put on the dot
strcat_s( pRegisterName, nBufLen, "." );
// See where X comes from
switch ( dwXSwizzle ) { case D3DVS_X_X: strcat_s( pRegisterName, nBufLen, "x" ); break; case D3DVS_X_Y: strcat_s( pRegisterName, nBufLen, "y" ); break; case D3DVS_X_Z: strcat_s( pRegisterName, nBufLen, "z" ); break; case D3DVS_X_W: strcat_s( pRegisterName, nBufLen, "w" ); break; }
// If the source of the remaining components are aren't
// identical to the source of x, continue with swizzle
if ( ((dwXSwizzle >> D3DVS_SWIZZLE_SHIFT) != (dwYSwizzle >> (D3DVS_SWIZZLE_SHIFT + 2))) || // X and Y sources match?
((dwXSwizzle >> D3DVS_SWIZZLE_SHIFT) != (dwZSwizzle >> (D3DVS_SWIZZLE_SHIFT + 4))) || // X and Z sources match?
((dwXSwizzle >> D3DVS_SWIZZLE_SHIFT) != (dwWSwizzle >> (D3DVS_SWIZZLE_SHIFT + 6)))) // X and W sources match?
{
// OpenGL seems to want us to have either 1 or 4 components in a swizzle, so just plow on through the rest
switch ( dwYSwizzle ) { case D3DVS_Y_X: strcat_s( pRegisterName, nBufLen, "x" ); break; case D3DVS_Y_Y: strcat_s( pRegisterName, nBufLen, "y" ); break; case D3DVS_Y_Z: strcat_s( pRegisterName, nBufLen, "z" ); break; case D3DVS_Y_W: strcat_s( pRegisterName, nBufLen, "w" ); break; }
switch ( dwZSwizzle ) { case D3DVS_Z_X: strcat_s( pRegisterName, nBufLen, "x" ); break; case D3DVS_Z_Y: strcat_s( pRegisterName, nBufLen, "y" ); break; case D3DVS_Z_Z: strcat_s( pRegisterName, nBufLen, "z" ); break; case D3DVS_Z_W: strcat_s( pRegisterName, nBufLen, "w" ); break; }
switch ( dwWSwizzle ) { case D3DVS_W_X: strcat_s( pRegisterName, nBufLen, "x" ); break; case D3DVS_W_Y: strcat_s( pRegisterName, nBufLen, "y" ); break; case D3DVS_W_Z: strcat_s( pRegisterName, nBufLen, "z" ); break; case D3DVS_W_W: strcat_s( pRegisterName, nBufLen, "w" ); break; }
}
}
// If there are any source modifiers, check to see if they're at
// least partially "postfix" and tack them on as appropriate
if ( dwSrcModifier != D3DSPSM_NONE ) { switch ( dwSrcModifier ) { case D3DSPSM_BIAS: // bias
case D3DSPSM_BIASNEG: // bias and negate
Assert(0); strcat_s( pRegisterName, nBufLen, "_bx2" ); break; case D3DSPSM_SIGN: // sign
case D3DSPSM_SIGNNEG: // sign and negate
Assert(0); strcat_s( pRegisterName, nBufLen, "_sgn" ); break; case D3DSPSM_X2: // *2
case D3DSPSM_X2NEG: // *2 and negate
Assert(0); strcat_s( pRegisterName, nBufLen, "_x2" ); break; case D3DSPSM_ABS: // abs()
case D3DSPSM_ABSNEG: // -abs()
Assert(0); strcat_s( pRegisterName, nBufLen, ")" ); break; case D3DSPSM_DZ: // divide through by z component
Assert(0); strcat_s( pRegisterName, nBufLen, "_dz" ); break; case D3DSPSM_DW: // divide through by w component
Assert(0); strcat_s( pRegisterName, nBufLen, "_dw" ); break; } } // end postfix modifiers (really only ps.1.x)
}}
// These are the only ARL instructions that should appear in the instruction stream
void D3DToGL_ASM::InsertMoveInstruction( char *pCode, int nCodeSize, int nARLComponent ){ switch ( nARLComponent ) { case ARL_DEST_X: strcat_s( pCode, nCodeSize, "ARL a0.x, VEC_ADDRESS_REG.x;\n" ); break; case ARL_DEST_Y: strcat_s( pCode, nCodeSize, "ARL a0.x, VEC_ADDRESS_REG.y;\n" ); break; case ARL_DEST_Z: strcat_s( pCode, nCodeSize, "ARL a0.x, VEC_ADDRESS_REG.z;\n" ); break; case ARL_DEST_W: strcat_s( pCode, nCodeSize, "ARL a0.x, VEC_ADDRESS_REG.w;\n" ); break; }}
// This optionally inserts a move from our dummy address register to the .x component of the real one
void D3DToGL_ASM::InsertMoveFromAddressRegister( char *pCode, int nCodeSize, int nARLComp0, int nARLComp1, int nARLComp2 = ARL_DEST_NONE ){ int nNumSwizzles = 0;
if ( nARLComp0 != ARL_DEST_NONE ) nNumSwizzles++;
if ( nARLComp1 != ARL_DEST_NONE ) nNumSwizzles++;
if ( nARLComp2 != ARL_DEST_NONE ) nNumSwizzles++;
// We shouldn't have any more than one indirect address usage in a single instruction
Assert( nNumSwizzles < 2 );
if ( nARLComp0 != ARL_DEST_NONE ) { InsertMoveInstruction( pCode, nCodeSize, nARLComp0 ); } else if ( nARLComp1 != ARL_DEST_NONE ) { InsertMoveInstruction( pCode, nCodeSize, nARLComp1 ); } else if ( nARLComp2 != ARL_DEST_NONE ) { InsertMoveInstruction( pCode, nCodeSize, nARLComp2 ); }}
//------------------------------------------------------------------------------
// TranslateShader()
//
// This is the main function that the outside world sees. A pointer to the
// uint32 stream returned from the D3DX compile routine is parsed and used
// to write human-readable asm code into the character array pointed to by
// pDisassembledCode. An error code is returned.
//------------------------------------------------------------------------------
static int g_translationCounter = 0;
int D3DToGL_ASM::TranslateShader( uint32* code, char *pDisassembledCode, int nBufLen, bool *bVertexShader, uint32 options, int32 nShadowDepthSampler, char *debugLabel ){ uint32 i, dwToken, dwRegToken, inst, nNumTokensToSkip; char buff[256]; char pDestReg[32]; char pSrc0Reg[32]; char pSrc1Reg[32]; char pSrc2Reg[32];
int nARLComp0, nARLComp1, nARLComp2;
// obey options
m_bUseEnvParams = (options & D3DToGL_OptionUseEnvParams) != 0; m_bDoFixupZ = (options & D3DToGL_OptionDoFixupZ) != 0; m_bDoFixupY = (options & D3DToGL_OptionDoFixupY) != 0; m_bDoUserClipPlanes = (options & D3DToGL_OptionDoUserClipPlanes) != 0;
// debugging
m_bSpew = (options & D3DToGL_OptionSpew) != 0; // m_bSpew |= (g_translationCounter == 1012 ); // interested in this specific translation run
// These are not accessed below in a way that will cause them to grow, so
// we could overflow these and/or the buffer pointed to by pDisassembledCode
CUtlBuffer bufAttribCode( 100, 10000, CUtlBuffer::TEXT_BUFFER ); CUtlBuffer bufParamCode( 100, 10000, CUtlBuffer::TEXT_BUFFER ); CUtlBuffer bufALUCode( 100, 30000, CUtlBuffer::TEXT_BUFFER );
// Pointers to text buffers for assembling sections of the program
char *pHeaderCode = pDisassembledCode; char *pAttribMapStart = NULL; char *pAttribCode = (char *)bufAttribCode.Base(); char *pParamCode = (char *)bufParamCode.Base(); char *pALUCode = (char *)bufALUCode.Base();
V_snprintf( pHeaderCode, nBufLen, "" ); V_snprintf( pAttribCode, bufAttribCode.Size(), "" ); V_snprintf( pParamCode, bufParamCode.Size(), "" ); V_snprintf( pALUCode, bufALUCode.Size(), "" );
for ( i=0; i<MAX_SHADER_CONSTANTS; i++ ) { m_bConstantRegisterReferenced[i] = false; m_bConstantRegisterDefined[i] = false; }
// Track shadow sampler usage for proper declaration
m_nShadowDepthSampler = nShadowDepthSampler; m_bDeclareShadowOption = false;
// Various flags set while parsing code to drive various declaration instructions
m_bNeedsD2AddTemp = false; m_bNeedsLerpTemp = false; m_bNeedsNRMTemp = false; m_bNeedsSinCosDeclarations = false; m_bDeclareAddressReg = false; m_bDeclareVSOPos = false; m_bDeclareVSOFog = false; m_dwTexCoordOutMask = 0; m_bOutputColorRegister[0] = false; m_bOutputColorRegister[1] = false; m_bOutputColorRegister[2] = false; m_bOutputColorRegister[3] = false; m_bOutputDepthRegister = false; m_dwTempUsageMask = 0x00000000;
memset( m_dwAttribMap, 0xFF, sizeof(m_dwAttribMap) ); m_pdwBaseToken = m_pdwNextToken = code; // Initialize dwToken pointers
dwToken = GetNextToken(); m_dwMajorVersion = D3DSHADER_VERSION_MAJOR( dwToken ); m_dwMinorVersion = D3DSHADER_VERSION_MINOR( dwToken );
// We only do vs_2_0 and ps_2_x
if ( m_dwMajorVersion != 2 ) { Debugger(); }
// If pixel shader
if ( ( dwToken & 0xFFFF0000 ) == 0xFFFF0000 ) { V_snprintf( pHeaderCode, nBufLen, "!!ARBfp1.0\n" ); m_bVertexShader = false; } else // vertex shader
{ if (m_bDoUserClipPlanes) { // include "OPTION NV_vertex_program2;"
V_snprintf( pHeaderCode, nBufLen, "!!ARBvp1.0\n#//ATTRIBMAP-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx\nOPTION NV_vertex_program2;\n" ); } else { // do not include "OPTION NV_vertex_program2;"
V_snprintf( pHeaderCode, nBufLen, "!!ARBvp1.0\n#//ATTRIBMAP-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx\n" ); }
// find that first 'x' which is where the attrib map will be written later.
pAttribMapStart = strchr( pHeaderCode, 'x'); m_bVertexShader = true; }
*bVertexShader = m_bVertexShader;
if ( m_bSpew ) { printf("\n************* translating shader " ); } int opcounter = 0; // Loop until we hit the end dwToken...note that D3DPS_END() == D3DVS_END() so this works for either
while ( dwToken != D3DPS_END() ) {#ifdef POSIX
int tokenIndex = m_pdwNextToken - code;#endif
int aluCodeLength0 = strlen( pALUCode ); dwToken = GetNextToken(); // Get next dwToken in the stream
inst = Opcode( dwToken ); // Mask out the instruction opcode
if ( m_bSpew ) {#ifdef POSIX
printf("\n** token# %04x inst# %04d opcode %s (%08x)", tokenIndex, opcounter, GLMDecode(eD3D_SIO, inst), dwToken );#endif
opcounter++; } switch ( inst ) { // -- No arguments at all -----------------------------------------------
case D3DSIO_NOP: case D3DSIO_PHASE: case D3DSIO_RET: case D3DSIO_ELSE: case D3DSIO_ENDIF: case D3DSIO_ENDLOOP: case D3DSIO_ENDREP: case D3DSIO_BREAK: Assert(0); PrintOpcode( inst, buff, sizeof( buff ) ); strcat_s( pALUCode, bufALUCode.Size(), buff ); strcat_s( pALUCode, bufALUCode.Size(), ";\n" ); break;
// -- "Declarative" non dcl ops ----------------------------------------
case D3DSIO_TEXDEPTH: case D3DSIO_TEXKILL:
PrintOpcode( inst, buff, sizeof( buff ) ); strcat_s( pALUCode, bufALUCode.Size(), buff );
dwToken = GetNextToken(); PrintParameterToString( dwToken, DST_REGISTER, buff, sizeof( buff ), false ); strcat_s( pALUCode, bufALUCode.Size(), buff ); strcat_s( pALUCode, bufALUCode.Size(), ";\n" ); break;
// -- Unary ops -------------------------------------------------
case D3DSIO_BEM: case D3DSIO_TEXBEM: case D3DSIO_TEXBEML: case D3DSIO_TEXDP3: case D3DSIO_TEXDP3TEX: case D3DSIO_TEXM3x2DEPTH: case D3DSIO_TEXM3x2TEX: case D3DSIO_TEXM3x3: case D3DSIO_TEXM3x3PAD: case D3DSIO_TEXM3x3TEX: case D3DSIO_TEXM3x3VSPEC: case D3DSIO_TEXREG2AR: case D3DSIO_TEXREG2GB: case D3DSIO_TEXREG2RGB: case D3DSIO_LABEL: case D3DSIO_CALL: case D3DSIO_IF: case D3DSIO_LOOP: case D3DSIO_REP: case D3DSIO_BREAKP: case D3DSIO_DSX: case D3DSIO_DSY: Assert(0); break;
case D3DSIO_NRM:
m_bNeedsNRMTemp = true;
dwToken = GetNextToken(); PrintParameterToString( dwToken, DST_REGISTER, pDestReg, sizeof( pDestReg ), false ); dwToken = GetNextToken(); PrintParameterToString( dwToken, SRC_REGISTER, pSrc0Reg, sizeof( pSrc0Reg ), false );
strcat_s( pALUCode, bufALUCode.Size(), "DP3 NRM_TEMP.w, " ); strcat_s( pALUCode, bufALUCode.Size(), pSrc0Reg ); strcat_s( pALUCode, bufALUCode.Size(), ", " ); strcat_s( pALUCode, bufALUCode.Size(), pSrc0Reg ); strcat_s( pALUCode, bufALUCode.Size(), ";\nRSQ NRM_TEMP.w, NRM_TEMP.w;\nMUL" ); strcat_s( pALUCode, bufALUCode.Size(), pDestReg ); strcat_s( pALUCode, bufALUCode.Size(), ", NRM_TEMP.w, " ); strcat_s( pALUCode, bufALUCode.Size(), pSrc0Reg ); strcat_s( pALUCode, bufALUCode.Size(), ";\n" ); break;
case D3DSIO_MOVA:
m_bDeclareAddressReg = true; PrintOpcode( inst, buff, sizeof( buff ) ); strcat_s( pALUCode, bufALUCode.Size(), buff );
dwToken = GetNextToken(); PrintParameterToString( dwToken, DST_REGISTER, buff, sizeof( buff ), false ); strcat_s( pALUCode, bufALUCode.Size(), buff ); strcat_s( pALUCode, bufALUCode.Size(), ", " );
dwToken = GetNextToken(); PrintParameterToString( dwToken, SRC_REGISTER, buff, sizeof( buff ), false ); strcat_s( pALUCode, bufALUCode.Size(), buff ); strcat_s( pALUCode, bufALUCode.Size(), ";\n" );
break; case D3DSIO_MOV: case D3DSIO_RCP: case D3DSIO_RSQ: case D3DSIO_EXP: case D3DSIO_EXPP: case D3DSIO_LOG: case D3DSIO_LOGP: case D3DSIO_FRC: case D3DSIO_LIT: case D3DSIO_ABS:
PrintOpcode( inst, buff, sizeof( buff ) ); strcat_s( pALUCode, bufALUCode.Size(), buff );
dwToken = GetNextToken(); PrintParameterToString( dwToken, DST_REGISTER, buff, sizeof( buff ), false ); strcat_s( pALUCode, bufALUCode.Size(), buff ); strcat_s( pALUCode, bufALUCode.Size(), ", " );
dwToken = GetNextToken(); PrintParameterToString( dwToken, SRC_REGISTER, buff, sizeof( buff ), false ); strcat_s( pALUCode, bufALUCode.Size(), buff ); strcat_s( pALUCode, bufALUCode.Size(), ";\n" ); break;
// -- Binary ops -------------------------------------------------
case D3DSIO_TEXM3x3SPEC: case D3DSIO_M4x4: case D3DSIO_M4x3: case D3DSIO_M3x4: case D3DSIO_M3x3: case D3DSIO_M3x2: case D3DSIO_CALLNZ: case D3DSIO_IFC: case D3DSIO_BREAKC: case D3DSIO_SETP: case D3DSIO_TEXLDL: Assert(0); break;
case D3DSIO_ADD: case D3DSIO_SUB: case D3DSIO_MUL: case D3DSIO_DP3: case D3DSIO_DP4: case D3DSIO_MIN: case D3DSIO_MAX: case D3DSIO_DST: case D3DSIO_SLT: case D3DSIO_SGE: case D3DSIO_CRS: case D3DSIO_POW:
// Print opcode and registers into separate buffers
PrintOpcode( inst, buff, sizeof( buff ) ); PrintParameterToString( GetNextToken(), DST_REGISTER, pDestReg, sizeof( pDestReg ), false ); nARLComp0 = ARL_DEST_NONE; PrintParameterToString( GetNextToken(), SRC_REGISTER, pSrc0Reg, sizeof( pSrc0Reg ), false, &nARLComp0 ); nARLComp1 = ARL_DEST_NONE; PrintParameterToString( GetNextToken(), SRC_REGISTER, pSrc1Reg, sizeof( pSrc1Reg ), false, &nARLComp1 );
// This optionally inserts a move from our dummy address register to the .x component of the real one
InsertMoveFromAddressRegister( pALUCode, bufALUCode.Size(), nARLComp0, nARLComp1 );
// Concat this instruction into instruction stream
strcat_s( pALUCode, bufALUCode.Size(), buff ); strcat_s( pALUCode, bufALUCode.Size(), pDestReg ); strcat_s( pALUCode, bufALUCode.Size(), ", " ); strcat_s( pALUCode, bufALUCode.Size(), pSrc0Reg ); strcat_s( pALUCode, bufALUCode.Size(), ", " ); strcat_s( pALUCode, bufALUCode.Size(), pSrc1Reg ); strcat_s( pALUCode, bufALUCode.Size(), ";\n" );
break;
// -- Ternary ops -------------------------------------------------
case D3DSIO_DP2ADD: m_bNeedsD2AddTemp = true;
PrintParameterToString( GetNextToken(), DST_REGISTER, pDestReg, sizeof( pDestReg ), false ); PrintParameterToString( GetNextToken(), SRC_REGISTER, pSrc0Reg, sizeof( pSrc0Reg ), false ); PrintParameterToString( GetNextToken(), SRC_REGISTER, pSrc1Reg, sizeof( pSrc1Reg ), false ); PrintParameterToString( GetNextToken(), SRC_REGISTER, pSrc2Reg, sizeof( pSrc2Reg ), false );
strcat_s( pALUCode, bufALUCode.Size(), "MOV DP2A0, " ); // MOV DP2A0, src0;
strcat_s( pALUCode, bufALUCode.Size(), pSrc0Reg ); strcat_s( pALUCode, bufALUCode.Size(), ";\nMOV DP2A0.z, 1;\n" );// MOV DP2A0.z, 1;
strcat_s( pALUCode, bufALUCode.Size(), "MOV DP2A1, " ); // MOV DP2A1, src1;
strcat_s( pALUCode, bufALUCode.Size(), pSrc1Reg ); strcat_s( pALUCode, bufALUCode.Size(), ";\nMOV DP2A1.z, " ); // MOV DP2A1.z, src2;
strcat_s( pALUCode, bufALUCode.Size(), pSrc2Reg ); // DP3 dest, DP2A0, DP2A1;
strcat_s( pALUCode, bufALUCode.Size(), ";\nDP3" );
strcat_s( pALUCode, bufALUCode.Size(), pDestReg ); strcat_s( pALUCode, bufALUCode.Size(), ", DP2A0, DP2A1;\n" ); break;
case D3DSIO_LRP:
if ( !m_bVertexShader ) { PrintOpcode( inst, buff, sizeof( buff ) ); strcat_s( pALUCode, bufALUCode.Size(), buff ); PrintParameterToString( GetNextToken(), DST_REGISTER, buff, sizeof( buff ), false ); strcat_s( pALUCode, bufALUCode.Size(), buff ); strcat_s( pALUCode, bufALUCode.Size(), ", " ); PrintParameterToString( GetNextToken(), SRC_REGISTER, buff, sizeof( buff ), false ); strcat_s( pALUCode, bufALUCode.Size(), buff ); strcat_s( pALUCode, bufALUCode.Size(), ", " ); PrintParameterToString( GetNextToken(), SRC_REGISTER, buff, sizeof( buff ), false ); strcat_s( pALUCode, bufALUCode.Size(), buff ); strcat_s( pALUCode, bufALUCode.Size(), ", " ); PrintParameterToString( GetNextToken(), SRC_REGISTER, buff, sizeof( buff ), false ); strcat_s( pALUCode, bufALUCode.Size(), buff ); strcat_s( pALUCode, bufALUCode.Size(), ";\n" ); } else // VS doesn't actually have a LRP instruction. Emulate with a SUB and a MAD
{ m_bNeedsLerpTemp = true;
// dest = src0 * (src1 - src2) + src2;
PrintParameterToString( GetNextToken(), DST_REGISTER, pDestReg, sizeof( pDestReg ), false ); PrintParameterToString( GetNextToken(), SRC_REGISTER, pSrc0Reg, sizeof( pSrc0Reg ), false ); PrintParameterToString( GetNextToken(), SRC_REGISTER, pSrc1Reg, sizeof( pSrc1Reg ), false ); PrintParameterToString( GetNextToken(), SRC_REGISTER, pSrc2Reg, sizeof( pSrc2Reg ), false );
strcat_s( pALUCode, bufALUCode.Size(), "SUB LRP_TEMP, " ); // SUB LRP_TEMP, src1, src2;
strcat_s( pALUCode, bufALUCode.Size(), pSrc1Reg ); strcat_s( pALUCode, bufALUCode.Size(), ", " ); strcat_s( pALUCode, bufALUCode.Size(), pSrc2Reg ); strcat_s( pALUCode, bufALUCode.Size(), ";\n" );
strcat_s( pALUCode, bufALUCode.Size(), "MAD" ); // MAD dst, src0, LRP_TEMP, src2;
strcat_s( pALUCode, bufALUCode.Size(), pDestReg ); strcat_s( pALUCode, bufALUCode.Size(), ", " ); strcat_s( pALUCode, bufALUCode.Size(), pSrc0Reg ); strcat_s( pALUCode, bufALUCode.Size(), ", LRP_TEMP, " ); strcat_s( pALUCode, bufALUCode.Size(), pSrc2Reg ); strcat_s( pALUCode, bufALUCode.Size(), ";\n" ); } break;
case D3DSIO_SGN: Assert( m_bVertexShader ); Assert(0); // TODO emulate with SLT etc
break; case D3DSIO_CND: Assert(0); break; case D3DSIO_CMP: Assert( !m_bVertexShader );
// In Direct3D, result = (src0 >= 0.0) ? src1 : src2
// In OpenGL, result = (src0 < 0.0) ? src1 : src2
//
// As a result, arguments are effectively in a different order than Direct3D! !#$&*!%#$&
PrintParameterToString( GetNextToken(), DST_REGISTER, pDestReg, sizeof( pDestReg ), false ); PrintParameterToString( GetNextToken(), SRC_REGISTER, pSrc0Reg, sizeof( pSrc0Reg ), false ); PrintParameterToString( GetNextToken(), SRC_REGISTER, pSrc1Reg, sizeof( pSrc1Reg ), false ); PrintParameterToString( GetNextToken(), SRC_REGISTER, pSrc2Reg, sizeof( pSrc2Reg ), false );
strcat_s( pALUCode, bufALUCode.Size(), "CMP" ); strcat_s( pALUCode, bufALUCode.Size(), pDestReg ); strcat_s( pALUCode, bufALUCode.Size(), ", " ); strcat_s( pALUCode, bufALUCode.Size(), pSrc0Reg ); strcat_s( pALUCode, bufALUCode.Size(), ", " ); strcat_s( pALUCode, bufALUCode.Size(), pSrc2Reg ); // Src 2 |
strcat_s( pALUCode, bufALUCode.Size(), ", " ); // |--- Swap these guys from Direct3D's convention
strcat_s( pALUCode, bufALUCode.Size(), pSrc1Reg ); // Src 1 |
strcat_s( pALUCode, bufALUCode.Size(), ";\n" ); break;
case D3DSIO_SINCOS:
// This is the code sequence recommended to IHVs by Microsoft in the DirectX 9 DDK:
//
// http://msdn.microsoft.com/en-us/library/ms800337.aspx
//
// MUL SC_TEMP.z, src, src;
// MAD SC_TEMP.xy, SC_TEMP.z, scA, scA.wzyx;
// MAD SC_TEMP.xy, SC_TEMP, SC_TEMP.z, scB;
// MAD SC_TEMP.xy, SC_TEMP, SC_TEMP.z, scB.wzyx;
// MUL SC_TEMP.x, SC_TEMP.x, src;
// MUL SC_TEMP.xy, SC_TEMP, SC_TEMP.x;
// ADD SC_TEMP.xy, SC_TEMP, SC_TEMP;
// ADD SC_TEMP.x, -SC_TEMP.x, scB.z;
m_bNeedsSinCosDeclarations = true;
PrintParameterToString( GetNextToken(), DST_REGISTER, pDestReg, sizeof( pDestReg ), false ); PrintParameterToString( GetNextToken(), SRC_REGISTER, pSrc0Reg, sizeof( pSrc0Reg ), false );
// Eat two more tokens since D3D defines similar Taylor series constants that we won't need
SkipTokens( 2 );
strcat_s( pALUCode, bufALUCode.Size(), "MUL SC_TEMP.z, " ); // MUL SC_TEMP.z, src, src;
strcat_s( pALUCode, bufALUCode.Size(), pSrc0Reg ); strcat_s( pALUCode, bufALUCode.Size(), ", " ); strcat_s( pALUCode, bufALUCode.Size(), pSrc0Reg ); strcat_s( pALUCode, bufALUCode.Size(), ";\n" );
strcat_s( pALUCode, bufALUCode.Size(), "MAD SC_TEMP.xy, SC_TEMP.z, scA, scA.wzyx;\n" ); strcat_s( pALUCode, bufALUCode.Size(), "MAD SC_TEMP.xy, SC_TEMP, SC_TEMP.z, scB;\n" ); strcat_s( pALUCode, bufALUCode.Size(), "MAD SC_TEMP.xy, SC_TEMP, SC_TEMP.z, scB.wzyx;\n" );
strcat_s( pALUCode, bufALUCode.Size(), "MUL SC_TEMP.x, SC_TEMP.x, " ); strcat_s( pALUCode, bufALUCode.Size(), pSrc0Reg ); strcat_s( pALUCode, bufALUCode.Size(), ";\n" ); strcat_s( pALUCode, bufALUCode.Size(), "MUL SC_TEMP.xy, SC_TEMP, SC_TEMP.x;\n" ); strcat_s( pALUCode, bufALUCode.Size(), "ADD SC_TEMP.xy, SC_TEMP, SC_TEMP;\n" ); strcat_s( pALUCode, bufALUCode.Size(), "ADD SC_TEMP.x, -SC_TEMP.x, scB.z;\n" );
strcat_s( pALUCode, bufALUCode.Size(), "MOV" ); strcat_s( pALUCode, bufALUCode.Size(), pDestReg ); strcat_s( pALUCode, bufALUCode.Size(), ", SC_TEMP;\n" ); break;
case D3DSIO_MAD: // Print opcode and registers into separate buffers
PrintOpcode( inst, buff, sizeof( buff ) ); PrintParameterToString( GetNextToken(), DST_REGISTER, pDestReg, sizeof( pDestReg ), false ); nARLComp0 = ARL_DEST_NONE; PrintParameterToString( GetNextToken(), SRC_REGISTER, pSrc0Reg, sizeof( pSrc0Reg ), false, &nARLComp0 ); nARLComp1 = ARL_DEST_NONE; PrintParameterToString( GetNextToken(), SRC_REGISTER, pSrc1Reg, sizeof( pSrc1Reg ), false, &nARLComp1 ); nARLComp2 = ARL_DEST_NONE; PrintParameterToString( GetNextToken(), SRC_REGISTER, pSrc2Reg, sizeof( pSrc2Reg ), false, &nARLComp2 );
// This optionally inserts a move from our dummy address register to the .x component of the real one
InsertMoveFromAddressRegister( pALUCode, bufALUCode.Size(), nARLComp0, nARLComp1, nARLComp2 );
// Concat this instruction into instruction stream
strcat_s( pALUCode, bufALUCode.Size(), buff ); strcat_s( pALUCode, bufALUCode.Size(), pDestReg ); strcat_s( pALUCode, bufALUCode.Size(), ", " ); strcat_s( pALUCode, bufALUCode.Size(), pSrc0Reg ); strcat_s( pALUCode, bufALUCode.Size(), ", " ); strcat_s( pALUCode, bufALUCode.Size(), pSrc1Reg ); strcat_s( pALUCode, bufALUCode.Size(), ", " ); strcat_s( pALUCode, bufALUCode.Size(), pSrc2Reg ); strcat_s( pALUCode, bufALUCode.Size(), ";\n" );
break;
// -- Quaternary op ------------------------------------------------
case D3DSIO_TEXLDD: PrintOpcode( inst, buff, sizeof( buff ) ); strcat_s( pALUCode, bufALUCode.Size(), buff ); PrintParameterToString( GetNextToken(), DST_REGISTER, buff, sizeof( buff ), false ); strcat_s( pALUCode, bufALUCode.Size(), buff ); strcat_s( pALUCode, bufALUCode.Size(), ", " ); PrintParameterToString( GetNextToken(), SRC_REGISTER, buff, sizeof( buff ), false ); strcat_s( pALUCode, bufALUCode.Size(), buff ); strcat_s( pALUCode, bufALUCode.Size(), ", " ); PrintParameterToString( GetNextToken(), SRC_REGISTER, buff, sizeof( buff ), false ); strcat_s( pALUCode, bufALUCode.Size(), buff ); strcat_s( pALUCode, bufALUCode.Size(), ", " ); PrintParameterToString( GetNextToken(), SRC_REGISTER, buff, sizeof( buff ), false ); strcat_s( pALUCode, bufALUCode.Size(), buff ); strcat_s( pALUCode, bufALUCode.Size(), ", " ); PrintParameterToString( GetNextToken(), SRC_REGISTER, buff, sizeof( buff ), false ); strcat_s( pALUCode, bufALUCode.Size(), buff ); strcat_s( pALUCode, bufALUCode.Size(), ";\n" );
break; // -- Special cases: texcoord vs texcrd and tex vs texld -----------
case D3DSIO_TEXCOORD: Assert(0);
// If ps_1_4, this is texcrd
if ((m_dwMajorVersion == 1) && (m_dwMinorVersion == 4) && (!m_bVertexShader)) { strcat_s( pALUCode, bufALUCode.Size(), "texcrd" ); } else // else it's texcoord
{ Assert(0); strcat_s( pALUCode, bufALUCode.Size(), "texcoord" ); }
PrintParameterToString( GetNextToken(), DST_REGISTER, buff, sizeof( buff ), false ); strcat_s( pALUCode, bufALUCode.Size(), buff );
// If ps_1_4, texcrd also has a source parameter
if ((m_dwMajorVersion == 1) && (m_dwMinorVersion == 4) && (!m_bVertexShader)) { strcat_s( pALUCode, bufALUCode.Size(), ", " ); PrintParameterToString( GetNextToken(), SRC_REGISTER, buff, sizeof( buff ), false ); strcat_s( pALUCode, bufALUCode.Size(), buff ); }
strcat_s( pALUCode, bufALUCode.Size(), ";\n" ); break;
case D3DSIO_TEX:
if( ( OpcodeSpecificData( dwToken ) << D3DSP_OPCODESPECIFICCONTROL_SHIFT ) == D3DSI_TEXLD_PROJECT ) { strcat_s( pALUCode, bufALUCode.Size(), "TXP" ); } else if( ( OpcodeSpecificData( dwToken ) << D3DSP_OPCODESPECIFICCONTROL_SHIFT) == D3DSI_TEXLD_BIAS ) { strcat_s( pALUCode, bufALUCode.Size(), "TXB" ); } else { strcat_s( pALUCode, bufALUCode.Size(), "TEX" ); }
// Destination
dwToken = GetNextToken(); PrintParameterToString( dwToken, DST_REGISTER, buff, sizeof( buff ), false ); strcat_s( pALUCode, bufALUCode.Size(), buff ); strcat_s( pALUCode, bufALUCode.Size(), ", " );
// Source0
dwToken = GetNextToken(); PrintParameterToString( dwToken, SRC_REGISTER, buff, sizeof( buff ), false ); strcat_s( pALUCode, bufALUCode.Size(), buff ); strcat_s( pALUCode, bufALUCode.Size(), ", " );
// Source1
dwToken = GetNextToken(); PrintParameterToString( dwToken, SRC_REGISTER, buff, sizeof( buff ), false ); strcat_s( pALUCode, bufALUCode.Size(), buff ); strcat_s( pALUCode, bufALUCode.Size(), ", " );
// Syntax for shadow depth sampler
if ( ( (int) ( dwToken & D3DSP_REGNUM_MASK ) ) == m_nShadowDepthSampler ) { m_bDeclareShadowOption = true;
strcat_s( pALUCode, bufALUCode.Size(), "SHADOW" ); // Should result in SHADOW2D target
Assert( m_dwSamplerTypes[dwToken & D3DSP_REGNUM_MASK] == SAMPLER_TYPE_2D ); }
// Sampler dimension (2D, CUBE, 3D) determined by earlier declaration
strcat_s( pALUCode, bufALUCode.Size(), g_pSamplerStrings[m_dwSamplerTypes[dwToken & D3DSP_REGNUM_MASK]] ); strcat_s( pALUCode, bufALUCode.Size(), ";\n" ); break;
case D3DSIO_DCL:
if ( m_bVertexShader ) { dwToken = GetNextToken(); // What kind of dcl is this...
dwRegToken = GetNextToken(); // Look ahead to register token
strcat_s( pAttribCode, bufAttribCode.Size(), "ATTRIB" ); PrintParameterToString( dwRegToken, DST_REGISTER, buff, sizeof( buff ), false ); strcat_s( pAttribCode, bufAttribCode.Size(), buff ); strcat_s( pAttribCode, bufAttribCode.Size(), " = " );
// maintain attrib map
// check that this reg index has not been used before - if it has, let Houston know
uint regIndex = dwRegToken & D3DSP_REGNUM_MASK; if (m_dwAttribMap[ regIndex ] == 0xFFFFFFFF) { // log it
// semantic/usage in the higher nibble
// usage index in the low nibble
uint usage = dwToken & D3DSP_DCL_USAGE_MASK; uint usageindex = ( dwToken & D3DSP_DCL_USAGEINDEX_MASK ) >> D3DSP_DCL_USAGEINDEX_SHIFT; m_dwAttribMap[ regIndex ] = (usage<<4) | usageindex; // avoid writing 0xBB since runtime code uses that for an 'unused' marker
if (m_dwAttribMap[ regIndex ] == 0xBB) { Debugger(); } } else { //not OK
Debugger(); }
char temp[128]; // regnum goes straight into the vertex.attrib[n] index
sprintf( temp, "vertex.attrib[%-2d]; # %08x %08x\n", regIndex, dwToken, dwRegToken ); strcat_s( pAttribCode, bufAttribCode.Size(), temp ); } else { dwToken = GetNextToken(); // What kind of dcl is this...
dwRegToken = GetNextToken(); // Look ahead to register token
// If the register is a sampler, the dcl has a dimension decorator that we have to save for subsequent TEX instructions
if ( GetRegType( dwRegToken ) == D3DSPR_SAMPLER ) { switch ( TextureType( dwToken ) ) { default: case D3DSTT_UNKNOWN: case D3DSTT_2D: m_dwSamplerTypes[dwRegToken & D3DSP_REGNUM_MASK] = SAMPLER_TYPE_2D; break; case D3DSTT_CUBE: m_dwSamplerTypes[dwRegToken & D3DSP_REGNUM_MASK] = SAMPLER_TYPE_CUBE; break; case D3DSTT_VOLUME: m_dwSamplerTypes[dwRegToken & D3DSP_REGNUM_MASK] = SAMPLER_TYPE_3D; break; } } else // Not a sampler, we're going to generate attribute declaration code
{ strcat_s( pAttribCode, bufAttribCode.Size(), "ATTRIB" ); PrintParameterToString( dwRegToken, DST_REGISTER, buff, sizeof( buff ), false ); strcat_s( pAttribCode, bufAttribCode.Size(), buff ); strcat_s( pAttribCode, bufAttribCode.Size(), ";\n" ); } } break;
case D3DSIO_DEFB: case D3DSIO_DEFI: // Shouldn't be using bool or integer constants
Assert(0); break;
case D3DSIO_DEF:
//
// JasonM TODO: catch D3D's sincos-specific D3DSINCOSCONST1 and D3DSINCOSCONST2 constants and filter them out here
//
strcat_s( pParamCode, bufParamCode.Size(), "PARAM" ); // Which register is being defined
dwToken = GetNextToken();
// Note that this constant was explicitly defined
m_bConstantRegisterDefined[dwToken & D3DSP_REGNUM_MASK] = true;
PrintParameterToString( dwToken, DST_REGISTER, buff, sizeof( buff ), false ); strcat_s( pParamCode, bufParamCode.Size(), buff ); strcat_s( pParamCode, bufParamCode.Size(), " = { " );
// Run through the 4 floats
for ( i=0; i<4; i++ ) { float fConst = uint32ToFloat_ASM( GetNextToken() ); V_snprintf( buff, sizeof( buff ), i != 3 ? "%g, " : "%g", fConst); // end with comma-space
strcat_s( pParamCode, bufParamCode.Size(), buff ); }
strcat_s( pParamCode, bufParamCode.Size(), " };\n" ); break;
case D3DSIO_COMMENT: // Using OpcodeSpecificData() can fail here since the comments can be longer than 0xff dwords
nNumTokensToSkip = ( dwToken & 0x0fff0000 ) >> 16; SkipTokens( nNumTokensToSkip ); break;
case D3DSIO_END: break; } if ( m_bSpew ) { int aluCodeLength1 = strlen( pALUCode ); if ( aluCodeLength1 != aluCodeLength0 ) { // code was emitted
printf( "\n > %s", pALUCode + aluCodeLength0 ); aluCodeLength0 = aluCodeLength1; } } }
if ( m_bNeedsSinCosDeclarations ) { // Note that this constant packing expects .wzyx swizzles in case we ever use the SINCOS code in a ps_2_x shader
//
// The Microsoft documentation on this is all kinds of broken and, strangely, these numbers don't
// match the D3DSINCOSCONST1 and D3DSINCOSCONST2 constants used by the D3D assembly sincos instruction...
strcat_s( pParamCode, bufParamCode.Size(), "PARAM scA = { -1.55009923e-6, -2.17013894e-5, 0.00260416674, 0.00026041668 };\n" ); strcat_s( pParamCode, bufParamCode.Size(), "PARAM scB = { -0.020833334, -0.0625, 1.0, 0.5 };\n" ); }
// Just declare the whole constant store for non-def constants
if ( m_bVertexShader ) { if ( m_bUseEnvParams ) { strcat_s( pParamCode, bufParamCode.Size(), "PARAM c[256] = { program.env[0..255] };\n" ); } else { strcat_s( pParamCode, bufParamCode.Size(), "PARAM c[256] = { program.local[0..255] };\n" ); } } else { if ( m_bUseEnvParams ) { strcat_s( pParamCode, bufParamCode.Size(), "PARAM c[32] = { program.env[0..31] };\n" ); } else { strcat_s( pParamCode, bufParamCode.Size(), "PARAM c[32] = { program.local[0..31] };\n" ); } }
if ( m_bDeclareAddressReg ) { strcat_s( pParamCode, bufParamCode.Size(), "ADDRESS a0;\n" ); strcat_s( pParamCode, bufParamCode.Size(), "TEMP VEC_ADDRESS_REG;\n" ); }
// Declare temps in Param code buffer
for( int i=0; i<32; i++ ) { char tempBuff[32]; if ( m_dwTempUsageMask & ( 0x00000001 << i ) ) { V_snprintf( tempBuff, sizeof( tempBuff ), "TEMP r%d;\n", i ); strcat_s( pParamCode, bufParamCode.Size(), tempBuff ); } }
if ( m_bNeedsSinCosDeclarations ) { strcat_s( pParamCode, bufParamCode.Size(), "TEMP SC_TEMP;\n" ); }
// Optional temps needed to emulate d2add instruction in DX pixel shaders
if ( m_bNeedsD2AddTemp ) { strcat_s( pParamCode, bufParamCode.Size(), "TEMP DP2A0;\nTEMP DP2A1;\n" ); }
// Optional temp needed to emulate lerp instruction in DX vertex shaders
if ( m_bNeedsLerpTemp ) { strcat_s( pParamCode, bufParamCode.Size(), "TEMP LRP_TEMP;\n" ); }
// Optional temp needed to emulate NRM instruction in DX shaders
if ( m_bNeedsNRMTemp ) { strcat_s( pParamCode, bufParamCode.Size(), "TEMP NRM_TEMP;\n" ); }
// Pixel shader color outputs (MRT support?...just declare MRT outputs as useless TEMPS)
if ( !m_bVertexShader ) { if ( m_bOutputColorRegister[1] ) { strcat_s( pParamCode, bufParamCode.Size(), "TEMP oC1;\n" ); } if ( m_bOutputColorRegister[2] ) { strcat_s( pParamCode, bufParamCode.Size(), "TEMP oC2;\n" ); } if ( m_bOutputColorRegister[3] ) { strcat_s( pParamCode, bufParamCode.Size(), "TEMP oC3;\n" ); } if ( m_bOutputColorRegister[0] ) { strcat_s( pParamCode, bufParamCode.Size(), "OUTPUT oC0 = result.color;\n" ); } }
// this looks stale - ax it ?
//if (m_bVertexShader && !m_bDoFixupZ)
//{
// static char foo = 1;
// if(foo) Debugger();
//}
if ( m_bDeclareVSOPos && m_bVertexShader ) { if ( m_bDoFixupZ || m_bDoFixupY) { // don't write to real reg - declare a temp and then declare a new output reg oPosGL
strcat_s( pParamCode, bufParamCode.Size(), "TEMP oPos;\n" ); strcat_s( pParamCode, bufParamCode.Size(), "OUTPUT oPosGL = result.position;\n" ); // TODO: insert clip distance computation something like this:
//
// strcat_s( pALUCode, bufALUCode.Size(), "DP4 oCLP[0].x, oPos, c[215]; \n" );
//
if (m_bDoFixupZ) { // append insns to perform Z fixup
// new Z = (old Z * 2.0) - W
// negate Z, double it, then add the 'w'.
// near: Z=0 -> Z' = +1.0. this seems wrong....
// far: Z=1 -> Z' = -1.0 uh, this ain't right...
// strcat_s( pALUCode, bufALUCode.Size(), "MAD r0.z, -oPos.z, c[0].z, oPos.w; # z' = (2*-z)+w \n" );
// double Z, subtract 'w'.
// near: Z=0 -> Z' = -1.0.
// far: Z=1 -> Z' = +1.0
//strcat_s( pALUCode, bufALUCode.Size(), "MAD r0.z, oPos.z, c[0].z, -oPos.w; # z' = (2*z)-w \n" );
strcat_s( pALUCode, bufALUCode.Size(), "MAD oPos.z, oPos.z, c[0].z, -oPos.w; # z' = (2*z)-w \n" ); }
if (m_bDoFixupY) { // append insns to flip Y over
// new Y = -(old Y)
strcat_s( pALUCode, bufALUCode.Size(), "MOV oPos.y, -oPos.y; # y' = -y \n" ); }
strcat_s( pALUCode, bufALUCode.Size(), "MOV oPosGL, oPos; \n" ); } else { strcat_s( pParamCode, bufParamCode.Size(), "OUTPUT oPos = result.position;\n" );
// TODO: insert clip distance computation something like this:
//
// strcat_s( pALUCode, bufALUCode.Size(), "DP4 oCLP[0].x, oPos, c[215]; \n" );
//
} }
if (m_bVertexShader && m_bDoUserClipPlanes) { // insert oCLP generation insts
char temp[256];
if(0) { V_snprintf( temp, sizeof( temp ), "DP4 result.clip[0].x, oPos, c[%d];\n", DXABSTRACT_VS_CLIP_PLANE_BASE ); // ask GLM where to stash the secret params
V_snprintf( temp, sizeof( temp ), "DP4 result.clip[1].x, oPos, c[%d];\n", DXABSTRACT_VS_CLIP_PLANE_BASE+1 ); }
if(0) { V_snprintf( temp, sizeof( temp ), "DP4 o[CLP0].x, oPos, c[%d];\n", DXABSTRACT_VS_CLIP_PLANE_BASE ); // ask GLM where to stash the secret params
V_snprintf( temp, sizeof( temp ), "DP4 o[CLP1].x, oPos, c[%d];\n", DXABSTRACT_VS_CLIP_PLANE_BASE+1 ); }
if(1) { V_snprintf( temp, sizeof( temp ), "DP4 oClip0.x, oPos, c[%d];\n", DXABSTRACT_VS_CLIP_PLANE_BASE ); // ask GLM where to stash the secret params
V_snprintf( temp, sizeof( temp ), "DP4 oClip1.x, oPos, c[%d];\n", DXABSTRACT_VS_CLIP_PLANE_BASE+1 ); }
strcat_s( pALUCode, bufALUCode.Size(), temp ); }
if ( m_bDeclareVSOFog && m_bVertexShader ) { strcat_s( pParamCode, bufParamCode.Size(), "OUTPUT oFog = result.fogcoord;\n" ); }
for ( int i=0; i<32; i++ ) { char outTexCoordBuff[64]; if ( m_dwTexCoordOutMask & ( 0x00000001 << i ) ) { V_snprintf( outTexCoordBuff, sizeof( outTexCoordBuff ), "OUTPUT oT%d = result.texcoord[%d];\n", i, i ); strcat_s( pParamCode, bufParamCode.Size(), outTexCoordBuff ); } }
if ( m_bOutputColorRegister[0] && m_bVertexShader ) { strcat_s( pParamCode, bufParamCode.Size(), "OUTPUT oD0 = result.color;\n" ); }
if ( m_bOutputColorRegister[1] && m_bVertexShader ) { strcat_s( pParamCode, bufParamCode.Size(), "OUTPUT oD1 = result.color.secondary;\n" ); }
if ( m_bOutputDepthRegister && !m_bVertexShader ) { strcat_s( pParamCode, bufParamCode.Size(), "OUTPUT oDepth = result.depth;\n" ); }
if ( m_bDoUserClipPlanes && m_bVertexShader ) { strcat_s( pParamCode, bufParamCode.Size(), "OUTPUT oClip0 = result.clip[0];\n" ); strcat_s( pParamCode, bufParamCode.Size(), "OUTPUT oClip1 = result.clip[1];\n" ); } // do some annotation at the end of the attrib block
{ char temp[1000];
if (m_bVertexShader) { // write attrib map into the text starting at pAttribMapStart - two hex digits per attrib
for( int i=0; i<16; i++) { if (m_dwAttribMap[i] != 0xFFFFFFFF) { V_snprintf( temp, sizeof(temp), "%02X", m_dwAttribMap[i] ); memcpy( pAttribMapStart + (i*3), temp, 2 ); } } }
V_snprintf( temp, sizeof(temp), "#// trans#%d label:%s\n", g_translationCounter, debugLabel?debugLabel:"none" ); strcat_s( pAttribCode, bufAttribCode.Size(), temp );
g_translationCounter++; }
// If we actually sample from a shadow depth sampler, we need to declare the shadow option at the top
if ( m_bDeclareShadowOption ) { strcat_s( pHeaderCode, nBufLen, "OPTION ARB_fragment_program_shadow;\n" ); }
// Put all of the strings together for final program ( pHeaderCode + pAttribCode + pParamCode + pALUCode )
strcat_s( pHeaderCode, nBufLen, pAttribCode ); strcat_s( pHeaderCode, nBufLen, pParamCode ); strcat_s( pHeaderCode, nBufLen, pALUCode ); strcat_s( pHeaderCode, nBufLen, "END\n\0" );
if (m_bSpew) { printf("\n************* translation complete\n\n " ); }
return DISASM_OK;}
#endif
|
