//========= Copyright Valve Corporation, All rights reserved. ============// // TOGL CODE LICENSE // // Copyright 2011-2014 Valve Corporation // All Rights Reserved. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. //------------------------------------------------------------------------------ // DX9AsmToGL2.cpp //------------------------------------------------------------------------------ // Immediately include gl.h, etc. here to avoid compilation warnings. #include #include #include "togl/rendermechanism.h" #include "tier0/dbg.h" #include "tier1/strtools.h" #include "tier1/utlbuffer.h" #include "dx9asmtogl2.h" #include "materialsystem/IShader.h" // 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 // Flags to PrintUsageAndIndexToString. #define SEMANTIC_OUTPUT 0x01 #define SEMANTIC_INPUT 0x02 #define UNDECLARED_OUTPUT 0xFFFFFFFF #define UNDECLARED_INPUT 0xFFFFFFFF #ifndef POSIX #define Debugger() Assert(0) #endif //#define Assert(n) if( !(n) ){ TranslationError(); } static char *g_szVecZeros[] = { NULL, "0.0", "vec2( 0.0, 0.0 )", "vec3( 0.0, 0.0, 0.0 )", "vec4( 0.0, 0.0, 0.0, 0.0 )" }; static char *g_szVecOnes[] = { NULL, "1.0", "vec2( 1.0, 1.0 )", "vec3( 1.0, 1.0, 1.0 )", "vec4( 1.0, 1.0, 1.0, 1.0 )" }; static char *g_szDefaultSwizzle = "xyzw"; static char *g_szDefaultSwizzleStrings[] = { "x", "y", "z", "w" }; static char *g_szSamplerStrings[] = { "2D", "CUBE", "3D" }; static const char *g_pAtomicTempVarName = "atomic_temp_var"; static const char *g_pTangentAttributeName = "g_tangent"; int __cdecl SortInts( const int *a, const int *b ) { if ( *a < *b ) return -1; else if ( *a > *b ) return 1; else return 0; } void StripExtraTrailingZeros( char *pStr ) { int len = (int)V_strlen( pStr ); while ( len >= 2 && pStr[len-1] == '0' && pStr[len-2] != '.' ) { pStr[len-1] = 0; --len; } } void D3DToGL::PrintToBufWithIndents( CUtlBuffer &buf, const char *pFormat, ... ) { va_list marker; va_start( marker, pFormat ); char szTemp[1024]; V_vsnprintf( szTemp, sizeof( szTemp ), pFormat, marker ); va_end( marker ); PrintIndentation( (char*)buf.Base(), buf.Size() ); strcat_s( (char*)buf.Base(), buf.Size(), szTemp ); } void PrintToBuf( CUtlBuffer &buf, const char *pFormat, ... ) { va_list marker; va_start( marker, pFormat ); char szTemp[1024]; V_vsnprintf( szTemp, sizeof( szTemp ), pFormat, marker ); va_end( marker ); strcat_s( (char*)buf.Base(), buf.Size(), szTemp ); } void PrintToBuf( char *pOut, int nOutSize, const char *pFormat, ... ) { int nStrlen = V_strlen( pOut ); pOut += nStrlen; nOutSize -= nStrlen; va_list marker; va_start( marker, pFormat ); V_vsnprintf( pOut, nOutSize, pFormat, marker ); va_end( marker ); } // Return the number of letters following the dot. // Returns 4 if there is no dot. // (So "r0.xy" returns 2 and "r0" returns 4). int GetNumWriteMaskEntries( const char *pParam ) { const char *pDot = strchr( pParam, '.' ); if ( pDot ) return V_strlen( pDot + 1 ); else return 4; } const char* GetSwizzleDot( const char *pParam ) { const char *pDot = strrchr( pParam, '.' ); const char *pSquareClose = strrchr( pParam, ']' ); if ( pSquareClose ) { // The test against ']' catches cases like, so we point to the last dot vc[int(va_r.x) + 29].x if ( pDot && ( pSquareClose < pDot ) ) return pDot; else return NULL; } // Make sure the next character is a valid swizzle since we want to treat strings like vec4( gl_Normal, 0.0 ) as a whole param name. if ( pDot && ( ( *(pDot+1) == 'x' ) || ( *(pDot+1) == 'y' ) || ( *(pDot+1) == 'z' ) || ( *(pDot+1) == 'w' ) || ( *(pDot+1) == 'r' ) || ( *(pDot+1) == 'g' ) || ( *(pDot+1) == 'b' ) || ( *(pDot+1) == 'z' ) ) ) { return pDot; } return NULL; } int GetNumSwizzleComponents( const char *pParam ) { // Special scalar output which won't accept a swizzle if ( !V_stricmp( pParam, "gl_FogFragCoord" ) ) return 1; // Special scalar output which won't accept a swizzle if ( !V_stricmp( pParam, "gl_FragDepth" ) ) return 1; // Special scalar output which won't accept a swizzle if ( !V_stricmp( pParam, "a0" ) ) return 1; const char *pDot = GetSwizzleDot( pParam ); if ( pDot ) { pDot++; // Step over the dot int nNumSwizzleComponents = 0; while ( ( *pDot == 'x' ) || ( *pDot == 'y' ) || ( *pDot == 'z' ) || ( *pDot == 'w' ) || ( *pDot == 'r' ) || ( *pDot == 'g' ) || ( *pDot == 'b' ) || ( *pDot == 'z' ) ) { nNumSwizzleComponents++; pDot++; } return nNumSwizzleComponents; } return 0; } char GetSwizzleComponent( const char *pParam, int n ) { Assert( n < 4 ); const char *pDot = GetSwizzleDot( pParam ); if ( pDot ) { ++pDot; int nComponents = (int)V_strlen( pDot ); Assert( nComponents > 0 ); if ( n < nComponents ) return pDot[n]; else return pDot[nComponents-1]; } return g_szDefaultSwizzle[n]; } // Replace the parameter name and leave the swizzle intact. // So "somevar.xyz" becomes "othervar.xyz". void ReplaceParamName( const char *pSrc, const char *pNewParamName, char *pOut, int nOutLen ) { // Start with the new parameter name. V_strncpy( pOut, pNewParamName, nOutLen ); // Now add the swizzle if necessary. const char *pDot = GetSwizzleDot( pSrc ); if ( pDot ) { V_strncat( pOut, pDot, nOutLen ); } } void GetParamNameWithoutSwizzle( const char *pParam, char *pOut, int nOutLen ) { char *pParamStart = (char *) pParam; const char *pDot = GetSwizzleDot( pParam ); // dot followed by valid swizzle characters bool bAbsWrapper = false; // Check for abs() or -abs() wrapper and strip it off during the fixup if ( !V_strncmp( pParam, "abs(", 4 ) || !V_strncmp( pParam, "-abs(", 5 ) ) { const char *pOpenParen = strchr( pParam, '(' ); // FIRST opening paren const char *pClosingParen = strrchr( pParam, ')' ); // LAST closing paren Assert ( pOpenParen && pClosingParen ); pClosingParen; // hush compiler pParamStart = (char *) pOpenParen; pParamStart++; bAbsWrapper = true; } if ( pDot ) { int nToCopy = MIN( nOutLen-1, pDot - pParamStart ); memcpy( pOut, pParamStart, nToCopy ); pOut[nToCopy] = 0; } else { V_strncpy( pOut, pParamStart, bAbsWrapper ? nOutLen - 1 : nOutLen ); } } bool DoParamNamesMatch( const char *pParam1, const char *pParam2 ) { char szTemp[2][256]; GetParamNameWithoutSwizzle( pParam1, szTemp[0], sizeof( szTemp[0] ) ); GetParamNameWithoutSwizzle( pParam2, szTemp[1], sizeof( szTemp[1] ) ); return ( V_stricmp( szTemp[0], szTemp[1] ) == 0 ); } // Extract the n'th component of the swizzle mask. // If n would exceed the length of the swizzle mask, then it looks up into "xyzw". void WriteParamWithSingleMaskEntry( const char *pParam, int n, char *pOut, int nOutLen ) { bool bCloseParen = false; if ( !V_strncmp( pParam, "-abs(", 5 ) ) { V_strcpy( pOut, "-abs(" ); bCloseParen = true; pOut += 5; nOutLen -= 5; } else if ( !V_strncmp( pParam, "abs(", 4 ) ) { V_strcpy( pOut, "abs(" ); bCloseParen = true; pOut += 4; nOutLen -= 4; } GetParamNameWithoutSwizzle( pParam, pOut, nOutLen ); PrintToBuf( pOut, nOutLen, "." ); PrintToBuf( pOut, nOutLen, "%c", GetSwizzleComponent( pParam, n ) ); if ( bCloseParen ) { PrintToBuf( pOut, nOutLen, ")" ); } } float uint32ToFloat( uint32 dw ) { return *((float*)&dw); } CUtlString EnsureNumSwizzleComponents( const char *pSrcRegisterName, int nComponents ) { int nExisting = GetNumSwizzleComponents( pSrcRegisterName ); if ( nExisting == nComponents ) return pSrcRegisterName; bool bAbsWrapper = false; // Parameter wrapped in an abs() bool bAbsNegative = false; // -abs() char szSrcRegister[128]; V_strncpy( szSrcRegister, pSrcRegisterName, sizeof(szSrcRegister) ); // Check for abs() or -abs() wrapper and strip it off during the fixup if ( !V_strncmp( pSrcRegisterName, "abs(", 4 ) || !V_strncmp( pSrcRegisterName, "-abs(", 5 ) ) { bAbsWrapper = true; bAbsNegative = pSrcRegisterName[0] == '-'; const char *pOpenParen = strchr( pSrcRegisterName, '(' ); // FIRST opening paren const char *pClosingParen = strrchr( pSrcRegisterName, ')' ); // LAST closing paren Assert ( pOpenParen && pClosingParen ); // If we start with abs( and don't get both parens, something is very wrong // Copy out just the register name with no abs() int nRegNameLength = pClosingParen - pOpenParen - 1; V_strncpy( szSrcRegister, pOpenParen+1, nRegNameLength + 1 ); // Kind of a weird function...copy more than you need and slam the last char to NULL-terminate } char szReg[256]; GetParamNameWithoutSwizzle( szSrcRegister, szReg, sizeof( szReg ) ); if ( nComponents == 0 ) return szReg; PrintToBuf( szReg, sizeof( szReg ), "." ); if ( nExisting > nComponents ) { // DX ASM will sometimes have statements like "NRM r0.xyz, r1.yzww", where it just doesn't use the last part of r1. So we won't either. for ( int i=0; i < nComponents; i++ ) { PrintToBuf( szReg, sizeof( szReg ), "%c", GetSwizzleComponent( szSrcRegister, i ) ); } } else { if ( nExisting == 0 ) { // We've got something like r0 and need N more components, so add as much of "xyzw" is needed. for ( int i=0; i < nComponents; i++ ) PrintToBuf( szReg, sizeof( szReg ), "%c", g_szDefaultSwizzle[i] ); } else { // We've got something like r0.x and need N more components, so replicate the X so it looks like r0.xxx V_strncpy( szReg, szSrcRegister, sizeof( szReg ) ); char cLast = szSrcRegister[ V_strlen( szSrcRegister ) - 1 ]; for ( int i=nExisting; i < nComponents; i++ ) { PrintToBuf( szReg, sizeof( szReg ), "%c", cLast ); } } } if ( bAbsWrapper ) { char szTemp[128]; V_strncpy( szTemp, szReg, sizeof(szTemp) ); V_snprintf( szReg, sizeof( szReg ), "%sabs(%s)", bAbsNegative ? "-" : "", szTemp ) ; } return szReg; } static void TranslationError() { GLMDebugPrintf( "D3DToGL: GLSL translation error!\n" ); DebuggerBreakIfDebugging(); Error( "D3DToGL: GLSL translation error!\n" ); } D3DToGL::D3DToGL() { } uint32 D3DToGL::GetNextToken( void ) { uint32 dwToken = *m_pdwNextToken; m_pdwNextToken++; return dwToken; } void D3DToGL::SkipTokens( uint32 numToSkip ) { m_pdwNextToken += numToSkip; } uint32 D3DToGL::Opcode( uint32 dwToken ) { return ( dwToken & D3DSI_OPCODE_MASK ); } uint32 D3DToGL::OpcodeSpecificData (uint32 dwToken) { return ( ( dwToken & D3DSP_OPCODESPECIFICCONTROL_MASK ) >> D3DSP_OPCODESPECIFICCONTROL_SHIFT ); } uint32 D3DToGL::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 bool D3DToGL::OpenIntrinsic( uint32 inst, char* buff, int nBufLen, uint32 destDimension, uint32 nArgumentDimension ) { // Some GLSL intrinsics need type conversion, which we do in this routine // As a result, the caller must sometimes close both parentheses, not just one bool bDoubleClose = false; if ( nArgumentDimension == 0 ) { nArgumentDimension = 4; } switch ( inst ) { case D3DSIO_RSQ: V_snprintf( buff, nBufLen, "inversesqrt( " ); break; case D3DSIO_DP3: case D3DSIO_DP4: if ( destDimension == 1 ) { V_snprintf( buff, nBufLen, "dot( " ); } else { if ( !destDimension ) destDimension = 4; V_snprintf( buff, nBufLen, "vec%d( dot( ", destDimension ); bDoubleClose = true; } break; case D3DSIO_MIN: V_snprintf( buff, nBufLen, "min( " ); break; case D3DSIO_MAX: V_snprintf( buff, nBufLen, "max( " ); break; case D3DSIO_SLT: if ( nArgumentDimension == 1 ) { V_snprintf( buff, nBufLen, "float( " ); // lessThan doesn't have a scalar version } else { Assert( nArgumentDimension > 1 ); V_snprintf( buff, nBufLen, "vec%d( lessThan( ", nArgumentDimension ); bDoubleClose = true; } break; case D3DSIO_SGE: if ( nArgumentDimension == 1 ) { V_snprintf( buff, nBufLen, "float( " ); // greaterThanEqual doesn't have a scalar version } else { Assert( nArgumentDimension > 1 ); V_snprintf( buff, nBufLen, "vec%d( greaterThanEqual( ", nArgumentDimension ); bDoubleClose = true; } break; case D3DSIO_EXP: V_snprintf( buff, nBufLen, "exp( " ); // exp2 ? break; case D3DSIO_LOG: V_snprintf( buff, nBufLen, "log( " ); // log2 ? break; case D3DSIO_LIT: TranslationError(); V_snprintf( buff, nBufLen, "lit( " ); // gonna have to write this one break; case D3DSIO_DST: 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: TranslationError(); 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: TranslationError(); break; case D3DSIO_POW: V_snprintf( buff, nBufLen, "pow( " ); break; case D3DSIO_CRS: V_snprintf( buff, nBufLen, "cross( " ); break; case D3DSIO_SGN: TranslationError(); V_snprintf( buff, nBufLen, "sign( " ); break; case D3DSIO_ABS: V_snprintf( buff, nBufLen, "abs( " ); break; case D3DSIO_NRM: TranslationError(); V_snprintf( buff, nBufLen, "normalize( " ); break; case D3DSIO_SINCOS: TranslationError(); 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 TranslationError(); break; case D3DSIO_DEFB: case D3DSIO_DEFI: TranslationError(); 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: TranslationError(); V_snprintf( buff, nBufLen, "TEX" ); // We shouldn't 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: TranslationError(); break; case D3DSIO_EXPP: V_snprintf( buff, nBufLen, "exp( " ); break; case D3DSIO_LOGP: V_snprintf( buff, nBufLen, "log( " ); break; case D3DSIO_CND: TranslationError(); break; case D3DSIO_DEF: TranslationError(); V_snprintf( buff, nBufLen, "DEF" ); break; case D3DSIO_TEXREG2RGB: case D3DSIO_TEXDP3TEX: case D3DSIO_TEXM3x2DEPTH: case D3DSIO_TEXDP3: case D3DSIO_TEXM3x3: TranslationError(); break; case D3DSIO_TEXDEPTH: V_snprintf( buff, nBufLen, "texdepth" ); break; case D3DSIO_CMP: TranslationError(); Assert( !m_bVertexShader ); V_snprintf( buff, nBufLen, "CMP" ); break; case D3DSIO_BEM: TranslationError(); break; case D3DSIO_DP2ADD: TranslationError(); break; case D3DSIO_DSX: case D3DSIO_DSY: TranslationError(); break; case D3DSIO_TEXLDD: V_snprintf( buff, nBufLen, "texldd" ); break; case D3DSIO_SETP: TranslationError(); break; case D3DSIO_TEXLDL: V_snprintf( buff, nBufLen, "texldl" ); break; case D3DSIO_BREAKP: case D3DSIO_PHASE: TranslationError(); break; } return bDoubleClose; } const char* D3DToGL::GetGLSLOperatorString( uint32 inst ) { if ( inst == D3DSIO_ADD ) return "+"; else if ( inst == D3DSIO_SUB ) return "-"; else if ( inst == D3DSIO_MUL ) return "*"; Error( "GetGLSLOperatorString: unknown operator" ); return "zzzz"; } // Print ASM opcode void D3DToGL::PrintOpcode( uint32 inst, char* buff, int nBufLen ) { switch ( inst ) { case D3DSIO_NOP: V_snprintf( buff, nBufLen, "NOP" ); TranslationError(); 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: TranslationError(); 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: TranslationError(); V_snprintf( buff, nBufLen, "SGN" ); break; case D3DSIO_ABS: V_snprintf( buff, nBufLen, "ABS" ); break; case D3DSIO_NRM: TranslationError(); 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: TranslationError(); 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: TranslationError(); 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: TranslationError(); break; case D3DSIO_EXPP: V_snprintf( buff, nBufLen, "EXP" ); break; case D3DSIO_LOGP: V_snprintf( buff, nBufLen, "LOG" ); break; case D3DSIO_CND: TranslationError(); 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: TranslationError(); 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: TranslationError(); break; case D3DSIO_DP2ADD: TranslationError(); break; case D3DSIO_DSX: case D3DSIO_DSY: TranslationError(); break; case D3DSIO_TEXLDD: V_snprintf( buff, nBufLen, "texldd" ); break; case D3DSIO_SETP: TranslationError(); break; case D3DSIO_TEXLDL: V_snprintf( buff, nBufLen, "texldl" ); break; case D3DSIO_BREAKP: case D3DSIO_PHASE: TranslationError(); break; } } CUtlString D3DToGL::GetUsageAndIndexString( uint32 dwToken, int fSemanticFlags ) { char szTemp[1024]; PrintUsageAndIndexToString( dwToken, szTemp, sizeof( szTemp ), fSemanticFlags ); return szTemp; } //------------------------------------------------------------------------------ // 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::PrintUsageAndIndexToString( uint32 dwToken, char* strUsageUsageIndexName, int nBufLen, int fSemanticFlags ) { uint32 dwUsage = ( dwToken & D3DSP_DCL_USAGE_MASK ); uint32 dwUsageIndex = ( dwToken & D3DSP_DCL_USAGEINDEX_MASK ) >> D3DSP_DCL_USAGEINDEX_SHIFT; switch ( dwUsage ) { case D3DDECLUSAGE_POSITION: if ( m_bVertexShader ) { if ( fSemanticFlags & SEMANTIC_OUTPUT ) V_snprintf( strUsageUsageIndexName, nBufLen, "vTempPos" ); // effectively gl_Position else V_snprintf( strUsageUsageIndexName, nBufLen, "gl_Vertex" ); } else { // .xy = position in viewport coordinates // .z = depth V_snprintf( strUsageUsageIndexName, nBufLen, "gl_FragCoord" ); } 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, "vec4( gl_Normal, 0.0 )" ); break; case D3DDECLUSAGE_PSIZE: TranslationError(); V_snprintf( strUsageUsageIndexName, nBufLen, "_psize" ); // no analog break; case D3DDECLUSAGE_TEXCOORD: V_snprintf( strUsageUsageIndexName, nBufLen, "oT%d", dwUsageIndex ); break; case D3DDECLUSAGE_TANGENT: NoteTangentInputUsed(); V_strncpy( strUsageUsageIndexName, g_pTangentAttributeName, nBufLen ); break; case D3DDECLUSAGE_BINORMAL: V_snprintf( strUsageUsageIndexName, nBufLen, "vertex.attrib[14]" ); // aka texc[6] break; // case D3DDECLUSAGE_TESSFACTOR: // TranslationError(); // V_snprintf( strUsageUsageIndexName, nBufLen, "_position" ); // no analog // break; // case D3DDECLUSAGE_POSITIONT: // TranslationError(); // V_snprintf( strUsageUsageIndexName, nBufLen, "_positiont" ); // no analog // break; case D3DDECLUSAGE_COLOR: Assert( dwUsageIndex <= 1 ); // if ( fSemanticFlags & SEMANTIC_OUTPUT ) // V_snprintf( strUsageUsageIndexName, nBufLen, dwUsageIndex != 0 ? "gl_BackColor" : "gl_FrontColor" ); // else V_snprintf( strUsageUsageIndexName, nBufLen, dwUsageIndex != 0 ? "gl_SecondaryColor" : "gl_Color" ); break; case D3DDECLUSAGE_FOG: TranslationError(); break; case D3DDECLUSAGE_DEPTH: TranslationError(); V_snprintf( strUsageUsageIndexName, nBufLen, "_depth" ); // no analog break; case D3DDECLUSAGE_SAMPLE: TranslationError(); V_snprintf( strUsageUsageIndexName, nBufLen, "_sample" ); // no analog break; default: Debugger(); break; } } uint32 D3DToGL::GetRegType( uint32 dwRegToken ) { return ( ( dwRegToken & D3DSP_REGTYPE_MASK2 ) >> D3DSP_REGTYPE_SHIFT2 ) | ( ( dwRegToken & D3DSP_REGTYPE_MASK ) >> D3DSP_REGTYPE_SHIFT ); } void D3DToGL::PrintIndentation( char *pBuf, int nBufLen ) { for( int i=0; i 5 && V_strcmp( &pRegister[nLen-5], ".xyzw" ) == 0 ) pRegister[nLen-5] = 0; } // This returns 0 for x, 1 for y, 2 for z, and 3 for w. int GetSwizzleComponentVectorIndex( char chMask ) { if ( chMask == 'x' ) return 0; else if ( chMask == 'y' ) return 1; else if ( chMask == 'z' ) return 2; else if ( chMask == 'w' ) return 3; Error( "GetSwizzleComponentVectorIndex( '%c' ) - invalid parameter.\n", chMask ); return 0; } // GLSL needs the # of src masks to match the dest write mask. // // So this: // r0.xy = r1 + r2; // becomes: // r0.xy = r1.xy + r2.xy; // // // Also, and this is the trickier one: GLSL reads the source registers from their first component on // whereas D3D reads them as referenced in the dest register mask! // // So this code in D3D: // r0.yz = c0.x + c1.wxyz // Really means: // r0.y = c0.x + c1.x // r0.z = c0.x + c1.y // So we translate it to this in GLSL: // r0.yz = c0.xx + c1.wx // r0.yz = c0.xx + c1.xy // CUtlString D3DToGL::FixGLSLSwizzle( const char *pDestRegisterName, const char *pSrcRegisterName ) { bool bAbsWrapper = false; // Parameter wrapped in an abs() bool bAbsNegative = false; // -abs() char szSrcRegister[128]; V_strncpy( szSrcRegister, pSrcRegisterName, sizeof(szSrcRegister) ); // Check for abs() or -abs() wrapper and strip it off during the fixup if ( !V_strncmp( pSrcRegisterName, "abs(", 4 ) || !V_strncmp( pSrcRegisterName, "-abs(", 5 ) ) { bAbsWrapper = true; bAbsNegative = pSrcRegisterName[0] == '-'; const char *pOpenParen = strchr( pSrcRegisterName, '(' ); // FIRST opening paren const char *pClosingParen = strrchr( pSrcRegisterName, ')' ); // LAST closing paren Assert ( pOpenParen && pClosingParen ); // If we start with abs( and don't get both parens, something is very wrong // Copy out just the register name with no abs() int nRegNameLength = pClosingParen - pOpenParen - 1; V_strncpy( szSrcRegister, pOpenParen+1, nRegNameLength + 1 ); // Kind of a weird function...copy more than you need and slam the last char to NULL-terminate } int nSwizzlesInDest = GetNumSwizzleComponents( pDestRegisterName ); if ( nSwizzlesInDest == 0 ) nSwizzlesInDest = 4; char szFixedSrcRegister[128]; GetParamNameWithoutSwizzle( szSrcRegister, szFixedSrcRegister, sizeof( szFixedSrcRegister ) ); V_strncat( szFixedSrcRegister, ".", sizeof( szFixedSrcRegister ) ); for ( int i=0; i < nSwizzlesInDest; i++ ) { char chDestWriteMask = GetSwizzleComponent( pDestRegisterName, i ); int nVectorIndex = GetSwizzleComponentVectorIndex( chDestWriteMask ); char ch[2]; ch[0] = GetSwizzleComponent( szSrcRegister, nVectorIndex ); ch[1] = 0; V_strncat( szFixedSrcRegister, ch, sizeof( szFixedSrcRegister ) ); } SimplifyFourParamRegister( szFixedSrcRegister ); if ( bAbsWrapper ) { char szTempSrcRegister[128]; V_strncpy( szTempSrcRegister, szFixedSrcRegister, sizeof(szTempSrcRegister) ); V_snprintf( szFixedSrcRegister, sizeof( szFixedSrcRegister ), "%sabs(%s)", bAbsNegative ? "-" : "", szTempSrcRegister ) ; } return szFixedSrcRegister; } // Weird encoding...bits are split apart in the dwToken inline uint32 GetRegTypeFromToken( uint32 dwToken ) { return ( ( dwToken & D3DSP_REGTYPE_MASK2 ) >> D3DSP_REGTYPE_SHIFT2 ) | ( ( dwToken & D3DSP_REGTYPE_MASK ) >> D3DSP_REGTYPE_SHIFT ); } void D3DToGL::FlagIndirectRegister( uint32 dwToken, int *pARLDestReg ) { if ( !pARLDestReg ) return; 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::PrintParameterToString ( uint32 dwToken, uint32 dwSourceOrDest, char *pRegisterName, int nBufLen, bool bForceScalarSource, int *pARLDestReg ) { char buff[32]; bool bAllowWriteMask = true; bool bAllowSwizzle = true; uint32 dwRegNum = dwToken & D3DSP_REGNUM_MASK; uint32 dwRegType, dwSwizzle; uint32 dwSrcModifier = D3DSPSM_NONE; // Clear string to zero length pRegisterName[ 0 ] = 0; dwRegType = GetRegTypeFromToken( dwToken ); // If this is a dest register if ( dwSourceOrDest == DST_REGISTER ) { // Instruction modifiers if ( dwToken & D3DSPDM_PARTIALPRECISION ) { // strcat_s( pRegisterName, nBufLen, "_pp" ); } if ( dwToken & D3DSPDM_MSAMPCENTROID) { // strcat_s( pRegisterName, nBufLen, "_centroid" ); } } // 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 TranslationError(); strcat_s( pRegisterName, nBufLen, "-" ); break; case D3DSPSM_COMP: // complement TranslationError(); strcat_s( pRegisterName, nBufLen, "1-" ); break; case D3DSPSM_ABS: // abs() strcat_s( pRegisterName, nBufLen, "abs(" ); break; case D3DSPSM_ABSNEG: // -abs() strcat_s( pRegisterName, nBufLen, "-abs(" ); break; case D3DSPSM_NOT: // for predicate register: "!p0" TranslationError(); 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 ) ) { if ( m_dwMajorVersion == 3 ) { V_snprintf( buff, sizeof( buff ), "oTempT%d", dwRegNum ); } else { V_snprintf( buff, sizeof( buff ), dwRegNum == 0 ? "gl_Color" : "gl_SecondaryColor" ); } strcat_s( pRegisterName, nBufLen, buff ); } else { V_snprintf( buff, sizeof( buff ), "v%d", dwRegNum ); strcat_s( pRegisterName, nBufLen, buff ); } break; case D3DSPR_CONST: if ( m_bConstantRegisterDefined[dwRegNum] ) { char szConstantRegName[3]; if ( m_bVertexShader ) { V_snprintf( szConstantRegName, 3, "vd" ); } else { V_snprintf( szConstantRegName, 3, "pd" ); } // Put defined constants into their own namespace "d" V_snprintf( buff, sizeof( buff ), "%s%d", szConstantRegName, dwRegNum ); strcat_s( pRegisterName, nBufLen, buff ); } else if ( dwToken & D3DSHADER_ADDRESSMODE_MASK ) // Indirect addressing (e.g. skinning in a vertex shader) { char szConstantRegName[16]; if ( m_bVertexShader ) { V_snprintf( szConstantRegName, 3, "vc" ); } else // No indirect addressing in PS, this shouldn't happen { TranslationError(); V_snprintf( szConstantRegName, 3, "pc" ); } if ( ( m_bGenerateBoneUniformBuffer ) && ( dwRegNum >= DXABSTRACT_VS_FIRST_BONE_SLOT ) ) { if( dwRegNum < DXABSTRACT_VS_LAST_BONE_SLOT ) { dwRegNum -= DXABSTRACT_VS_FIRST_BONE_SLOT; V_strcpy( szConstantRegName, "vcbones" ); m_nHighestBoneRegister = ( DXABSTRACT_VS_PARAM_SLOTS - 1 ) - DXABSTRACT_VS_FIRST_BONE_SLOT; } else { dwRegNum -= ( DXABSTRACT_VS_LAST_BONE_SLOT + 1 ) - DXABSTRACT_VS_FIRST_BONE_SLOT; m_nHighestRegister = m_bGenerateBoneUniformBuffer ? ( ( DXABSTRACT_VS_PARAM_SLOTS - 1 ) - ( ( DXABSTRACT_VS_LAST_BONE_SLOT + 1 ) - DXABSTRACT_VS_FIRST_BONE_SLOT ) ): ( DXABSTRACT_VS_PARAM_SLOTS - 1 ); } } else { m_nHighestRegister = m_bGenerateBoneUniformBuffer ? ( ( DXABSTRACT_VS_PARAM_SLOTS - 1 ) - ( ( DXABSTRACT_VS_LAST_BONE_SLOT + 1 ) - DXABSTRACT_VS_FIRST_BONE_SLOT ) ): ( DXABSTRACT_VS_PARAM_SLOTS - 1 ); } // Index into single pc/vc[] register array with relative addressing int nDstReg = -1; FlagIndirectRegister( GetNextToken(), &nDstReg ); if ( pARLDestReg ) *pARLDestReg = nDstReg; Assert( nDstReg != ARL_DEST_NONE ); int nSrcSwizzle = 'x'; if ( nDstReg == ARL_DEST_Y ) nSrcSwizzle = 'y'; else if ( nDstReg == ARL_DEST_Z ) nSrcSwizzle = 'z'; else if ( nDstReg == ARL_DEST_W ) nSrcSwizzle = 'w'; V_snprintf( buff, sizeof( buff ), "%s[int(va_r.%c) + %d]", szConstantRegName, nSrcSwizzle, dwRegNum ); strcat_s( pRegisterName, nBufLen, buff ); // Must allow swizzling, otherwise this example doesn't compile right: mad r3.xyz, c27[a0.w].w, r3, r7 //bAllowSwizzle = false; } else // Direct addressing of constant array { char szConstantRegName[16]; V_snprintf( szConstantRegName, 3, m_bVertexShader ? "vc" : "pc" ); if ( ( m_bGenerateBoneUniformBuffer ) && ( dwRegNum >= DXABSTRACT_VS_FIRST_BONE_SLOT ) ) { if( dwRegNum < DXABSTRACT_VS_LAST_BONE_SLOT ) { dwRegNum -= DXABSTRACT_VS_FIRST_BONE_SLOT; V_strcpy( szConstantRegName, "vcbones" ); m_nHighestBoneRegister = MAX( m_nHighestBoneRegister, (int)dwRegNum ); } else { // handles case where constants after the bones are used (c217 onwards), these are to be concatenated with those before the bones (c0-c57) // keep track of regnum for concatenated array dwRegNum -= ( DXABSTRACT_VS_LAST_BONE_SLOT + 1 ) - DXABSTRACT_VS_FIRST_BONE_SLOT; m_nHighestRegister = MAX( m_nHighestRegister, dwRegNum ); } } else { //// NOGO if (dwRegNum != 255) // have seen cases where dwRegNum is 0xFF... need to figure out where those opcodes are coming from { m_nHighestRegister = MAX( m_nHighestRegister, dwRegNum ); } Assert( m_nHighestRegister < DXABSTRACT_VS_PARAM_SLOTS ); } // Index into single pc/vc[] register array with absolute addressing, same for GLSL and ASM V_snprintf( buff, sizeof( buff ), "%s[%d]", szConstantRegName, dwRegNum ); strcat_s( pRegisterName, nBufLen, buff ); } break; case D3DSPR_ADDR: // aliases to D3DSPR_TEXTURE if ( m_bVertexShader ) { Assert( dwRegNum == 0 ); V_snprintf( buff, sizeof( buff ), "va_r" ); } else // D3DSPR_TEXTURE in the pixel shader { // If dest reg, this is an iterator/varying declaration if ( dwSourceOrDest == DST_REGISTER ) { // Is this iterator centroid? if ( m_nCentroidMask & ( 0x00000001 << dwRegNum ) ) { V_snprintf( buff, sizeof( buff ), "centroid varying vec4 oT%d", dwRegNum ); // centroid varying } else { V_snprintf( buff, sizeof( buff ), "varying vec4 oT%d", dwRegNum ); } bAllowWriteMask = false; } else // source register { V_snprintf( buff, sizeof( buff ), "oT%d", dwRegNum ); } } strcat_s( pRegisterName, nBufLen, buff ); break; case D3DSPR_RASTOUT: // vertex shader oPos Assert( m_bVertexShader ); Assert( m_dwMajorVersion == 2 ); switch( dwRegNum ) { case D3DSRO_POSITION: strcat_s( pRegisterName, nBufLen, "vTempPos" ); // In GLSL, this ends up in gl_Position later on m_bDeclareVSOPos = true; break; case D3DSRO_FOG: strcat_s( pRegisterName, nBufLen, "gl_FogFragCoord" ); m_bDeclareVSOFog = true; break; default: printf( "\nD3DSPR_RASTOUT: dwRegNum is %08x and token is %08x", dwRegNum, dwToken ); TranslationError(); break; } break; case D3DSPR_ATTROUT: Assert( m_bVertexShader ); Assert( m_dwMajorVersion == 2 ); if ( dwRegNum == 0 ) { V_snprintf( buff, sizeof( buff ), "gl_FrontColor" ); } else if ( dwRegNum == 1 ) { V_snprintf( buff, sizeof( buff ), "gl_FrontSecondaryColor" ); } else { Error( "Invalid D3DSPR_ATTROUT index" ); } strcat_s( pRegisterName, nBufLen, buff ); break; case D3DSPR_TEXCRDOUT: // aliases to D3DSPR_OUTPUT if ( m_bVertexShader ) { if ( m_nVSPositionOutput == (int32) dwRegNum ) { V_snprintf( buff, sizeof( buff ), "vTempPos" ); // This output varying is the position } else if ( m_dwMajorVersion == 3 ) { V_snprintf( buff, sizeof( buff ), "oTempT%d", dwRegNum ); } else { 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: V_snprintf( buff, sizeof( buff ), "i%d", dwRegNum ); // Loops use these strcat_s( pRegisterName, nBufLen, buff ); m_dwConstIntUsageMask |= 0x00000001 << dwRegNum; // Keep track of the use of this integer constant break; case D3DSPR_COLOROUT: V_snprintf( buff, sizeof( buff ), "gl_FragData[%d]", dwRegNum ); strcat_s( pRegisterName, nBufLen, buff ); m_bOutputColorRegister[dwRegNum] = true; break; case D3DSPR_DEPTHOUT: V_snprintf( buff, sizeof( buff ), "gl_FragDepth" ); strcat_s( pRegisterName, nBufLen, buff ); m_bOutputDepthRegister = true; break; case D3DSPR_SAMPLER: V_snprintf( buff, sizeof( buff ), "sampler%d", dwRegNum ); strcat_s( pRegisterName, nBufLen, buff ); break; case D3DSPR_CONST2: TranslationError(); V_snprintf( buff, sizeof( buff ), "c%d", dwRegNum+2048); strcat_s( pRegisterName, nBufLen, buff ); break; case D3DSPR_CONST3: TranslationError(); V_snprintf( buff, sizeof( buff ), "c%d", dwRegNum+4096); strcat_s( pRegisterName, nBufLen, buff ); break; case D3DSPR_CONST4: TranslationError(); V_snprintf( buff, sizeof( buff ), "c%d", dwRegNum+6144); strcat_s( pRegisterName, nBufLen, buff ); break; case D3DSPR_CONSTBOOL: V_snprintf( buff, sizeof( buff ), m_bVertexShader ? "b%d" : "fb%d", dwRegNum ); strcat_s( pRegisterName, nBufLen, buff ); m_dwConstBoolUsageMask |= 0x00000001 << dwRegNum; // Keep track of the use of this bool constant break; case D3DSPR_LOOP: TranslationError(); V_snprintf( buff, sizeof( buff ), "aL%d", dwRegNum ); strcat_s( pRegisterName, nBufLen, buff ); break; case D3DSPR_TEMPFLOAT16: TranslationError(); V_snprintf( buff, sizeof( buff ), "temp_float16_xxx%d", dwRegNum ); strcat_s( pRegisterName, nBufLen, buff ); break; case D3DSPR_MISCTYPE: Assert( dwRegNum == 0 ); // So far, we know that MISC[0] is gl_FragCoord (aka vPos in DX ASM parlance), but we don't know about any other MISC registers V_snprintf( buff, sizeof( buff ), "gl_FragCoord" ); strcat_s( pRegisterName, nBufLen, buff ); break; case D3DSPR_LABEL: TranslationError(); V_snprintf( buff, sizeof( buff ), "label%d", dwRegNum ); strcat_s( pRegisterName, nBufLen, buff ); break; case D3DSPR_PREDICATE: TranslationError(); 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 int nMasksWritten = 0; if ( dwToken & D3DSP_WRITEMASK_0 ) { strcat_s( pRegisterName, nBufLen, "x" ); ++nMasksWritten; } if ( dwToken & D3DSP_WRITEMASK_1 ) { strcat_s( pRegisterName, nBufLen, "y" ); ++nMasksWritten; } if ( dwToken & D3DSP_WRITEMASK_2 ) { strcat_s( pRegisterName, nBufLen, "z" ); ++nMasksWritten; } if ( dwToken & D3DSP_WRITEMASK_3 ) { strcat_s( pRegisterName, nBufLen, "w" ); ++nMasksWritten; } } } else // must be a source register { if ( bAllowSwizzle ) // relative addressing hard-codes the swizzle on a0.x { 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 ( !bForceScalarSource ) { // 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; } } } // end !bForceScalarSource } else // dwSwizzle == D3DVS_NOSWIZZLE { // If this is a MOVA / ARL, GL on the Mac requires us to tack the .x onto the source register if ( bForceScalarSource ) { strcat_s( pRegisterName, nBufLen, ".x" ); } } } // bAllowSwizzle // 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 TranslationError(); strcat_s( pRegisterName, nBufLen, "_bx2" ); break; case D3DSPSM_SIGN: // sign case D3DSPSM_SIGNNEG: // sign and negate TranslationError(); strcat_s( pRegisterName, nBufLen, "_sgn" ); break; case D3DSPSM_X2: // *2 case D3DSPSM_X2NEG: // *2 and negate TranslationError(); strcat_s( pRegisterName, nBufLen, "_x2" ); break; case D3DSPSM_ABS: // abs() case D3DSPSM_ABSNEG: // -abs() strcat_s( pRegisterName, nBufLen, ")" ); break; case D3DSPSM_DZ: // divide through by z component TranslationError(); strcat_s( pRegisterName, nBufLen, "_dz" ); break; case D3DSPSM_DW: // divide through by w component TranslationError(); strcat_s( pRegisterName, nBufLen, "_dw" ); break; } } // end postfix modifiers (really only ps.1.x) } } void D3DToGL::RecordInputAndOutputPositions() { // Remember where we are in the token stream. m_pRecordedInputTokenStart = m_pdwNextToken; // Remember where our outputs are. m_nRecordedParamCodeStrlen = V_strlen( (char*)m_pBufParamCode->Base() ); m_nRecordedALUCodeStrlen = V_strlen( (char*)m_pBufALUCode->Base() ); m_nRecordedAttribCodeStrlen = V_strlen( (char*)m_pBufAttribCode->Base() ); } void D3DToGL::AddTokenHexCodeToBuffer( char *pBuffer, int nSize, int nLastStrlen ) { int nCurStrlen = V_strlen( pBuffer ); if ( nCurStrlen == nLastStrlen ) return; // Build a string with all the hex codes of the tokens since last time. char szHex[512]; szHex[0] = '\n'; V_snprintf( &szHex[1], sizeof( szHex )-1, HEXCODE_HEADER ); int nTokens = MIN( 10, m_pdwNextToken - m_pRecordedInputTokenStart ); for ( int i=0; i < nTokens; i++ ) { char szTemp[32]; V_snprintf( szTemp, sizeof( szTemp ), "0x%x ", m_pRecordedInputTokenStart[i] ); V_strncat( szHex, szTemp, sizeof( szHex ) ); } V_strncat( szHex, "\n", sizeof( szHex ) ); // Insert the hex codes into the string. int nBytesToInsert = V_strlen( szHex ); if ( nCurStrlen + nBytesToInsert + 1 >= nSize ) Error( "Buffer overflow writing token hex codes" ); if ( m_bPutHexCodesAfterLines ) { // Put it at the end of the last line. if ( pBuffer[nCurStrlen-1] == '\n' ) pBuffer[nCurStrlen-1] = 0; V_strncat( pBuffer, &szHex[1], nSize ); } else { memmove( pBuffer + nLastStrlen + nBytesToInsert, pBuffer + nLastStrlen, nCurStrlen - nLastStrlen + 1 ); memcpy( pBuffer + nLastStrlen, szHex, nBytesToInsert ); } } void D3DToGL::AddTokenHexCode() { if ( m_pdwNextToken > m_pRecordedInputTokenStart ) { AddTokenHexCodeToBuffer( (char*)m_pBufParamCode->Base(), m_pBufParamCode->Size(), m_nRecordedParamCodeStrlen ); AddTokenHexCodeToBuffer( (char*)m_pBufALUCode->Base(), m_pBufALUCode->Size(), m_nRecordedALUCodeStrlen ); AddTokenHexCodeToBuffer( (char*)m_pBufAttribCode->Base(), m_pBufAttribCode->Size(), m_nRecordedAttribCodeStrlen ); } } uint32 D3DToGL::MaintainAttributeMap( uint32 dwToken, uint32 dwRegToken ) { // Check that this reg index has not been used before - if it has, let Houston know uint dwRegIndex = dwRegToken & D3DSP_REGNUM_MASK; if ( m_dwAttribMap[ dwRegIndex ] == 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[ dwRegIndex ] = ( usage << 4 ) | usageindex; // avoid writing 0xBB since runtime code uses that for an 'unused' marker if ( m_dwAttribMap[ dwRegIndex ] == 0xBB ) { Debugger(); } } else { //not OK Debugger(); } return dwRegIndex; } void D3DToGL::Handle_DCL() { uint32 dwToken = GetNextToken(); // What kind of dcl is this... uint32 dwRegToken = GetNextToken(); // Look ahead to register token uint32 dwUsage = ( dwToken & D3DSP_DCL_USAGE_MASK ); uint32 dwUsageIndex = ( dwToken & D3DSP_DCL_USAGEINDEX_MASK ) >> D3DSP_DCL_USAGEINDEX_SHIFT; uint32 dwRegNum = dwRegToken & D3DSP_REGNUM_MASK; uint32 nRegType = GetRegTypeFromToken( dwRegToken ); if ( m_bVertexShader ) { // If this is an output, remember the index (what the ASM code calls o0, o1, o2..) and the semantic. // When GetParameterString( DST_REGISTER ) hits this one, we'll return "oN". // At the end of the main() function, we'll insert a bunch of statements like "gl_Color = o2" based on what we remembered here. if ( ( m_dwMajorVersion >= 3 ) && ( nRegType == D3DSPR_OUTPUT ) ) { // uint32 dwRegComponents = ( dwRegToken & D3DSP_WRITEMASK_ALL ) >> 16; // Components used by the output register (1 means float, 3 means vec2, 7 means vec3, f means vec4) if ( dwRegNum >= MAX_DECLARED_OUTPUTS ) Error( "Output register number (%d) too high (only %d supported).", dwRegNum, MAX_DECLARED_OUTPUTS ); if ( m_DeclaredOutputs[dwRegNum] != UNDECLARED_OUTPUT ) Error( "Output dcl_ hit for register #%d more than once!", dwRegNum ); Assert( dwToken != UNDECLARED_OUTPUT ); m_DeclaredOutputs[dwRegNum] = dwToken; //uint32 dwUsage = ( dwToken & D3DSP_DCL_USAGE_MASK ); //uint32 dwUsageIndex = ( dwToken & D3DSP_DCL_USAGEINDEX_MASK ) >> D3DSP_DCL_USAGEINDEX_SHIFT; // Flag which o# output register maps to gl_Position if ( dwUsage == D3DDECLUSAGE_POSITION ) { m_nVSPositionOutput = dwUsageIndex; m_bDeclareVSOPos = true; } if ( m_bAddHexCodeComments ) { CUtlString sParam2 = GetUsageAndIndexString( dwToken, SEMANTIC_OUTPUT ); PrintToBuf( *m_pBufHeaderCode, "// [GL remembering that oT%d maps to %s]\n", dwRegNum, sParam2.String() ); } } else if ( GetRegType( dwRegToken ) == D3DSPR_SAMPLER ) { // We can support vertex texturing if necessary, but I can't find a use case in any branch. (HW morphing in L4D2 isn't enabled, and the comments indicate that r_hwmorph isn't compatible with mat_queue_mode anyway, and CS:GO/DoTA don't use vertex shader texturing.) TranslationError(); int nRegNum = dwRegToken & D3DSP_REGNUM_MASK; switch ( TextureType( dwToken ) ) { default: case D3DSTT_UNKNOWN: case D3DSTT_2D: m_dwSamplerTypes[nRegNum] = SAMPLER_TYPE_2D; break; case D3DSTT_CUBE: m_dwSamplerTypes[nRegNum] = SAMPLER_TYPE_CUBE; break; case D3DSTT_VOLUME: m_dwSamplerTypes[nRegNum] = SAMPLER_TYPE_3D; break; } // Track sampler declarations m_dwSamplerUsageMask |= 1 << nRegNum; } else { Assert( GetRegType( dwRegToken ) == D3DSPR_INPUT); CUtlString sParam1 = GetParameterString( dwRegToken, DST_REGISTER, false, NULL ); CUtlString sParam2 = GetUsageAndIndexString( dwToken, SEMANTIC_INPUT ); sParam2 = FixGLSLSwizzle( sParam1, sParam2 ); PrintToBuf( *m_pBufHeaderCode, "attribute vec4 %s; // ", sParam1.String() ); MaintainAttributeMap( dwToken, dwRegToken ); char temp[128]; // regnum goes straight into the vertex.attrib[n] index sprintf( temp, "%08x %08x\n", dwToken, dwRegToken ); StrcatToHeaderCode( temp ); } } else // Pixel shader { // If the register is a sampler, the dcl has a dimension decorator that we have to save for subsequent TEX instructions uint32 nRegType = GetRegType( dwRegToken ); if ( nRegType == D3DSPR_SAMPLER ) { int nRegNum = dwRegToken & D3DSP_REGNUM_MASK; switch ( TextureType( dwToken ) ) { default: case D3DSTT_UNKNOWN: case D3DSTT_2D: m_dwSamplerTypes[nRegNum] = SAMPLER_TYPE_2D; break; case D3DSTT_CUBE: m_dwSamplerTypes[nRegNum] = SAMPLER_TYPE_CUBE; break; case D3DSTT_VOLUME: m_dwSamplerTypes[nRegNum] = SAMPLER_TYPE_3D; break; } // Track sampler declarations m_dwSamplerUsageMask |= 1 << nRegNum; } else // Not a sampler, we're going to generate varying declaration code { // In pixel shaders we only declare texture coordinate varyings since they may be using centroid if ( ( m_dwMajorVersion == 3 ) && ( nRegType == D3DSPR_INPUT ) ) { Assert( m_DeclaredInputs[dwRegNum] == UNDECLARED_INPUT ); m_DeclaredInputs[dwRegNum] = dwToken; if ( ( dwUsage != D3DDECLUSAGE_COLOR ) && ( dwUsage != D3DDECLUSAGE_TEXCOORD ) ) { TranslationError(); // Not supported yet, but can be if we need it. } if ( dwUsage == D3DDECLUSAGE_TEXCOORD ) { char buf[256]; if ( m_nCentroidMask & ( 0x00000001 << dwUsageIndex ) ) { V_snprintf( buf, sizeof( buf ), "centroid varying vec4 oT%d;\n", dwUsageIndex ); // centroid varying } else { V_snprintf( buf, sizeof( buf ), "varying vec4 oT%d;\n", dwUsageIndex ); } StrcatToHeaderCode( buf ); } } else if ( nRegType == D3DSPR_TEXTURE ) { char buff[256]; PrintParameterToString( dwRegToken, DST_REGISTER, buff, sizeof( buff ), false, NULL ); PrintToBuf( *m_pBufHeaderCode, "%s;\n",buff ); } else { // No need to declare anything (probably D3DSPR_MISCTYPE either VPOS or VFACE) } } } } static bool IsFloatNaN( float f ) { const uint nBits = *reinterpret_cast(&f); const uint nExponent = ( nBits >> 23 ) & 0xFF; return ( nExponent == 255 ); } static inline bool EqualTol( double a, double b, double t ) { return fabs( a - b ) <= ( ( MAX( fabs( a ), fabs( b ) ) + 1.0 ) * t ); } // Originally written by Bruce Dawson, see: // See http://randomascii.wordpress.com/2012/03/08/float-precisionfrom-zero-to-100-digits-2/ // This class represents a very limited high-precision number with 'count' 32-bit // unsigned elements. template struct HighPrec { typedef unsigned T; typedef unsigned long long Product_t; static const int kWordShift = 32; HighPrec() { memset(m_data, 0, sizeof(m_data)); m_nLowestNonZeroIndex = ARRAYSIZE(m_data); } // Insert the bits from value into m_data, shifted in from the bottom (least // significant end) by the specified number of bits. A shift of zero or less // means that none of the bits will be shifted in. A shift of one means that // the high bit of value will be in the bottom of the last element of m_data - // the least significant bit. A shift of kWordShift means that value will be // in the least significant element of m_data, and so on. void InsertLowBits(T value, int shiftAmount) { if (shiftAmount <= 0) return; int subShift = shiftAmount & (kWordShift - 1); int bigShift = shiftAmount / kWordShift; Product_t result = (Product_t)value << subShift; T resultLow = (T)result; T resultHigh = result >> kWordShift; // Use an unsigned type so that negative numbers will become large, // which makes the range checking below simpler. unsigned highIndex = ARRAYSIZE(m_data) - 1 - bigShift; // Write the results to the data array. If the index is too large // then that means that the data was shifted off the edge. if ( (highIndex < ARRAYSIZE(m_data)) && ( resultHigh ) ) { m_data[highIndex] |= resultHigh; m_nLowestNonZeroIndex = MIN( m_nLowestNonZeroIndex, highIndex ); } if ( ( highIndex + 1 < ARRAYSIZE(m_data)) && ( resultLow ) ) { m_data[highIndex + 1] |= resultLow; m_nLowestNonZeroIndex = MIN( m_nLowestNonZeroIndex, highIndex + 1 ); } } // Insert the bits from value into m_data, shifted in from the top (most // significant end) by the specified number of bits. A shift of zero or less // means that none of the bits will be shifted in. A shift of one means that // the low bit of value will be in the top of the first element of m_data - // the most significant bit. A shift of kWordShift means that value will be // in the most significant element of m_data, and so on. void InsertTopBits(T value, int shiftAmount) { InsertLowBits(value, (ARRAYSIZE(m_data) + 1) * kWordShift - shiftAmount); } // Return true if all elements of m_data are zero. bool IsZero() const { bool bIsZero = ( m_nLowestNonZeroIndex == ARRAYSIZE(m_data) ); #ifdef DEBUG for (int i = 0; i < ARRAYSIZE(m_data); ++i) { if (m_data[i]) { Assert( !bIsZero ); return false; } } Assert( bIsZero ); #endif return bIsZero; } // Divide by div and return the remainder, from 0 to div-1. // Standard long-division algorithm. T DivReturnRemainder(T divisor) { T remainder = 0; #ifdef DEBUG for (uint j = 0; j < m_nLowestNonZeroIndex; ++j) { Assert( m_data[j] == 0 ); } #endif int nNewLowestNonZeroIndex = ARRAYSIZE(m_data); for (int i = m_nLowestNonZeroIndex; i < ARRAYSIZE(m_data); ++i) { Product_t dividend = ((Product_t)remainder << kWordShift) + m_data[i]; Product_t result = dividend / divisor; remainder = T(dividend % divisor); m_data[i] = T(result); if ( ( result ) && ( nNewLowestNonZeroIndex == ARRAYSIZE(m_data) ) ) nNewLowestNonZeroIndex = i; } m_nLowestNonZeroIndex = nNewLowestNonZeroIndex; return remainder; } // The individual 'digits' (32-bit unsigned integers actually) that // make up the number. The most-significant digit is in m_data[0]. T m_data[count]; uint m_nLowestNonZeroIndex; }; union Double_t { Double_t(double num = 0.0f) : f(num) {} // Portable extraction of components. bool Negative() const { return (i >> 63) != 0; } int64_t RawMantissa() const { return i & ((1LL << 52) - 1); } int64_t RawExponent() const { return (i >> 52) & 0x7FF; } int64_t i; double f; }; static uint PrintDoubleInt( char *pBuf, uint nBufSize, double f, uint nMinChars ) { static const char *pDigits = "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899"; Assert( !nMinChars || ( ( nMinChars % 6 ) == 0 ) ); char *pLastChar = pBuf + nBufSize - 1; char *pDst = pLastChar; *pDst-- = '\0'; // Put the double in our magic union so we can grab the components. union Double_t num(f); // Get the character that represents the sign. // Check for NaNs or infinity. if (num.RawExponent() == 2047) { TranslationError(); } // Adjust for the exponent bias. int exponentValue = int(num.RawExponent() - 1023); // Add the implied one to the mantissa. uint64_t mantissaValue = (1ll << 52) + num.RawMantissa(); // Special-case for denormals - no special exponent value and // no implied one. if (num.RawExponent() == 0) { exponentValue = -1022; mantissaValue = num.RawMantissa(); } uint32_t mantissaHigh = mantissaValue >> 32; uint32_t mantissaLow = mantissaValue & 0xFFFFFFFF; // The first bit of the mantissa has an implied value of one and this can // be shifted 1023 positions to the left, so that's 1024 bits to the left // of the binary point, or 32 32-bit words for the integer part. HighPrec<32> intPart; // When our exponentValue is zero (a number in the 1.0 to 2.0 range) // we have a 53-bit mantissa and the implied value of the highest bit // is 1. We need to shift 12 bits in from the bottom to get that 53rd bit // into the ones spot in the integral portion. // To complicate it a bit more we have to insert the mantissa as two parts. intPart.InsertLowBits(mantissaHigh, 12 + exponentValue); intPart.InsertLowBits(mantissaLow, 12 + exponentValue - 32); bool bAnyDigitsLeft; do { uint remainder = intPart.DivReturnRemainder( 1000000 ); // 10^6 uint origRemainer = remainder; (void)origRemainer; bAnyDigitsLeft = !intPart.IsZero(); if ( bAnyDigitsLeft ) { uint n = remainder % 100U; remainder /= 100U; *reinterpret_cast(pDst - 1) = reinterpret_cast(pDigits)[n]; n = remainder % 100U; remainder /= 100U; *reinterpret_cast(pDst - 1 - 2) = reinterpret_cast(pDigits)[n]; Assert( remainder < 100U ); *reinterpret_cast(pDst - 1 - 4) = reinterpret_cast(pDigits)[remainder]; pDst -= 6; } else { uint n = remainder % 100U; remainder /= 100U; *reinterpret_cast(pDst - 1) = reinterpret_cast(pDigits)[n]; --pDst; if ( ( n >= 10 ) || ( remainder ) ) --pDst; if ( remainder ) { n = remainder % 100U; remainder /= 100U; *reinterpret_cast(pDst - 1) = reinterpret_cast(pDigits)[n]; --pDst; if ( ( n >= 10 ) || ( remainder ) ) --pDst; if ( remainder ) { Assert( remainder < 100U ); *reinterpret_cast(pDst - 1) = reinterpret_cast(pDigits)[remainder]; --pDst; if ( remainder >= 10 ) --pDst; } } } } while ( bAnyDigitsLeft ); uint l = pLastChar - pDst; while ( ( l - 1 ) < nMinChars ) { *pDst-- = '0'; l++; } Assert( (int)l == ( pLastChar - pDst ) ); Assert( l <= nBufSize ); memmove( pBuf, pDst + 1, l ); return l - 1; } // FloatToString is equivalent to sprintf( "%.12f" ), but doesn't have any dependencies on the current locale setting. // Unfortunately, high accuracy radix conversion is actually pretty tricky to do right. // Most importantly, this function has the same max roundtrip (IEEE->ASCII->IEEE) error as the MS CRT functions and can reliably handle extremely large inputs. static void FloatToString( char *pBuf, uint nBufSize, double fConst ) { char *pEnd = pBuf + nBufSize; char *pDst = pBuf; double flVal = fConst; if ( IsFloatNaN( flVal ) ) { flVal = 0; } if ( flVal < 0.0f ) { *pDst++ = '-'; flVal = -flVal; } double flInt; double flFract = modf( flVal, &flInt ); flFract = floor( flFract * 1000000000000.0 + .5 ); if ( !flInt ) { *pDst++ = '0'; } else { uint l = PrintDoubleInt( pDst, pEnd - pDst, flInt, 0 ); pDst += l; } *pDst++ = '.'; if ( !flFract ) { *pDst++ = '0'; *pDst++ = '\0'; } else { uint l = PrintDoubleInt( pDst, pEnd - pDst, flFract, 12 ); pDst += l; StripExtraTrailingZeros( pBuf ); // Turn 1.00000 into 1.0 } } #if 0 #include "vstdlib/random.h" static void TestFloatConversion() { for ( ; ; ) { double fConst; switch ( rand() % 4 ) { case 0: fConst = RandomFloat( -1e-30, 1e+30 ); break; case 1: fConst = RandomFloat( -1e-10, 1e+10 ); break; case 2: fConst = RandomFloat( -1e-5, 1e+5 ); break; default: fConst = RandomFloat( -1, 1 ); break; } char szTemp[1024]; // FloatToString does not rely on V_snprintf(), so it can't be affected by the current locale setting. FloatToString( szTemp, sizeof( szTemp ), fConst ); static double flMaxErr1; static double flMaxErr2; // Compare FloatToString()'s results vs. V_snprintf()'s, also track maximum error of each. double flCheck = atof( szTemp ); double flErr = fabs( flCheck - fConst ); flMaxErr1 = MAX( flMaxErr1, flErr ); Assert( EqualTol( flCheck, fConst, .000000125 ) ); char szTemp2[256]; V_snprintf( szTemp2, sizeof( szTemp2 ), "%.12f", fConst ); StripExtraTrailingZeros( szTemp2 ); if ( !strchr( szTemp2, '.' ) ) { V_strncat( szTemp2, ".0", sizeof( szTemp2 ) ); } double flCheck2 = atof( szTemp2 ); double flErr2 = fabs( flCheck2 - fConst ); flMaxErr2 = MAX( flMaxErr2, flErr2 ); Assert( EqualTol( flCheck2, fConst, .000000125 ) ); if ( flMaxErr1 > flMaxErr2 ) { GLMDebugPrintf( "!\n" ); } } } #endif void D3DToGL::Handle_DEFIB( uint32 instruction ) { Assert( ( instruction == D3DSIO_DEFI ) || ( instruction == D3DSIO_DEFB ) ); // which register is being defined uint32 dwToken = GetNextToken(); uint32 nRegNum = dwToken & D3DSP_REGNUM_MASK; uint32 regType = GetRegTypeFromToken( dwToken ); if ( regType == D3DSPR_CONSTINT ) { m_dwDefConstIntUsageMask |= ( 1 << nRegNum ); uint x = GetNextToken(); uint y = GetNextToken(); uint z = GetNextToken(); uint w = GetNextToken(); NOTE_UNUSED(y); NOTE_UNUSED(z); NOTE_UNUSED(w); Assert( nRegNum < 32 ); if ( nRegNum < 32 ) { m_dwDefConstIntIterCount[nRegNum] = x; } } else { TranslationError(); } } void D3DToGL::Handle_DEF() { //TestFloatConversion(); // // JasonM TODO: catch D3D's sincos-specific D3DSINCOSCONST1 and D3DSINCOSCONST2 constants and filter them out here // // Which register is being defined uint32 dwToken = GetNextToken(); // Note that this constant was explicitly defined m_bConstantRegisterDefined[dwToken & D3DSP_REGNUM_MASK] = true; CUtlString sParamName = GetParameterString( dwToken, DST_REGISTER, false, NULL ); PrintIndentation( (char*)m_pBufParamCode->Base(), m_pBufParamCode->Size() ); PrintToBuf( *m_pBufParamCode, "vec4 %s = vec4( ", sParamName.String() ); // Run through the 4 floats for ( int i=0; i < 4; i++ ) { float fConst = uint32ToFloat( GetNextToken() ); char szTemp[1024]; FloatToString( szTemp, sizeof( szTemp ), fConst ); #if 0 static double flMaxErr1; static double flMaxErr2; // Compare FloatToString()'s results vs. V_snprintf()'s, also track maximum error of each. double flCheck = atof( szTemp ); double flErr = fabs( flCheck - fConst ); flMaxErr1 = MAX( flMaxErr1, flErr ); Assert( EqualTol( flCheck, fConst, .000000125 ) ); char szTemp2[256]; V_snprintf( szTemp2, sizeof( szTemp2 ), "%.12f", fConst ); StripExtraTrailingZeros( szTemp2 ); if ( !strchr( szTemp2, '.' ) ) { V_strncat( szTemp2, ".0", sizeof( szTemp2 ) ); } double flCheck2 = atof( szTemp2 ); double flErr2 = fabs( flCheck2 - fConst ); flMaxErr2 = MAX( flMaxErr2, flErr2 ); Assert( EqualTol( flCheck2, fConst, .000000125 ) ); if ( flMaxErr1 > flMaxErr2 ) { GLMDebugPrintf( "!\n" ); } #endif PrintToBuf( *m_pBufParamCode, i != 3 ? "%s, " : "%s", szTemp ); // end with comma-space } PrintToBuf( *m_pBufParamCode, " );\n" ); } void D3DToGL::Handle_MAD( uint32 nInstruction ) { uint32 nDestToken = GetNextToken(); CUtlString sParam1 = GetParameterString( nDestToken, DST_REGISTER, false, NULL ); int nARLComp0 = ARL_DEST_NONE; CUtlString sParam2 = GetParameterString( GetNextToken(), SRC_REGISTER, false, &nARLComp0 ); int nARLComp1 = ARL_DEST_NONE; CUtlString sParam3 = GetParameterString( GetNextToken(), SRC_REGISTER, false, &nARLComp1 ); int nARLComp2 = ARL_DEST_NONE; CUtlString sParam4 = GetParameterString( GetNextToken(), SRC_REGISTER, false, &nARLComp2 ); // This optionally inserts a move from our dummy address register to the .x component of the real one InsertMoveFromAddressRegister( m_pBufALUCode, nARLComp0, nARLComp1, nARLComp2 ); sParam2 = FixGLSLSwizzle( sParam1, sParam2 ); sParam3 = FixGLSLSwizzle( sParam1, sParam3 ); sParam4 = FixGLSLSwizzle( sParam1, sParam4 ); PrintToBufWithIndents( *m_pBufALUCode, "%s = %s * %s + %s;\n", sParam1.String(), sParam2.String(), sParam3.String(), sParam4.String() ); // If the _SAT instruction modifier is used, then do a saturate here. if ( nDestToken & D3DSPDM_SATURATE ) { int nComponents = GetNumSwizzleComponents( sParam1.String() ); if ( nComponents == 0 ) nComponents = 4; PrintToBufWithIndents( *m_pBufALUCode, "%s = clamp( %s, %s, %s );\n", sParam1.String(), sParam1.String(), g_szVecZeros[nComponents], g_szVecOnes[nComponents] ); } } void D3DToGL::Handle_DP2ADD() { char pDestReg[64], pSrc0Reg[64], pSrc1Reg[64], pSrc2Reg[64]; uint32 nDestToken = GetNextToken(); PrintParameterToString( nDestToken, DST_REGISTER, pDestReg, sizeof( pDestReg ), false, NULL ); PrintParameterToString( GetNextToken(), SRC_REGISTER, pSrc0Reg, sizeof( pSrc0Reg ), false, NULL ); PrintParameterToString( GetNextToken(), SRC_REGISTER, pSrc1Reg, sizeof( pSrc1Reg ), false, NULL ); PrintParameterToString( GetNextToken(), SRC_REGISTER, pSrc2Reg, sizeof( pSrc2Reg ), false, NULL ); // We should only be assigning to a single component of the dest. Assert( GetNumSwizzleComponents( pDestReg ) == 1 ); Assert( GetNumSwizzleComponents( pSrc2Reg ) == 1 ); // This is a 2D dot product, so we only want two entries from the middle components. CUtlString sArg0 = EnsureNumSwizzleComponents( pSrc0Reg, 2 ); CUtlString sArg1 = EnsureNumSwizzleComponents( pSrc1Reg, 2 ); PrintToBufWithIndents( *m_pBufALUCode, "%s = dot( %s, %s ) + %s;\n", pDestReg, sArg0.String(), sArg1.String(), pSrc2Reg ); // If the _SAT instruction modifier is used, then do a saturate here. if ( nDestToken & D3DSPDM_SATURATE ) { int nComponents = GetNumSwizzleComponents( pDestReg ); if ( nComponents == 0 ) nComponents = 4; PrintToBufWithIndents( *m_pBufALUCode, "%s = clamp( %s, %s, %s );\n", pDestReg, pDestReg, g_szVecZeros[nComponents], g_szVecOnes[nComponents] ); } } void D3DToGL::Handle_SINCOS() { char pDestReg[64], pSrc0Reg[64]; PrintParameterToString( GetNextToken(), DST_REGISTER, pDestReg, sizeof( pDestReg ), false, NULL ); PrintParameterToString( GetNextToken(), SRC_REGISTER, pSrc0Reg, sizeof( pSrc0Reg ), true, NULL ); m_bNeedsSinCosDeclarations = true; CUtlString sDest( pDestReg ); CUtlString sArg0 = EnsureNumSwizzleComponents( pSrc0Reg, 1 );// Ensure input is scalar CUtlString sResult( "vSinCosTmp.xy" ); // Always going to populate this sResult = FixGLSLSwizzle( sDest, sResult ); // Make sure we match the desired output reg PrintToBufWithIndents( *m_pBufALUCode, "vSinCosTmp.z = %s * %s;\n", sArg0.String(), sArg0.String() ); PrintToBufWithIndents( *m_pBufALUCode, "vSinCosTmp.xy = vSinCosTmp.zz * scA.xy + scA.wz;\n" ); PrintToBufWithIndents( *m_pBufALUCode, "vSinCosTmp.xy = vSinCosTmp.xy * vSinCosTmp.zz + scB.xy;\n" ); PrintToBufWithIndents( *m_pBufALUCode, "vSinCosTmp.xy = vSinCosTmp.xy * vSinCosTmp.zz + scB.wz;\n" ); PrintToBufWithIndents( *m_pBufALUCode, "vSinCosTmp.x = vSinCosTmp.x * %s;\n", sArg0.String() ); PrintToBufWithIndents( *m_pBufALUCode, "vSinCosTmp.xy = vSinCosTmp.xy * vSinCosTmp.xx;\n" ); PrintToBufWithIndents( *m_pBufALUCode, "vSinCosTmp.xy = vSinCosTmp.xy + vSinCosTmp.xy;\n" ); PrintToBufWithIndents( *m_pBufALUCode, "vSinCosTmp.x = -vSinCosTmp.x + scB.z;\n" ); PrintToBufWithIndents( *m_pBufALUCode, "%s = %s;\n", sDest.String(), sResult.String() ); if ( m_dwMajorVersion < 3 ) { // Eat two more tokens since D3D defines Taylor series constants that we won't need // Only valid for pixel and vertex shader version earlier than 3_0 // (http://msdn.microsoft.com/en-us/library/windows/hardware/ff569710(v=vs.85).aspx) SkipTokens( 2 ); } } void D3DToGL::Handle_LRP( uint32 nInstruction ) { uint32 nDestToken = GetNextToken(); CUtlString sDest = GetParameterString( nDestToken, DST_REGISTER, false, NULL ); int nARLComp0 = ARL_DEST_NONE; CUtlString sParam0 = GetParameterString( GetNextToken(), SRC_REGISTER, false, &nARLComp0 ); int nARLComp1 = ARL_DEST_NONE; CUtlString sParam1 = GetParameterString( GetNextToken(), SRC_REGISTER, false, &nARLComp1 ); int nARLComp2 = ARL_DEST_NONE; CUtlString sParam2 = GetParameterString( GetNextToken(), SRC_REGISTER, false, &nARLComp2 ); // This optionally inserts a move from our dummy address register to the .x component of the real one InsertMoveFromAddressRegister( m_pBufALUCode, nARLComp0, nARLComp1, nARLComp2 ); sParam0 = FixGLSLSwizzle( sDest, sParam0 ); sParam1 = FixGLSLSwizzle( sDest, sParam1 ); sParam2 = FixGLSLSwizzle( sDest, sParam2 ); // dest = src0 * (src1 - src2) + src2; PrintToBufWithIndents( *m_pBufALUCode, "%s = %s * ( %s - %s ) + %s;\n", sDest.String(), sParam0.String(), sParam1.String(), sParam2.String(), sParam2.String() ); // If the _SAT instruction modifier is used, then do a saturate here. if ( nDestToken & D3DSPDM_SATURATE ) { int nComponents = GetNumSwizzleComponents( sDest.String() ); if ( nComponents == 0 ) nComponents = 4; PrintToBufWithIndents( *m_pBufALUCode, "%s = clamp( %s, %s, %s );\n", sDest.String(), sDest.String(), g_szVecZeros[nComponents], g_szVecOnes[nComponents] ); } } void D3DToGL::Handle_TEX( uint32 dwToken, bool bIsTexLDL ) { char pDestReg[64], pSrc0Reg[64], pSrc1Reg[64]; PrintParameterToString( GetNextToken(), DST_REGISTER, pDestReg, sizeof( pDestReg ), false, NULL ); PrintParameterToString( GetNextToken(), SRC_REGISTER, pSrc0Reg, sizeof( pSrc0Reg ), false, NULL ); DWORD dwSrc1Token = GetNextToken(); PrintParameterToString( dwSrc1Token, SRC_REGISTER, pSrc1Reg, sizeof( pSrc1Reg ), false, NULL ); Assert( (dwSrc1Token & D3DSP_REGNUM_MASK) < ARRAYSIZE( m_dwSamplerTypes ) ); uint32 nSamplerType = m_dwSamplerTypes[dwSrc1Token & D3DSP_REGNUM_MASK]; if ( nSamplerType == SAMPLER_TYPE_2D ) { const bool bIsShadowSampler = ( ( 1 << ( (int) ( dwSrc1Token & D3DSP_REGNUM_MASK ) ) ) & m_nShadowDepthSamplerMask ) != 0; if ( bIsTexLDL ) { CUtlString sCoordVar = EnsureNumSwizzleComponents( pSrc0Reg, bIsShadowSampler ? 3 : 2 ); // Strip out the W component of the pSrc0Reg and pass that as the LOD to texture2DLod. char szLOD[128], szExtra[8]; GetParamNameWithoutSwizzle( pSrc0Reg, szLOD, sizeof( szLOD ) ); V_snprintf( szExtra, sizeof( szExtra ), ".%c", GetSwizzleComponent( pSrc0Reg, 3 ) ); V_strncat( szLOD, szExtra, sizeof( szLOD ) ); PrintToBufWithIndents( *m_pBufALUCode, "%s = %s( %s, %s, %s );\n", pDestReg, bIsShadowSampler ? "shadow2DLod" : "texture2DLod", pSrc1Reg, sCoordVar.String(), szLOD ); } else if ( bIsShadowSampler ) { // .z is meant to contain the object depth, while .xy contains the 2D tex coords CUtlString sCoordVar3D = EnsureNumSwizzleComponents( pSrc0Reg, 3 ); PrintToBufWithIndents( *m_pBufALUCode, "%s = shadow2D( %s, %s );\n", pDestReg, pSrc1Reg, sCoordVar3D.String() ); Assert( m_dwSamplerTypes[dwSrc1Token & D3DSP_REGNUM_MASK] == SAMPLER_TYPE_2D ); } else if( ( OpcodeSpecificData( dwToken ) << D3DSP_OPCODESPECIFICCONTROL_SHIFT ) == D3DSI_TEXLD_PROJECT ) { // This projective case is after the shadow case intentionally, due to the way that "projective" // loads are overloaded in our D3D shaders for shadow lookups. // // We use the vec4 variant of texture2DProj() intentionally here, since it lines up well with Direct3D. CUtlString s4DProjCoords = EnsureNumSwizzleComponents( pSrc0Reg, 4 ); // Ensure vec4 variant PrintToBufWithIndents( *m_pBufALUCode, "%s = texture2DProj( %s, %s );\n", pDestReg, pSrc1Reg, s4DProjCoords.String() ); } else { CUtlString sCoordVar = EnsureNumSwizzleComponents( pSrc0Reg, bIsShadowSampler ? 3 : 2 ); PrintToBufWithIndents( *m_pBufALUCode, "%s = texture2D( %s, %s );\n", pDestReg, pSrc1Reg, sCoordVar.String() ); } } else if ( nSamplerType == SAMPLER_TYPE_3D ) { if ( bIsTexLDL ) { TranslationError(); } CUtlString sCoordVar = EnsureNumSwizzleComponents( pSrc0Reg, 3 ); PrintToBufWithIndents( *m_pBufALUCode, "%s = texture3D( %s, %s );\n", pDestReg, pSrc1Reg, sCoordVar.String() ); } else if ( nSamplerType == SAMPLER_TYPE_CUBE ) { if ( bIsTexLDL ) { TranslationError(); } CUtlString sCoordVar = EnsureNumSwizzleComponents( pSrc0Reg, 3 ); PrintToBufWithIndents( *m_pBufALUCode, "%s = textureCube( %s, %s );\n", pDestReg, pSrc1Reg, sCoordVar.String() ); } else { Error( "TEX instruction: unsupported sampler type used" ); } } void D3DToGL::StrcatToHeaderCode( const char *pBuf ) { strcat_s( (char*)m_pBufHeaderCode->Base(), m_pBufHeaderCode->Size(), pBuf ); } void D3DToGL::StrcatToALUCode( const char *pBuf ) { PrintIndentation( (char*)m_pBufALUCode->Base(), m_pBufALUCode->Size() ); strcat_s( (char*)m_pBufALUCode->Base(), m_pBufALUCode->Size(), pBuf ); } void D3DToGL::StrcatToParamCode( const char *pBuf ) { strcat_s( (char*)m_pBufParamCode->Base(), m_pBufParamCode->Size(), pBuf ); } void D3DToGL::StrcatToAttribCode( const char *pBuf ) { strcat_s( (char*)m_pBufAttribCode->Base(), m_pBufAttribCode->Size(), pBuf ); } void D3DToGL::Handle_TexLDD( uint32 nInstruction ) { TranslationError(); // Not supported yet, but can be if we need it. } void D3DToGL::Handle_TexCoord() { TranslationError(); // If ps_1_4, this is texcrd if ( (m_dwMajorVersion == 1) && (m_dwMinorVersion == 4) && (!m_bVertexShader) ) { StrcatToALUCode( "texcrd" ); } else // else it's texcoord { TranslationError(); StrcatToALUCode( "texcoord" ); } char buff[256]; PrintParameterToString( GetNextToken(), DST_REGISTER, buff, sizeof( buff ), false, NULL ); StrcatToALUCode( buff ); // If ps_1_4, texcrd also has a source parameter if ((m_dwMajorVersion == 1) && (m_dwMinorVersion == 4) && (!m_bVertexShader)) { StrcatToALUCode( ", " ); PrintParameterToString( GetNextToken(), SRC_REGISTER, buff, sizeof( buff ), false, NULL ); StrcatToALUCode( buff ); } StrcatToALUCode( ";\n" ); } void D3DToGL::Handle_BREAKC( uint32 dwToken ) { uint nComparison = ( dwToken & D3DSHADER_COMPARISON_MASK ) >> D3DSHADER_COMPARISON_SHIFT; const char *pComparison = "?"; switch ( nComparison ) { case D3DSPC_GT: pComparison = ">"; break; case D3DSPC_EQ: pComparison = "=="; break; case D3DSPC_GE: pComparison = ">="; break; case D3DSPC_LT: pComparison = "<"; break; case D3DSPC_NE: pComparison = "!="; break; case D3DSPC_LE: pComparison = "<="; break; default: TranslationError(); } char src0[256]; uint32 src0Token = GetNextToken(); PrintParameterToString( src0Token, SRC_REGISTER, src0, sizeof( src0 ), false, NULL ); char src1[256]; uint32 src1Token = GetNextToken(); PrintParameterToString( src1Token, SRC_REGISTER, src1, sizeof( src1 ), false, NULL ); PrintToBufWithIndents( *m_pBufALUCode, "if (%s %s %s) break;\n", src0, pComparison, src1 ); } void D3DToGL::HandleBinaryOp_GLSL( uint32 nInstruction ) { uint32 nDestToken = GetNextToken(); CUtlString sParam1 = GetParameterString( nDestToken, DST_REGISTER, false, NULL ); int nARLComp0 = ARL_DEST_NONE; CUtlString sParam2 = GetParameterString( GetNextToken(), SRC_REGISTER, false, &nARLComp0 ); int nARLComp1 = ARL_DEST_NONE; CUtlString sParam3 = GetParameterString( GetNextToken(), SRC_REGISTER, false, &nARLComp1 ); // This optionally inserts a move from our dummy address register to the .x component of the real one InsertMoveFromAddressRegister( m_pBufALUCode, nARLComp0, nARLComp1 ); // Since DP3 and DP4 have a scalar as the dest and vectors as the src, don't screw with the swizzle specifications. if ( nInstruction == D3DSIO_DP3 ) { sParam2 = EnsureNumSwizzleComponents( sParam2, 3 ); sParam3 = EnsureNumSwizzleComponents( sParam3, 3 ); } else if ( nInstruction == D3DSIO_DP4 ) { sParam2 = EnsureNumSwizzleComponents( sParam2, 4 ); sParam3 = EnsureNumSwizzleComponents( sParam3, 4 ); } else if ( nInstruction == D3DSIO_DST ) { m_bUsesDSTInstruction = true; sParam2 = EnsureNumSwizzleComponents( sParam2, 4 ); sParam3 = EnsureNumSwizzleComponents( sParam3, 4 ); } else { sParam2 = FixGLSLSwizzle( sParam1, sParam2 ); sParam3 = FixGLSLSwizzle( sParam1, sParam3 ); } char buff[256]; if ( nInstruction == D3DSIO_ADD || nInstruction == D3DSIO_SUB || nInstruction == D3DSIO_MUL ) { // These all look like x = y op z PrintToBufWithIndents( *m_pBufALUCode, "%s = %s %s %s;\n", sParam1.String(), sParam2.String(), GetGLSLOperatorString( nInstruction ), sParam3.String() ); } else { int nDestComponents = GetNumSwizzleComponents( sParam1.String() ); int nSrcComponents = GetNumSwizzleComponents( sParam2.String() ); // All remaining instructions can use GLSL intrinsics like dot() and cross(). bool bDoubleClose = OpenIntrinsic( nInstruction, buff, sizeof( buff ), nDestComponents, nSrcComponents ); if ( ( nSrcComponents == 1 ) && ( nInstruction == D3DSIO_SGE ) ) { PrintToBufWithIndents( *m_pBufALUCode, "%s = %s%s >= %s );\n", sParam1.String(), buff, sParam2.String(), sParam3.String() ); } else if ( ( nSrcComponents == 1 ) && ( nInstruction == D3DSIO_SLT ) ) { PrintToBufWithIndents( *m_pBufALUCode, "%s = %s%s < %s );\n", sParam1.String(), buff, sParam2.String(), sParam3.String() ); } else { PrintToBufWithIndents( *m_pBufALUCode, "%s = %s%s, %s %s;\n", sParam1.String(), buff, sParam2.String(), sParam3.String(), bDoubleClose ? ") )" : ")" ); } } // If the _SAT instruction modifier is used, then do a saturate here. if ( nDestToken & D3DSPDM_SATURATE ) { int nComponents = GetNumSwizzleComponents( sParam1.String() ); if ( nComponents == 0 ) nComponents = 4; PrintToBufWithIndents( *m_pBufALUCode, "%s = clamp( %s, %s, %s );\n", sParam1.String(), sParam1.String(), g_szVecZeros[nComponents], g_szVecOnes[nComponents] ); } } void D3DToGL::HandleBinaryOp_ASM( uint32 nInstruction ) { CUtlString sParam1 = GetParameterString( GetNextToken(), DST_REGISTER, false, NULL ); int nARLComp0 = ARL_DEST_NONE; CUtlString sParam2 = GetParameterString( GetNextToken(), SRC_REGISTER, false, &nARLComp0 ); int nARLComp1 = ARL_DEST_NONE; CUtlString sParam3 = GetParameterString( GetNextToken(), SRC_REGISTER, false, &nARLComp1 ); // This optionally inserts a move from our dummy address register to the .x component of the real one InsertMoveFromAddressRegister( m_pBufALUCode, nARLComp0, nARLComp1 ); char buff[256]; PrintOpcode( nInstruction, buff, sizeof( buff ) ); PrintToBufWithIndents( *m_pBufALUCode, "%s%s, %s, %s;\n", buff, sParam1.String(), sParam2.String(), sParam3.String() ); } void D3DToGL::WriteGLSLCmp( const char *pDestReg, const char *pSrc0Reg, const char *pSrc1Reg, const char *pSrc2Reg ) { int nWriteMaskEntries = GetNumWriteMaskEntries( pDestReg ); for ( int i=0; i < nWriteMaskEntries; i++ ) { char params[4][256]; WriteParamWithSingleMaskEntry( pDestReg, i, params[0], sizeof( params[0] ) ); WriteParamWithSingleMaskEntry( pSrc0Reg, i, params[1], sizeof( params[1] ) ); WriteParamWithSingleMaskEntry( pSrc1Reg, i, params[2], sizeof( params[2] ) ); WriteParamWithSingleMaskEntry( pSrc2Reg, i, params[3], sizeof( params[3] ) ); PrintToBufWithIndents( *m_pBufALUCode, "%s = ( %s >= 0.0 ) ? %s : %s;\n", params[0], params[1], params[2], params[3] ); } } void D3DToGL::Handle_CMP() { // 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! !#$&*!%#$& char pDestReg[64], pSrc0Reg[64], pSrc1Reg[64], pSrc2Reg[64]; uint32 nDestToken = GetNextToken(); PrintParameterToString( nDestToken, DST_REGISTER, pDestReg, sizeof( pDestReg ), false, NULL ); PrintParameterToString( GetNextToken(), SRC_REGISTER, pSrc0Reg, sizeof( pSrc0Reg ), false, NULL ); PrintParameterToString( GetNextToken(), SRC_REGISTER, pSrc1Reg, sizeof( pSrc1Reg ), false, NULL ); PrintParameterToString( GetNextToken(), SRC_REGISTER, pSrc2Reg, sizeof( pSrc2Reg ), false, NULL ); // These are a tricky case.. we have to expand it out into multiple statements. char szDestBase[256]; GetParamNameWithoutSwizzle( pDestReg, szDestBase, sizeof( szDestBase ) ); V_strncpy( pSrc0Reg, FixGLSLSwizzle( pDestReg, pSrc0Reg ), sizeof( pSrc0Reg ) ); V_strncpy( pSrc1Reg, FixGLSLSwizzle( pDestReg, pSrc1Reg ), sizeof( pSrc1Reg ) ); V_strncpy( pSrc2Reg, FixGLSLSwizzle( pDestReg, pSrc2Reg ), sizeof( pSrc2Reg ) ); // This isn't reliable! //if ( DoParamNamesMatch( pDestReg, pSrc0Reg ) && GetNumSwizzleComponents( pDestReg ) > 1 ) if ( 1 ) { // So the dest register is the same as the comparand. We're in danger of screwing up our results. // // For example, this code: // CMP r0.xy, r0.xx, r1, r2 // would generate this: // r0.x = (r0.x >= 0) ? r1.x : r2.x; // r0.y = (r0.x >= 0) ? r1.x : r2.x; // // But the first lines changes r0.x and thus screws the atomicity of the CMP instruction for the second line. // So we assign r0 to a temporary first and then write to the temporary. PrintToBufWithIndents( *m_pBufALUCode, "%s = %s;\n", g_pAtomicTempVarName, szDestBase ); char szTempVar[256]; ReplaceParamName( pDestReg, g_pAtomicTempVarName, szTempVar, sizeof( szTempVar ) ); WriteGLSLCmp( szTempVar, pSrc0Reg, pSrc1Reg, pSrc2Reg ); PrintToBufWithIndents( *m_pBufALUCode, "%s = %s;\n", szDestBase, g_pAtomicTempVarName ); m_bUsedAtomicTempVar = true; } else { // Just write out the simple expanded version of the CMP. No need to use atomic_temp_var. WriteGLSLCmp( pDestReg, pSrc0Reg, pSrc1Reg, pSrc2Reg ); } // If the _SAT instruction modifier is used, then do a saturate here. if ( nDestToken & D3DSPDM_SATURATE ) { int nComponents = GetNumSwizzleComponents( pDestReg ); if ( nComponents == 0 ) nComponents = 4; PrintToBufWithIndents( *m_pBufALUCode, "%s = clamp( %s, %s, %s );\n", pDestReg, pDestReg, g_szVecZeros[nComponents], g_szVecOnes[nComponents] ); } } void D3DToGL::Handle_NRM() { char pDestReg[64]; char pSrc0Reg[64]; PrintParameterToString( GetNextToken(), DST_REGISTER, pDestReg, sizeof( pDestReg ), false, NULL ); int nARLSrcComp = ARL_DEST_NONE; PrintParameterToString( GetNextToken(), SRC_REGISTER, pSrc0Reg, sizeof( pSrc0Reg ), false, &nARLSrcComp ); if ( nARLSrcComp != -1 ) { InsertMoveFromAddressRegister( m_pBufALUCode, nARLSrcComp, -1, -1 ); } CUtlString sSrc = EnsureNumSwizzleComponents( pSrc0Reg, 3 ); PrintToBufWithIndents( *m_pBufALUCode, "%s = normalize( %s );\n", pDestReg, sSrc.String() ); } void D3DToGL::Handle_UnaryOp( uint32 nInstruction ) { uint32 nDestToken = GetNextToken(); CUtlString sParam1 = GetParameterString( nDestToken, DST_REGISTER, false, NULL ); CUtlString sParam2 = GetParameterString( GetNextToken(), SRC_REGISTER, false, NULL ); sParam2 = FixGLSLSwizzle( sParam1, sParam2 ); if ( nInstruction == D3DSIO_MOV ) { PrintToBufWithIndents( *m_pBufALUCode, "%s = %s;\n", sParam1.String(), sParam2.String() ); } else if ( nInstruction == D3DSIO_RSQ ) { PrintToBufWithIndents( *m_pBufALUCode, "%s = inversesqrt( %s );\n", sParam1.String(), sParam2.String() ); } else if ( nInstruction == D3DSIO_RCP ) { PrintToBufWithIndents( *m_pBufALUCode, "%s = 1.0 / %s;\n", sParam1.String(), sParam2.String() ); } else if ( nInstruction == D3DSIO_EXP ) { PrintToBufWithIndents( *m_pBufALUCode, "%s = exp2( %s );\n", sParam1.String(), sParam2.String() ); } else if ( nInstruction == D3DSIO_FRC ) { PrintToBufWithIndents( *m_pBufALUCode, "%s = fract( %s );\n", sParam1.String(), sParam2.String() ); } else if ( nInstruction == D3DSIO_LOG ) // d3d 'log' is log base 2 { PrintToBufWithIndents( *m_pBufALUCode, "%s = log2( %s );\n", sParam1.String(), sParam2.String() ); } else if ( nInstruction == D3DSIO_ABS ) // rbarris did this one, Jason please check { PrintToBufWithIndents( *m_pBufALUCode, "%s = abs( %s );\n", sParam1.String(), sParam2.String() ); } else if ( nInstruction == D3DSIO_MOVA ) { m_bDeclareAddressReg = true; PrintToBufWithIndents( *m_pBufALUCode, "%s = %s;\n", sParam1.String(), sParam2.String() ); if ( !m_bGenerateBoneUniformBuffer ) { m_nHighestRegister = DXABSTRACT_VS_PARAM_SLOTS - 1; } } else { Error( "Unsupported instruction" ); } // If the _SAT instruction modifier is used, then do a saturate here. if ( nDestToken & D3DSPDM_SATURATE ) { int nComponents = GetNumSwizzleComponents( sParam1.String() ); if ( nComponents == 0 ) { nComponents = 4; } PrintToBufWithIndents( *m_pBufALUCode, "%s = clamp( %s, %s, %s );\n", sParam1.String(), sParam1.String(), g_szVecZeros[nComponents], g_szVecOnes[nComponents] ); } } void D3DToGL::WriteGLSLSamplerDefinitions() { int nSamplersWritten = 0; for ( int i=0; i < ARRAYSIZE( m_dwSamplerTypes ); i++ ) { if ( m_dwSamplerTypes[i] == SAMPLER_TYPE_2D ) { if ( ( ( 1 << i ) & m_nShadowDepthSamplerMask ) != 0 ) { PrintToBuf( *m_pBufHeaderCode, "uniform sampler2DShadow sampler%d;\n", i ); } else { PrintToBuf( *m_pBufHeaderCode, "uniform sampler2D sampler%d;\n", i ); } ++nSamplersWritten; } else if ( m_dwSamplerTypes[i] == SAMPLER_TYPE_3D ) { PrintToBuf( *m_pBufHeaderCode, "uniform sampler3D sampler%d;\n", i ); ++nSamplersWritten; } else if ( m_dwSamplerTypes[i] == SAMPLER_TYPE_CUBE ) { PrintToBuf( *m_pBufHeaderCode, "uniform samplerCube sampler%d;\n", i ); ++nSamplersWritten; } else if ( m_dwSamplerTypes[i] != SAMPLER_TYPE_UNUSED ) { Error( "Unknown sampler type." ); } } if ( nSamplersWritten > 0 ) PrintToBuf( *m_pBufHeaderCode, "\n\n" ); } void D3DToGL::WriteGLSLOutputVariableAssignments() { if ( m_bVertexShader ) { // Map output "oN" registers back to GLSL output variables. if ( m_bAddHexCodeComments ) { PrintToBuf( *m_pBufAttribCode, "\n// Now we're storing the oN variables from the output dcl_ statements back into their GLSL equivalents.\n" ); } for ( int i=0; i < ARRAYSIZE( m_DeclaredOutputs ); i++ ) { if ( m_DeclaredOutputs[i] == UNDECLARED_OUTPUT ) continue; if ( ( m_dwTexCoordOutMask & ( 1 << i ) ) == 0 ) continue; uint32 dwToken = m_DeclaredOutputs[i]; uint32 dwUsage = ( dwToken & D3DSP_DCL_USAGE_MASK ); uint32 dwUsageIndex = ( dwToken & D3DSP_DCL_USAGEINDEX_MASK ) >> D3DSP_DCL_USAGEINDEX_SHIFT; if ( ( dwUsage == D3DDECLUSAGE_FOG ) || ( dwUsage == D3DDECLUSAGE_PSIZE ) ) { TranslationError(); // Not supported yet, but can be if we need it. } if ( dwUsage == D3DDECLUSAGE_COLOR ) { PrintToBufWithIndents( *m_pBufALUCode, "%s = oTempT%d;\n", dwUsageIndex ? "gl_FrontSecondaryColor" : "gl_FrontColor", i ); } else if ( dwUsage == D3DDECLUSAGE_TEXCOORD ) { char buf[256]; if ( m_nCentroidMask & ( 0x00000001 << dwUsageIndex ) ) { V_snprintf( buf, sizeof( buf ), "centroid varying vec4 oT%d;\n", dwUsageIndex ); // centroid varying } else { V_snprintf( buf, sizeof( buf ), "varying vec4 oT%d;\n", dwUsageIndex ); } StrcatToHeaderCode( buf ); PrintToBufWithIndents( *m_pBufALUCode, "oT%d = oTempT%d;\n", dwUsageIndex, i ); } } } } void D3DToGL::WriteGLSLInputVariableAssignments() { if ( m_bVertexShader ) return; for ( int i=0; i < ARRAYSIZE( m_DeclaredInputs ); i++ ) { if ( m_DeclaredInputs[i] == UNDECLARED_INPUT ) continue; uint32 dwToken = m_DeclaredInputs[i]; uint32 dwUsage = ( dwToken & D3DSP_DCL_USAGE_MASK ); uint32 dwUsageIndex = ( dwToken & D3DSP_DCL_USAGEINDEX_MASK ) >> D3DSP_DCL_USAGEINDEX_SHIFT; if ( dwUsage == D3DDECLUSAGE_COLOR ) { PrintToBufWithIndents( *m_pBufAttribCode, "vec4 oTempT%d = %s;\n", i, dwUsageIndex ? "gl_SecondaryColor" : "gl_Color" ); } else if ( dwUsage == D3DDECLUSAGE_TEXCOORD ) { PrintToBufWithIndents( *m_pBufAttribCode, "vec4 oTempT%d = oT%d;\n", i, dwUsageIndex ); } } } void D3DToGL::Handle_DeclarativeNonDclOp( uint32 nInstruction ) { char buff[128]; uint32 dwToken = GetNextToken(); PrintParameterToString( dwToken, DST_REGISTER, buff, sizeof( buff ), false, NULL ); if ( nInstruction == D3DSIO_TEXKILL ) { // TEXKILL is supposed to discard the pixel if any of the src register's X, Y, or Z components are less than zero. // We have to translate it to something like: // if ( r0.x < 0.0 || r0.y < 0.0 ) // discard; char c[3]; c[0] = GetSwizzleComponent( buff, 0 ); c[1] = GetSwizzleComponent( buff, 1 ); c[2] = GetSwizzleComponent( buff, 2 ); // Get the unique components. char cUnique[3]; cUnique[0] = c[0]; int nUnique = 1; if ( c[1] != c[0] ) cUnique[nUnique++] = c[1]; if ( c[2] != c[1] && c[2] != c[0] ) cUnique[nUnique++] = c[2]; // Get the src register base name. char szBase[256]; GetParamNameWithoutSwizzle( buff, szBase, sizeof( szBase ) ); PrintToBufWithIndents( *m_pBufALUCode, "if ( %s.%c < 0.0 ", szBase, cUnique[0] ); for ( int i=1; i < nUnique; i++ ) { PrintToBuf( *m_pBufALUCode, "|| %s.%c < 0.0 ", szBase, cUnique[i] ); } PrintToBuf( *m_pBufALUCode, ")\n{\n\tdiscard;\n}\n" ); } else { char szOpcode[128]; PrintOpcode( nInstruction, szOpcode, sizeof( szOpcode ) ); StrcatToALUCode( szOpcode ); StrcatToALUCode( buff ); StrcatToALUCode( ";\n" ); } } void D3DToGL::NoteTangentInputUsed() { if ( !m_bTangentInputUsed ) { m_bTangentInputUsed = true; // PrintToBuf( *m_pBufParamCode, "attribute vec4 %s;\n", g_pTangentAttributeName ); } } // These are the only ARL instructions that should appear in the instruction stream void D3DToGL::InsertMoveInstruction( CUtlBuffer *pCode, int nARLComponent ) { PrintIndentation( ( char * )pCode->Base(), pCode->Size() ); switch ( nARLComponent ) { case ARL_DEST_X: strcat_s( ( char * )pCode->Base(), pCode->Size(), "a0 = int( va_r.x );\n" ); break; case ARL_DEST_Y: strcat_s( ( char * )pCode->Base(), pCode->Size(), "a0 = int( va_r.y );\n" ); break; case ARL_DEST_Z: strcat_s( ( char * )pCode->Base(), pCode->Size(), "a0 = int( va_r.z );\n" ); break; case ARL_DEST_W: strcat_s( ( char * )pCode->Base(), pCode->Size(), "a0 = int( va_r.w );\n" ); break; } } // This optionally inserts a move from our dummy address register to the .x component of the real one void D3DToGL::InsertMoveFromAddressRegister( CUtlBuffer *pCode, int nARLComp0, int nARLComp1, int nARLComp2 /* = ARL_DEST_NONE */ ) { // We no longer need to do this in GLSL - we put the cast to int from the dummy address register va_r.x, va_r.y, etc. directly into the instruction return; } //------------------------------------------------------------------------------ // 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. //------------------------------------------------------------------------------ int D3DToGL::TranslateShader( uint32* code, CUtlBuffer *pBufDisassembledCode, bool *bVertexShader, uint32 options, int32 nShadowDepthSamplerMask, uint32 nCentroidMask, char *debugLabel ) { CUtlString sLine, sParamName; uint32 i, dwToken, nInstruction, nNumTokensToSkip; char buff[256]; // 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; m_bAddHexCodeComments = (options & D3DToGL_AddHexComments) != 0; m_bPutHexCodesAfterLines = (options & D3DToGL_PutHexCommentsAfterLines) != 0; m_bGeneratingDebugText = (options & D3DToGL_GeneratingDebugText) != 0; m_bGenerateSRGBWriteSuffix = (options & D3DToGL_OptionSRGBWriteSuffix) != 0; m_NumIndentTabs = 1; // start code indented one tab m_nLoopDepth = 0; // debugging m_bSpew = (options & D3DToGL_OptionSpew) != 0; // These are not accessed below in a way that will cause them to glow, so // we could overflow these and/or the buffer pointed to by pDisassembledCode m_pBufAttribCode = new CUtlBuffer( 100, 10000, CUtlBuffer::TEXT_BUFFER ); m_pBufParamCode = new CUtlBuffer( 100, 10000, CUtlBuffer::TEXT_BUFFER ); m_pBufALUCode = new CUtlBuffer( 100, 60000, CUtlBuffer::TEXT_BUFFER ); // Pointers to text buffers for assembling sections of the program m_pBufHeaderCode = pBufDisassembledCode; char *pAttribMapStart = NULL; ((char*)m_pBufHeaderCode->Base())[0] = 0; ((char*)m_pBufAttribCode->Base())[0] = 0; ((char*)m_pBufParamCode->Base())[0] = 0; ((char*)m_pBufALUCode->Base())[0] = 0; for ( i=0; iBase(), m_pBufHeaderCode->Size(), "#version %s\n%s", glslVersionText, glslExtText ); m_bVertexShader = false; } else // vertex shader { m_bGenerateSRGBWriteSuffix = false; V_snprintf( (char *)m_pBufHeaderCode->Base(), m_pBufHeaderCode->Size(), "#version %s\n%s//ATTRIBMAP-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx\n", glslVersionText, glslExtText ); // find that first '-xx' which is where the attrib map will be written later. pAttribMapStart = strstr( (char *)m_pBufHeaderCode->Base(), "-xx" ) + 1; m_bVertexShader = true; } *bVertexShader = m_bVertexShader; m_bGenerateBoneUniformBuffer = m_bVertexShader && ((options & D3DToGL_OptionGenerateBoneUniformBuffer) != 0); if ( m_bAddHexCodeComments ) { RecordInputAndOutputPositions(); } 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() ) { if ( m_bAddHexCodeComments ) { AddTokenHexCode(); RecordInputAndOutputPositions(); } #ifdef POSIX int tokenIndex = m_pdwNextToken - code; #endif int aluCodeLength0 = V_strlen( (char *) m_pBufALUCode->Base() ); dwToken = GetNextToken(); // Get next dwToken in the stream nInstruction = 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, nInstruction), dwToken ); #endif opcounter++; } switch ( nInstruction ) { // -- No arguments at all ----------------------------------------------- case D3DSIO_NOP: // D3D compiler outputs NOPs when shader debugging/optimizations are disabled. break; case D3DSIO_PHASE: case D3DSIO_RET: case D3DSIO_ENDLOOP: case D3DSIO_BREAK: TranslationError(); PrintOpcode( nInstruction, buff, sizeof( buff ) ); StrcatToALUCode( buff ); StrcatToALUCode( ";\n" ); break; // -- "Declarative" non dcl ops ---------------------------------------- case D3DSIO_TEXDEPTH: case D3DSIO_TEXKILL: Handle_DeclarativeNonDclOp( nInstruction ); 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_LOOP: case D3DSIO_BREAKP: case D3DSIO_DSX: case D3DSIO_DSY: TranslationError(); break; case D3DSIO_IFC: { static const char *s_szCompareStrings[ 7 ] = { "__INVALID__", ">", "==", ">=", "<", "!=", "<=" }; // Compare mode is encoded in instruction token uint32 dwCompareMode = OpcodeSpecificData( dwToken ); Assert( ( dwCompareMode >= 1 ) && ( dwCompareMode <= 6 ) ); // Get left side of compare dwToken = GetNextToken(); char szLeftSide[32]; PrintParameterToString( dwToken, SRC_REGISTER, szLeftSide, sizeof( szLeftSide ), false, NULL ); // Get right side of compare dwToken = GetNextToken(); char szRightSide[32]; PrintParameterToString( dwToken, SRC_REGISTER, szRightSide, sizeof( szRightSide ), false, NULL ); PrintToBufWithIndents( *m_pBufALUCode, "if ( %s %s %s )\n", szLeftSide, s_szCompareStrings[dwCompareMode], szRightSide ); StrcatToALUCode( "{\n" ); m_NumIndentTabs++; break; } case D3DSIO_IF: dwToken = GetNextToken(); PrintParameterToString( dwToken, SRC_REGISTER, buff, sizeof( buff ), false, NULL ); PrintToBufWithIndents( *m_pBufALUCode, "if ( %s )\n", buff ); StrcatToALUCode( "{\n" ); m_NumIndentTabs++; break; case D3DSIO_ELSE: m_NumIndentTabs--; StrcatToALUCode( "}\n" ); StrcatToALUCode( "else\n" ); StrcatToALUCode( "{\n" ); m_NumIndentTabs++; break; case D3DSIO_ENDIF: m_NumIndentTabs--; StrcatToALUCode( "}\n" ); break; case D3DSIO_REP: dwToken = GetNextToken(); PrintParameterToString( dwToken, SRC_REGISTER, buff, sizeof( buff ), false, NULL ); // In practice, this is the only form of for loop that will appear in DX asm PrintToBufWithIndents( *m_pBufALUCode, "for( int i=0; i < %s; i++ )\n", buff ); StrcatToALUCode( "{\n" ); m_nLoopDepth++; // For now, we don't deal with loop nesting // Easy enough to fix later with an array of loop names i, j, k etc Assert( m_nLoopDepth <= 1 ); m_NumIndentTabs++; break; case D3DSIO_ENDREP: m_nLoopDepth--; m_NumIndentTabs--; StrcatToALUCode( "}\n" ); break; case D3DSIO_NRM: Handle_NRM(); break; case D3DSIO_MOVA: Handle_UnaryOp( nInstruction ); break; // Unary operations 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: Handle_UnaryOp( nInstruction ); 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_SETP: TranslationError(); break; case D3DSIO_BREAKC: Handle_BREAKC( dwToken ); break; // Binary Operations 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: HandleBinaryOp_GLSL( nInstruction ); break; // -- Ternary ops ------------------------------------------------- case D3DSIO_DP2ADD: Handle_DP2ADD(); break; case D3DSIO_LRP: Handle_LRP( nInstruction ); break; case D3DSIO_SGN: Assert( m_bVertexShader ); TranslationError(); // TODO emulate with SLT etc break; case D3DSIO_CND: TranslationError(); break; case D3DSIO_CMP: Handle_CMP(); break; case D3DSIO_SINCOS: Handle_SINCOS(); break; case D3DSIO_MAD: Handle_MAD( nInstruction ); break; // -- Quaternary op ------------------------------------------------ case D3DSIO_TEXLDD: Handle_TexLDD( nInstruction ); break; // -- Special cases: texcoord vs texcrd and tex vs texld ----------- case D3DSIO_TEXCOORD: Handle_TexCoord(); break; case D3DSIO_TEX: Handle_TEX( dwToken, false ); break; case D3DSIO_TEXLDL: Handle_TEX( nInstruction, true ); break; case D3DSIO_DCL: Handle_DCL(); break; case D3DSIO_DEFB: case D3DSIO_DEFI: Handle_DEFIB( nInstruction ); break; case D3DSIO_DEF: Handle_DEF(); 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 = V_strlen( (char *) m_pBufALUCode->Base() ); if ( aluCodeLength1 != aluCodeLength0 ) { // code was emitted printf( "\n > %s", ((char *)m_pBufALUCode->Base()) + aluCodeLength0 ); aluCodeLength0 = aluCodeLength1; } } } // 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 even // match the D3DSINCOSCONST1 and D3DSINCOSCONST2 constants used by the D3D assembly sincos instruction... if ( m_bNeedsSinCosDeclarations ) { PrintIndentation( (char*)m_pBufParamCode->Base(), m_pBufParamCode->Size() ); StrcatToParamCode( "vec4 scA = vec4( -1.55009923e-6, -2.17013894e-5, 0.00260416674, 0.00026041668 );\n" ); PrintIndentation( (char*)m_pBufParamCode->Base(), m_pBufParamCode->Size() ); StrcatToParamCode( "vec4 scB = vec4( -0.020833334, -0.125, 1.0, 0.5 );\n" ); } // Stick in the sampler mask in hex PrintToBuf( *m_pBufHeaderCode, "%sSAMPLERMASK-%x\n", "//", m_dwSamplerUsageMask ); uint nSamplerTypes = 0; for ( int i = 0; i < 16; i++ ) { Assert( m_dwSamplerTypes[i] < 4); nSamplerTypes |= ( m_dwSamplerTypes[i] << ( i * 2 ) ); } PrintToBuf( *m_pBufHeaderCode, "%sSAMPLERTYPES-%x\n", "//", nSamplerTypes ); // fragData outputs referenced uint nFragDataMask = 0; for ( int i = 0; i < 4; i++ ) { nFragDataMask |= m_bOutputColorRegister[ i ] ? ( 1 << i ) : 0; } PrintToBuf( *m_pBufHeaderCode, "%sFRAGDATAMASK-%x\n", "//", nFragDataMask ); // Uniforms PrintToBuf( *m_pBufHeaderCode, "//HIGHWATER-%d\n", m_nHighestRegister + 1 ); if ( ( m_bVertexShader ) && ( m_bGenerateBoneUniformBuffer ) ) { PrintToBuf( *m_pBufHeaderCode, "//HIGHWATERBONE-%i\n", m_nHighestBoneRegister + 1 ); } PrintToBuf( *m_pBufHeaderCode, "\nuniform vec4 %s[%d];\n", m_bVertexShader ? "vc" : "pc", m_nHighestRegister + 1 ); if ( ( m_nHighestBoneRegister >= 0 ) && ( m_bVertexShader ) && ( m_bGenerateBoneUniformBuffer ) ) { PrintToBuf( *m_pBufHeaderCode, "\nuniform vec4 %s[%d];\n", "vcbones", m_nHighestBoneRegister + 1 ); } if ( m_bVertexShader ) { PrintToBuf( *m_pBufHeaderCode, "\nuniform vec4 vcscreen;\n" ); } for( int i=0; i<32; i++ ) { if ( ( m_dwConstIntUsageMask & ( 0x00000001 << i ) ) && ( !( m_dwDefConstIntUsageMask & ( 0x00000001 << i ) ) ) ) { PrintToBuf( *m_pBufHeaderCode, "uniform int i%d ;\n", i ); } } for( int i=0; i<32; i++ ) { if ( m_dwDefConstIntUsageMask & ( 0x00000001 << i ) ) { PrintToBuf( *m_pBufHeaderCode, "const int i%d = %i;\n", i, m_dwDefConstIntIterCount[i] ); } } for( int i=0; i<32; i++ ) { if ( m_dwConstBoolUsageMask & ( 0x00000001 << i ) ) { PrintToBuf( *m_pBufHeaderCode, m_bVertexShader ? "uniform bool b%d;\n" : "uniform bool fb%d;\n", i ); } } // Control bit for sRGB Write suffix if ( m_bGenerateSRGBWriteSuffix ) { // R500 Hookup // Set this guy to 1 when the sRGBWrite state is true, otherwise 0 StrcatToHeaderCode( "uniform float flSRGBWrite;\n" ); } PrintToBuf( *m_pBufHeaderCode, "\n" ); // Write samplers WriteGLSLSamplerDefinitions(); if ( m_bUsesDSTInstruction ) { PrintToBuf( *m_pBufHeaderCode, "vec4 dst(vec4 src0,vec4 src1) { return vec4(1.0f,src0.y*src1.y,src0.z,src1.w); }\n" ); } if ( m_bDeclareAddressReg ) { if ( !m_bGenerateBoneUniformBuffer ) { m_nHighestRegister = DXABSTRACT_VS_PARAM_SLOTS - 1; } PrintIndentation( (char*)m_pBufParamCode->Base(), m_pBufParamCode->Size() ); StrcatToParamCode( "vec4 va_r;\n" ); } char *pTempVarStr = "TEMP"; pTempVarStr = "vec4"; // Declare temps in Param code buffer for( int i=0; i<32; i++ ) { if ( m_dwTempUsageMask & ( 0x00000001 << i ) ) { PrintIndentation( (char*)m_pBufParamCode->Base(), m_pBufParamCode->Size() ); PrintToBuf( *m_pBufParamCode, "%s r%d;\n", pTempVarStr, i ); } } if ( m_bVertexShader && (m_bDoUserClipPlanes || m_bDoFixupZ || m_bDoFixupY ) ) { PrintIndentation( (char*)m_pBufParamCode->Base(), m_pBufParamCode->Size() ); StrcatToParamCode( "vec4 vTempPos;\n" ); } if ( ( m_bVertexShader ) && ( m_dwMajorVersion == 3 ) ) { for ( int i = 0; i < 32; i++ ) { if ( m_dwTexCoordOutMask & ( 1 << i ) ) { PrintIndentation( (char*)m_pBufParamCode->Base(), m_pBufParamCode->Size() ); char buf[256]; V_snprintf( buf, sizeof( buf ), "vec4 oTempT%i = vec4( 0, 0, 0, 0 );\n", i ); StrcatToParamCode( buf ); } } } if ( m_bNeedsSinCosDeclarations ) { StrcatToParamCode( "vec3 vSinCosTmp;\n" ); // declare temp used by GLSL sin and cos intrinsics } // Optional temps needed to emulate d2add instruction in DX pixel shaders if ( m_bNeedsD2AddTemp ) { PrintToBuf( *m_pBufParamCode, "%s DP2A0;\n%s DP2A1;\n", pTempVarStr, pTempVarStr ); } // Optional temp needed to emulate lerp instruction in DX vertex shaders if ( m_bNeedsLerpTemp ) { PrintToBuf( *m_pBufParamCode, "%s LRP_TEMP;\n", pTempVarStr ); } // Optional temp needed to emulate NRM instruction in DX shaders if ( m_bNeedsNRMTemp ) { PrintToBuf( *m_pBufParamCode, "%s NRM_TEMP;\n", pTempVarStr ); } if ( m_bDeclareVSOPos && m_bVertexShader ) { if ( m_bDoUserClipPlanes ) { StrcatToALUCode( "gl_ClipVertex = vTempPos;\n" ); // if user clip is enabled, jam clip space position into gl_ClipVertex } if ( m_bDoFixupZ || m_bDoFixupY ) { // TODO: insert clip distance computation something like this: // // StrcatToALUCode( "DP4 oCLP[0].x, oPos, vc[215]; \n" ); // if ( m_bDoFixupZ ) { StrcatToALUCode( "vTempPos.z = vTempPos.z * vc[0].z - vTempPos.w; // z' = (2*z)-w\n" ); } if ( m_bDoFixupY ) { // append instructions to flip Y over // new Y = -(old Y) StrcatToALUCode( "vTempPos.y = -vTempPos.y; // y' = -y \n" ); } // Apply half pixel offset (0.5f pixel offset D3D) to output vertices to account for the pixel center difference between D3D9 and OpenGL. // This is the actual work in the shader. This works out to be 0.5 pixels wide because clip space is 2 units wide (-1, 1). StrcatToALUCode( "vTempPos.xy += vcscreen.xy * vTempPos.w;\n" ); StrcatToALUCode( "gl_Position = vTempPos;\n" ); } else { StrcatToParamCode( "OUTPUT oPos = result.position;\n" ); // TODO: insert clip distance computation something like this: // // StrcatToALUCode( "DP4 oCLP[0].x, oPos, c[215]; \n" ); // } } if ( m_bVertexShader ) { if ( m_dwMajorVersion == 3 ) { WriteGLSLOutputVariableAssignments(); } else { for ( int i=0; i<32; i++ ) { char outTexCoordBuff[64]; // Don't declare a varying for the output that is mapped to the position output if ( i != m_nVSPositionOutput ) { if ( m_dwTexCoordOutMask & ( 0x00000001 << i ) ) { if ( m_nCentroidMask & ( 0x00000001 << i ) ) { V_snprintf( outTexCoordBuff, sizeof( outTexCoordBuff ), "centroid varying vec4 oT%d;\n", i ); // centroid varying StrcatToHeaderCode( outTexCoordBuff ); } else { V_snprintf( outTexCoordBuff, sizeof( outTexCoordBuff ), "varying vec4 oT%d;\n", i ); StrcatToHeaderCode( outTexCoordBuff ); } } } } } } else { if ( m_dwMajorVersion == 3 ) { WriteGLSLInputVariableAssignments(); } } // 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 ); } } } PrintIndentation( (char*)m_pBufAttribCode->Base(), m_pBufAttribCode->Size() ); // This used to write out a translation counter into the shader as a comment. However, the order that shaders get in here // is non-deterministic between runs, and the change in this comment would cause shaders to appear different to the GL disk cache, // significantly increasing app load time. // Other code looks for trans#%d, so we can't just remove it. Instead, output it as 0. V_snprintf( temp, sizeof(temp), "%s trans#%d label:%s\n", "//", 0, debugLabel ? debugLabel : "none" ); StrcatToAttribCode( temp ); } // If we actually sample from a shadow depth sampler, we need to declare the shadow option at the top if ( m_bDeclareShadowOption ) { StrcatToHeaderCode( "OPTION ARB_fragment_program_shadow;\n" ); } StrcatToHeaderCode( "\nvoid main()\n{\n" ); if ( m_bUsedAtomicTempVar ) { PrintToBufWithIndents( *m_pBufHeaderCode, "vec4 %s;\n\n", g_pAtomicTempVarName ); } // sRGB Write suffix if ( m_bGenerateSRGBWriteSuffix ) { StrcatToALUCode( "vec3 sRGBFragData;\n" ); StrcatToALUCode( "sRGBFragData.xyz = log( gl_FragData[0].xyz );\n" ); StrcatToALUCode( "sRGBFragData.xyz = sRGBFragData.xyz * vec3( 0.454545f, 0.454545f, 0.454545f );\n" ); StrcatToALUCode( "sRGBFragData.xyz = exp( sRGBFragData.xyz );\n" ); StrcatToALUCode( "gl_FragData[0].xyz = mix( gl_FragData[0].xyz, sRGBFragData, flSRGBWrite );\n" ); } strcat_s( (char*)m_pBufALUCode->Base(), m_pBufALUCode->Size(), "}\n" ); // Put all of the strings together for final program ( pHeaderCode + pAttribCode + pParamCode + pALUCode ) StrcatToHeaderCode( (char*)m_pBufAttribCode->Base() ); StrcatToHeaderCode( (char*)m_pBufParamCode->Base() ); StrcatToHeaderCode( (char*)m_pBufALUCode->Base() ); // Cleanup - don't touch m_pBufHeaderCode, as it is managed by the caller delete m_pBufAttribCode; delete m_pBufParamCode; delete m_pBufALUCode; m_pBufAttribCode = m_pBufParamCode = m_pBufALUCode = NULL; if ( m_bSpew ) { printf("\n************* translation complete\n\n " ); } return DISASM_OK; }