1 files changed, 261 insertions, 0 deletions
diff --git a/togl/linuxwin/dx9asmtogl2.h b/togl/linuxwin/dx9asmtogl2.h
new file mode 100644
index 0000000..2ab7e09
--- /dev/null
+++ b/togl/linuxwin/dx9asmtogl2.h
@@ -0,0 +1,261 @@
+//========= 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.h
+//------------------------------------------------------------------------------
+
+#ifndef DX9_ASM_TO_GL_2_H
+#define DX9_ASM_TO_GL_2_H
+#include "tier1/utlstring.h"
+
+#define DISASM_OK      0
+#define DISASM_ERROR   1
+
+#define MAX_SHADER_CONSTANTS	512
+
+#define MAX_DECLARED_OUTPUTS	32
+#define MAX_DECLARED_INPUTS	32
+
+#define HEXCODE_HEADER		"// Hex: "
+
+// Option bits
+#define D3DToGL_OptionUseEnvParams				0x0001
+#define D3DToGL_OptionDoFixupZ					0x0002		// Add instructions to put Z in the right interval for GL
+#define D3DToGL_OptionDoFixupY					0x0004		// Add instructions to flip the Y over for GL
+#define D3DToGL_OptionDoUserClipPlanes			0x0008		// ARB mode: Include OPTION vertex_program_2 and append DP4's to write into oCLP[0] and oCLP[1]
+															// GLSL mode: generate code to write gl_ClipVertex
+
+#define D3DToGL_AddHexComments					0x0020		// Include hex comments in the code for debugging
+#define D3DToGL_PutHexCommentsAfterLines		0x0040		// If D3DToGL_AddHexComments is set, this puts the codes to the right, rather than on separate lines
+#define D3DToGL_GeneratingDebugText				0x0080		// This tells it that we're just getting info for debugging so go easy on asserts and errors
+#define D3DToGL_OptionSRGBWriteSuffix			0x0400		// Tack sRGB conversion suffix on to pixel shaders
+#define D3DToGL_OptionGenerateBoneUniformBuffer	0x0800		// if enabled, the vertex shader "bone" registers (all regs DXABSTRACT_VS_FIRST_BONE_SLOT and higher) will be separated out into another uniform buffer (vcbone)
+#define D3DToGL_OptionUseBindlessTexturing		0x1000
+#define D3DToGL_OptionSpew						0x80000000
+
+// Code for which component of the "dummy" address register is needed by an instruction
+#define ARL_DEST_NONE		-1
+#define ARL_DEST_X			 0
+#define ARL_DEST_Y			 1
+#define ARL_DEST_Z			 2
+#define ARL_DEST_W			 3
+
+class D3DToGL
+{
+private:
+	// Pointers for dwToken stream management
+	uint32* m_pdwBaseToken;
+	uint32* m_pdwNextToken;
+
+	// Vertex shader or pixel shader, and version (necessary because some opcodes alias)
+	bool m_bVertexShader;
+	uint32 m_dwMinorVersion;
+	uint32 m_dwMajorVersion;
+
+	// Option flags
+	bool	m_bUseEnvParams;			// set D3DToGL_OptionUseEnvParams in 'options' to use
+	bool	m_bDoFixupZ;				// set D3DToGL_OptionDoFixupZ
+	bool	m_bDoFixupY;				// set D3DToGL_OptionDoFixupZ
+	bool	m_bDoUserClipPlanes;		// set D3DToGL_OptionDoUserClipPlanes
+	bool	m_bSpew;					// set D3DToGL_OptionSpew
+	bool	m_bGenerateSRGBWriteSuffix;	// set D3DToGL_OptionSRGBWriteSuffix
+	bool	m_bGenerateBoneUniformBuffer;
+	bool	m_bUseBindlessTexturing;
+		
+	// Counter for dealing with nested loops
+	int m_nLoopDepth;
+
+	// Add "// Hex: 0xFFEEF00"-type statements after each instruction is parsed.
+	bool m_bAddHexCodeComments;		// set D3DToGL_AddHexComments
+
+	// Only applicable if m_bAddHexCodeComments is true. 
+	// If this is true, then it puts the hex code comments to the right of the instructions in a comment
+	// rather than preceding the instructions.
+	// Defaults to FALSE.
+	bool m_bPutHexCodesAfterLines;	// set D3DToGL_PutHexCommentsAtEnd
+
+	// This tells it that we're just getting info for debugging so go easy on asserts and errors.
+	// Defaults to FALSE.
+	bool m_bGeneratingDebugText;
+
+	// Various scratch temps needed to handle mis-matches in instruction sets between D3D and OpenGL
+	bool m_bNeedsD2AddTemp;
+	bool m_bNeedsNRMTemp;
+	bool m_bDeclareAddressReg;
+	bool m_bNeedsLerpTemp;
+	bool m_bNeedsSinCosDeclarations;
+
+	// Keep track of which vs outputs are used so we can declare them
+	bool m_bDeclareVSOPos;
+	bool m_bDeclareVSOFog;
+	uint32 m_dwTexCoordOutMask;
+
+	int32 m_nVSPositionOutput;
+	
+	// Mask of varyings which need centroid decoration
+	uint32 m_nCentroidMask;
+
+	// Keep track of which temps are used so they can be declared
+	uint32 m_dwTempUsageMask;
+	uint32 m_dwTempBoolUsageMask;
+	bool m_bOutputColorRegister[4];
+	bool m_bOutputDepthRegister;
+	
+	// Declaration of integer and bool constants
+	uint32 m_dwConstIntUsageMask;
+	uint32 m_dwConstBoolUsageMask;
+
+	uint32 m_dwDefConstIntUsageMask;
+	uint32 m_dwDefConstIntIterCount[32];
+	
+	// Did we use atomic_temp_var?
+	bool m_bUsedAtomicTempVar;
+	
+	// Track constants so we know how to declare them
+	bool m_bConstantRegisterDefined[MAX_SHADER_CONSTANTS];
+
+	// Track sampler types when declared so we can properly decorate TEX instructions
+	uint32 m_dwSamplerTypes[32];
+	
+	// Track sampler usage
+	uint32 m_dwSamplerUsageMask;
+
+	// Track shadow sampler usage
+	int m_nShadowDepthSamplerMask;
+	bool m_bDeclareShadowOption;
+
+	// Track attribute references
+	// init to 0xFFFFFFFF (unhit)
+	// index by (dwRegToken & D3DSP_REGNUM_MASK) in VS DCL insns
+	// fill with (usage<<4) | (usage index).
+	uint32 m_dwAttribMap[16];	
+
+	// Register high water mark
+	uint32 m_nHighestRegister;
+	int32 m_nHighestBoneRegister;
+	
+	// GLSL does indentation for readability
+	int m_NumIndentTabs;
+
+	// Output buffers.
+	CUtlBuffer *m_pBufHeaderCode;
+	CUtlBuffer *m_pBufAttribCode;
+	CUtlBuffer *m_pBufParamCode;
+	CUtlBuffer *m_pBufALUCode;
+
+	char *m_pFinalAssignmentsCode;
+	int m_nFinalAssignmentsBufSize;
+
+	// Recorded positions for debugging.
+	uint32* m_pRecordedInputTokenStart;
+	int m_nRecordedParamCodeStrlen;
+	int m_nRecordedALUCodeStrlen;
+	int m_nRecordedAttribCodeStrlen;
+
+	// In GLSL mode, these store the semantic attached to each oN register.
+	// They are the values that you pass to GetUsageIndexAndString.
+	uint32 m_DeclaredOutputs[MAX_DECLARED_OUTPUTS];
+	
+	uint32 m_DeclaredInputs[MAX_DECLARED_INPUTS];
+
+	// Have they used the tangent input semantic (i.e. is g_pTangentAttributeName declared)?
+	bool m_bTangentInputUsed;
+
+	bool m_bUsesDSTInstruction;
+
+private:
+	// Utilities to aid in decoding token stream
+	uint32 GetNextToken( void );
+	void SkipTokens( uint32 numToSkip );
+	uint32 Opcode( uint32 dwToken );
+	uint32 OpcodeSpecificData( uint32 dwToken );
+	uint32 TextureType ( uint32 dwToken );
+	uint32 GetRegType( uint32 dwRegToken );
+
+	// Write to the different buffers.
+	void StrcatToHeaderCode( const char *pBuf );
+	void StrcatToALUCode( const char *pBuf );
+	void StrcatToParamCode( const char *pBuf );
+	void StrcatToAttribCode( const char *pBuf );
+	void PrintToBufWithIndents( CUtlBuffer &buf, const char *pFormat, ... );
+
+	// This helps write the token hex codes into the output stream for debugging.
+	void AddTokenHexCodeToBuffer( char *pBuffer, int nSize, int nLastStrlen );
+	void RecordInputAndOutputPositions();
+	void AddTokenHexCode();
+
+	// Utilities for decoding tokens in to strings according to ASM syntax
+	void PrintOpcode( uint32 inst, char* buff, int nBufLen );
+
+	// fSemanticFlags is SEMANTIC_INPUT or SEMANTIC_OUTPUT.
+	void PrintUsageAndIndexToString( uint32 dwToken, char* strUsageUsageIndexName, int nBufLen, int fSemanticFlags );
+	CUtlString GetUsageAndIndexString( uint32 dwToken, int fSemanticFlags );
+	CUtlString GetParameterString( uint32 dwToken, uint32 dwSourceOrDest, bool bForceScalarSource, int *pARLDestReg );
+	const char* GetGLSLOperatorString( uint32 inst );
+
+	void PrintParameterToString ( uint32 dwToken, uint32 dwSourceOrDest, char *pRegisterName, int nBufLen, bool bForceScalarSource, int *pARLDestReg );
+
+	void InsertMoveFromAddressRegister( CUtlBuffer *pCode, int nARLComp0, int nARLComp1, int nARLComp2 = ARL_DEST_NONE );
+	void InsertMoveInstruction( CUtlBuffer *pCode, int nARLComponent );
+	void FlagIndirectRegister( uint32 dwToken, int *pARLDestReg );
+
+	// Utilities for decoding tokens in to strings according to GLSL syntax
+	bool OpenIntrinsic( uint32 inst, char* buff, int nBufLen, uint32 destDimension, uint32 nArgumentDimension );
+	void PrintIndentation( char *pBuf, int nBufLen );
+
+	uint32 MaintainAttributeMap( uint32 dwToken, uint32 dwRegToken );
+
+	CUtlString FixGLSLSwizzle( const char *pDestRegisterName, const char *pSrcRegisterName );
+	void WriteGLSLCmp( const char *pDestReg, const char *pSrc0Reg, const char *pSrc1Reg, const char *pSrc2Reg );
+	void WriteGLSLSamplerDefinitions();
+	void WriteGLSLOutputVariableAssignments();
+	void WriteGLSLInputVariableAssignments();
+	void NoteTangentInputUsed();
+
+	void Handle_DCL();
+	void Handle_DEF();
+	void Handle_DEFIB( uint32 nInstruction );
+	void Handle_MAD( uint32 nInstruction );
+	void Handle_DP2ADD();
+	void Handle_SINCOS();
+	void Handle_LRP( uint32 nInstruction );
+	void Handle_TEX( uint32 dwToken, bool bIsTexLDL );
+	void Handle_TexLDD( uint32 nInstruction );
+	void Handle_TexCoord();
+	void Handle_UnaryOp( uint32 nInstruction );
+	void Handle_BREAKC( uint32 dwToken );
+	void HandleBinaryOp_GLSL( uint32 nInstruction );
+	void HandleBinaryOp_ASM( uint32 nInstruction );
+	void Handle_CMP();
+	void Handle_NRM();
+	void Handle_DeclarativeNonDclOp( uint32 nInstruction );
+
+public:
+	D3DToGL();
+
+	int TranslateShader( uint32* code, CUtlBuffer *pBufDisassembledCode, bool *bVertexShader, uint32 options, int32 nShadowDepthSamplerMask, uint32 nCentroidMask, char *debugLabel );
+};
+
+
+#endif // DX9_ASM_TO_GL_2_H