First version of the SOurce SDK 2013

3 files changed, 878 insertions, 0 deletions

diff --git a/mp/src/public/shaderlib/BaseShader.h b/mp/src/public/shaderlib/BaseShader.h
new file mode 100644
index 00000000..56d56d37
--- /dev/null
+++ b/mp/src/public/shaderlib/BaseShader.h
@@ -0,0 +1,339 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//

+//

+// Purpose: 

+//

+// $NoKeywords: $

+// This is what all shaders inherit from.

+//===========================================================================//

+

+#ifndef BASESHADER_H

+#define BASESHADER_H

+

+#ifdef _WIN32		   

+#pragma once

+#endif

+

+#include "materialsystem/IShader.h"

+#include "materialsystem/imaterialvar.h"

+#include "materialsystem/ishaderapi.h"

+#include "materialsystem/imaterialsystemhardwareconfig.h"

+#include "shaderlib/BaseShader.h"

+#include "convar.h"

+

+//-----------------------------------------------------------------------------

+// Forward declarations

+//-----------------------------------------------------------------------------

+class IMaterialVar;

+

+//-----------------------------------------------------------------------------

+// Standard material vars

+//-----------------------------------------------------------------------------

+// Note: if you add to these, add to s_StandardParams in CBaseShader.cpp

+enum ShaderMaterialVars_t

+{

+	FLAGS = 0,

+	FLAGS_DEFINED,	// mask indicating if the flag was specified

+	FLAGS2,

+	FLAGS_DEFINED2,

+	COLOR,

+	ALPHA,

+	BASETEXTURE,

+	FRAME,

+	BASETEXTURETRANSFORM,

+	FLASHLIGHTTEXTURE,

+	FLASHLIGHTTEXTUREFRAME,

+	COLOR2,

+	SRGBTINT,

+

+	NUM_SHADER_MATERIAL_VARS

+};

+

+

+// Alpha belnd mode enums. Moved from basevsshader

+enum BlendType_t

+{

+	// no alpha blending

+	BT_NONE = 0,

+

+

+

+	// src * srcAlpha + dst * (1-srcAlpha)

+	// two passes for HDR:

+	//		pass 1:

+	//			color: src * srcAlpha + dst * (1-srcAlpha)

+	//			alpha: srcAlpha * zero + dstAlpha * (1-srcAlpha)

+	//		pass 2:

+	//			color: none

+	//			alpha: srcAlpha * one + dstAlpha * one

+	//

+	BT_BLEND,

+

+

+	

+	// src * one + dst * one

+	// one pass for HDR

+	BT_ADD,

+

+

+	

+	// Why do we ever use this instead of using premultiplied alpha?

+	// src * srcAlpha + dst * one

+	// two passes for HDR

+	//		pass 1:

+	//			color: src * srcAlpha + dst * one

+	//			alpha: srcAlpha * one + dstAlpha * one

+	//		pass 2:

+	//			color: none

+	//			alpha: srcAlpha * one + dstAlpha * one

+	BT_BLENDADD

+};

+

+

+//-----------------------------------------------------------------------------

+// Base class for shaders, contains helper methods.

+//-----------------------------------------------------------------------------

+class CBaseShader : public IShader

+{

+public:

+	// constructor

+	CBaseShader();

+

+	// Methods inherited from IShader

+	virtual char const* GetFallbackShader( IMaterialVar** params ) const { return 0; }

+	virtual int GetNumParams( ) const;

+	virtual char const* GetParamName( int paramIndex ) const;

+	virtual char const* GetParamHelp( int paramIndex ) const;

+	virtual ShaderParamType_t GetParamType( int paramIndex ) const;

+	virtual char const* GetParamDefault( int paramIndex ) const;

+	virtual int GetParamFlags( int nParamIndex ) const;

+

+	virtual void InitShaderParams( IMaterialVar** ppParams, const char *pMaterialName );

+	virtual void InitShaderInstance( IMaterialVar** ppParams, IShaderInit *pShaderInit, const char *pMaterialName, const char *pTextureGroupName );

+	virtual void DrawElements( IMaterialVar **params, int nModulationFlags, IShaderShadow* pShaderShadow, IShaderDynamicAPI* pShaderAPI,

+								VertexCompressionType_t vertexCompression, CBasePerMaterialContextData **pContext );

+

+	virtual	const SoftwareVertexShader_t GetSoftwareVertexShader() const { return m_SoftwareVertexShader; }

+

+	virtual int ComputeModulationFlags( IMaterialVar** params, IShaderDynamicAPI* pShaderAPI );

+	virtual bool NeedsPowerOfTwoFrameBufferTexture( IMaterialVar **params, bool bCheckSpecificToThisFrame = true ) const;

+	virtual bool NeedsFullFrameBufferTexture( IMaterialVar **params, bool bCheckSpecificToThisFrame = true ) const;

+	virtual bool IsTranslucent( IMaterialVar **params ) const;

+

+public:

+	// These functions must be implemented by the shader

+	virtual void OnInitShaderParams( IMaterialVar** ppParams, const char *pMaterialName ) {}

+	virtual void OnInitShaderInstance( IMaterialVar** ppParams, IShaderInit *pShaderInit, const char *pMaterialName ) = 0;

+	virtual void OnDrawElements( IMaterialVar **params, IShaderShadow* pShaderShadow, IShaderDynamicAPI* pShaderAPI, VertexCompressionType_t vertexCompression, CBasePerMaterialContextData **pContextDataPtr ) = 0;

+

+	// Sets the default shadow state

+	void SetInitialShadowState( );

+ 

+	// Draws a snapshot

+	void Draw( bool bMakeActualDrawCall = true );

+

+	// Are we currently taking a snapshot?

+	bool IsSnapshotting() const;

+

+	// Gets at the current materialvar flags

+	int CurrentMaterialVarFlags() const;

+

+	// Finds a particular parameter	(works because the lowest parameters match the shader)

+	int FindParamIndex( const char *pName ) const;

+

+	// Are we using graphics?

+	bool IsUsingGraphics();

+

+	// Are we using editor materials?

+	bool CanUseEditorMaterials();

+

+	// Gets the builder...

+	CMeshBuilder* MeshBuilder();

+

+	// Loads a texture

+	void LoadTexture( int nTextureVar, int nAdditionalCreationFlags = 0 );

+

+	// Loads a bumpmap

+	void LoadBumpMap( int nTextureVar );

+

+	// Loads a cubemap

+	void LoadCubeMap( int nTextureVar, int nAdditionalCreationFlags = 0  );

+

+	// get the shaderapi handle for a texture. BE CAREFUL WITH THIS. 

+	ShaderAPITextureHandle_t GetShaderAPITextureBindHandle( int nTextureVar, int nFrameVar, int nTextureChannel = 0 );

+

+

+	// Binds a texture

+	void BindTexture( Sampler_t sampler1, Sampler_t sampler2, int nTextureVar, int nFrameVar = -1 );

+	void BindTexture( Sampler_t sampler1, int nTextureVar, int nFrameVar = -1 );

+	void BindTexture( Sampler_t sampler1, ITexture *pTexture, int nFrame = 0 );

+	void BindTexture( Sampler_t sampler1, Sampler_t sampler2, ITexture *pTexture, int nFrame = 0 );

+

+	// Is the texture translucent?

+	bool TextureIsTranslucent( int textureVar, bool isBaseTexture );

+

+	// Returns the translucency...

+	float GetAlpha( IMaterialVar** params = NULL );

+

+	// Is the color var white?

+	bool IsWhite( int colorVar );

+

+	// Helper methods for fog

+	void FogToOOOverbright( void );

+	void FogToWhite( void );

+	void FogToBlack( void );

+	void FogToGrey( void );

+	void FogToFogColor( void );

+	void DisableFog( void );

+	void DefaultFog( void );

+	

+	// Helpers for alpha blending

+	void EnableAlphaBlending( ShaderBlendFactor_t src, ShaderBlendFactor_t dst );

+	void DisableAlphaBlending();

+

+	void SetBlendingShadowState( BlendType_t nMode );

+

+	void SetNormalBlendingShadowState( int textureVar = -1, bool isBaseTexture = true );

+	void SetAdditiveBlendingShadowState( int textureVar = -1, bool isBaseTexture = true );

+	void SetDefaultBlendingShadowState( int textureVar = -1, bool isBaseTexture = true );

+	void SingleTextureLightmapBlendMode( );

+

+	// Helpers for color modulation

+	void SetColorState( int colorVar, bool setAlpha = false );

+	bool IsAlphaModulating();

+	bool IsColorModulating();

+	void ComputeModulationColor( float* color );

+	void SetModulationShadowState( int tintVar = -1 );

+	void SetModulationDynamicState( int tintVar = -1 );

+

+	// Helpers for HDR

+	bool IsHDREnabled( void );

+

+	// Loads the identity matrix into the texture

+	void LoadIdentity( MaterialMatrixMode_t matrixMode );

+

+	// Loads the camera to world transform

+	void LoadCameraToWorldTransform( MaterialMatrixMode_t matrixMode );

+	void LoadCameraSpaceSphereMapTransform( MaterialMatrixMode_t matrixMode );

+

+	// Sets a texture translation transform in fixed function

+	void SetFixedFunctionTextureTranslation( MaterialMatrixMode_t mode, int translationVar );

+	void SetFixedFunctionTextureScale( MaterialMatrixMode_t mode, int scaleVar );

+	void SetFixedFunctionTextureScaledTransform( MaterialMatrixMode_t textureTransform, int transformVar, int scaleVar );

+	void SetFixedFunctionTextureTransform( MaterialMatrixMode_t textureTransform, int transformVar );

+

+	void CleanupDynamicStateFixedFunction( );

+

+	// Fixed function Base * detail pass

+	void FixedFunctionBaseTimesDetailPass( int baseTextureVar, int frameVar, 

+		int baseTextureTransformVar, int detailVar, int detailScaleVar );

+

+	// Fixed function Self illumination pass

+	void FixedFunctionSelfIlluminationPass( Sampler_t sampler, 

+		int baseTextureVar, int frameVar, int baseTextureTransformVar, int selfIllumTintVar );

+

+	// Masked environment map

+	void FixedFunctionMaskedEnvmapPass( int envMapVar, int envMapMaskVar, 

+		int baseTextureVar, int envMapFrameVar, int envMapMaskFrameVar, 

+		int frameVar, int maskOffsetVar, int maskScaleVar, int tintVar = -1 );

+

+	// Additive masked environment map

+	void FixedFunctionAdditiveMaskedEnvmapPass( int envMapVar, int envMapMaskVar, 

+		int baseTextureVar, int envMapFrameVar, int envMapMaskFrameVar, 

+		int frameVar, int maskOffsetVar, int maskScaleVar, int tintVar = -1 );

+

+	// Modulate by detail texture pass

+	void FixedFunctionMultiplyByDetailPass( int baseTextureVar, int frameVar, 

+		int textureOffsetVar, int detailVar, int detailScaleVar );

+

+	// Multiply by lightmap pass

+	void FixedFunctionMultiplyByLightmapPass( int baseTextureVar, int frameVar, 

+		int baseTextureTransformVar, float alphaOverride = -1 );

+

+ 	// Helper methods for environment mapping

+	int SetShadowEnvMappingState( int envMapMaskVar, int tintVar = -1 );

+	void SetDynamicEnvMappingState( int envMapVar, int envMapMaskVar, 

+		int baseTextureVar, int envMapFrameVar, int envMapMaskFrameVar, 

+		int frameVar, int maskOffsetVar, int maskScaleVar, int tintVar = -1 );

+

+	bool UsingFlashlight( IMaterialVar **params ) const;

+	bool UsingEditor( IMaterialVar **params ) const;

+

+	void DrawFlashlight_dx70( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, 

+							  IShaderShadow* pShaderShadow, 

+							  int flashlightTextureVar, int flashlightTextureFrameVar, 

+							  bool suppress_lighting = false );

+

+	void SetFlashlightFixedFunctionTextureTransform( MaterialMatrixMode_t matrix );

+

+	void GetColorParameter( IMaterialVar** params, float *pColorOut ) const; // return tint color (color*color2)

+	void ApplyColor2Factor( float *pColorOut ) const;		// (*pColorOut) *= COLOR2

+

+	static IMaterialVar **s_ppParams;

+

+protected:

+	SoftwareVertexShader_t m_SoftwareVertexShader;

+

+	static const char *s_pTextureGroupName; // Current material's texture group name.

+	static IShaderShadow *s_pShaderShadow;

+	static IShaderDynamicAPI *s_pShaderAPI;

+	static IShaderInit *s_pShaderInit;

+

+private:

+	static int s_nModulationFlags;

+	static CMeshBuilder *s_pMeshBuilder;

+};

+

+

+//-----------------------------------------------------------------------------

+// Gets at the current materialvar flags

+//-----------------------------------------------------------------------------

+inline int CBaseShader::CurrentMaterialVarFlags() const

+{

+	return s_ppParams[FLAGS]->GetIntValue();

+}

+

+//-----------------------------------------------------------------------------

+// Are we currently taking a snapshot?

+//-----------------------------------------------------------------------------

+inline bool CBaseShader::IsSnapshotting() const

+{

+	return (s_pShaderShadow != NULL);

+}

+

+//-----------------------------------------------------------------------------

+// Is the color var white?

+//-----------------------------------------------------------------------------

+inline bool CBaseShader::IsWhite( int colorVar )

+{

+	if (colorVar < 0)

+		return true;

+

+	if (!s_ppParams[colorVar]->IsDefined())

+		return true;

+

+	float color[3];

+	s_ppParams[colorVar]->GetVecValue( color, 3 );

+	return (color[0] >= 1.0f) && (color[1] >= 1.0f) && (color[2] >= 1.0f);

+}

+

+

+class CBasePerMaterialContextData								// shaders can keep per material data in classes descended from this

+{

+ public:

+	uint32 m_nVarChangeID;

+	bool m_bMaterialVarsChanged;							// set by mat system when material vars change. shader should rehtink and then clear the var

+

+	FORCEINLINE CBasePerMaterialContextData( void )

+	{

+		m_bMaterialVarsChanged = true;

+		m_nVarChangeID = 0xffffffff;

+	}

+

+	// virtual destructor so that derived classes can have their own data to be cleaned up on

+	// delete of material

+	virtual ~CBasePerMaterialContextData( void )

+	{

+	}

+};

+

+#endif // BASESHADER_H

diff --git a/mp/src/public/shaderlib/ShaderDLL.h b/mp/src/public/shaderlib/ShaderDLL.h
new file mode 100644
index 00000000..31a1b1f7
--- /dev/null
+++ b/mp/src/public/shaderlib/ShaderDLL.h
@@ -0,0 +1,49 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//

+//

+// Purpose: 

+//

+// $Header: $

+// $NoKeywords: $

+//=============================================================================//

+

+#ifndef SHADERDLL_H

+#define SHADERDLL_H

+

+#ifdef _WIN32

+#pragma once

+#endif

+

+#include <materialsystem/IShader.h>

+

+//-----------------------------------------------------------------------------

+// forward declarations

+//-----------------------------------------------------------------------------

+class IShader;

+class ICvar;

+

+//-----------------------------------------------------------------------------

+// The standard implementation of CShaderDLL

+//-----------------------------------------------------------------------------

+class IShaderDLL

+{

+public:

+	// Adds a shader to the list of shaders

+	virtual void InsertShader( IShader *pShader ) = 0;

+};

+

+

+//-----------------------------------------------------------------------------

+// Singleton interface

+//-----------------------------------------------------------------------------

+IShaderDLL *GetShaderDLL();

+

+//-----------------------------------------------------------------------------

+// Singleton interface for CVars

+//-----------------------------------------------------------------------------

+ICvar *GetCVar();

+

+

+

+

+

+#endif // SHADERDLL_H

diff --git a/mp/src/public/shaderlib/cshader.h b/mp/src/public/shaderlib/cshader.h
new file mode 100644
index 00000000..16acc5de
--- /dev/null
+++ b/mp/src/public/shaderlib/cshader.h
@@ -0,0 +1,490 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//

+//

+// Purpose: 

+//

+// $NoKeywords: $

+//=============================================================================//

+

+#ifndef CSHADER_H

+#define CSHADER_H

+

+#ifdef _WIN32		   

+#pragma once

+#endif

+

+// uncomment this if you want to build for nv3x

+//#define NV3X 1

+

+// This is what all shaders include.

+// CBaseShader will become CShader in this file.

+#include "materialsystem/ishaderapi.h"

+#include "utlvector.h"

+#include "materialsystem/imaterialvar.h"

+#include "materialsystem/imaterial.h"

+#include "BaseShader.h"

+

+#include "materialsystem/itexture.h"

+

+// Included for convenience because they are used in a bunch of shaders

+#include "materialsystem/imesh.h"

+#include "materialsystem/imaterialsystemhardwareconfig.h"

+#include "materialsystem/materialsystem_config.h"

+#include "shaderlib/ShaderDLL.h"

+

+// make "local variable is initialized but not referenced" warnings errors for combo checking macros

+#pragma warning ( error : 4189 )

+

+//-----------------------------------------------------------------------------

+// Global interfaces

+//-----------------------------------------------------------------------------

+extern IMaterialSystemHardwareConfig *g_pHardwareConfig;

+extern const MaterialSystem_Config_t *g_pConfig;

+extern bool g_shaderConfigDumpEnable;

+

+// Helper method

+bool IsUsingGraphics();

+

+#define SOFTWARE_VERTEX_SHADER(name)			\

+	static void SoftwareVertexShader_ ## name( CMeshBuilder &meshBuilder, IMaterialVar **params, IShaderDynamicAPI* pShaderAPI )

+

+#define FORWARD_DECLARE_SOFTWARE_VERTEX_SHADER(name)\

+	static void SoftwareVertexShader_ ## name( CMeshBuilder &meshBuilder, IMaterialVar **params, IShaderDynamicAPI* pShaderAPI );

+

+#define USE_SOFTWARE_VERTEX_SHADER(name) \

+	m_SoftwareVertexShader = SoftwareVertexShader_ ## name

+

+#define SHADER_INIT_PARAMS()			\

+	virtual void OnInitShaderParams( IMaterialVar **params, const char *pMaterialName )

+

+#define SHADER_FALLBACK			\

+	virtual char const* GetFallbackShader( IMaterialVar** params ) const

+

+// Typesafe flag setting

+inline void CShader_SetFlags( IMaterialVar **params, MaterialVarFlags_t _flag )

+{

+	params[FLAGS]->SetIntValue( params[FLAGS]->GetIntValue() | (_flag) );

+}

+

+inline bool CShader_IsFlagSet( IMaterialVar **params, MaterialVarFlags_t _flag )

+{

+	return ((params[FLAGS]->GetIntValue() & (_flag) ) != 0);

+}

+

+#define SET_FLAGS( _flag )		CShader_SetFlags( params, _flag )

+#define CLEAR_FLAGS( _flag )	params[FLAGS]->SetIntValue( params[FLAGS]->GetIntValue() & ~(_flag) )

+#define IS_FLAG_SET( _flag )	CShader_IsFlagSet( params, _flag )

+#define IS_FLAG_DEFINED( _flag ) ((params[FLAGS_DEFINED]->GetIntValue() & (_flag) ) != 0)

+

+#define IS_PARAM_DEFINED( _param ) ( ( ( _param >= 0 ) && ( params[_param]->IsDefined() ) ) )

+

+#define SET_PARAM_STRING_IF_NOT_DEFINED( nParamIndex, kDefaultValue )     \

+	if ( ( nParamIndex != -1 ) && ( !params[nParamIndex]->IsDefined() ) ) \

+	{																	  \

+		params[nParamIndex]->SetStringValue( kDefaultValue );			  \

+	}

+

+#define SET_PARAM_INT_IF_NOT_DEFINED( nParamIndex, kDefaultValue )			\

+	if ( ( nParamIndex != -1 ) && ( !params[nParamIndex]->IsDefined() ) )	\

+	{																		\

+		params[nParamIndex]->SetIntValue( kDefaultValue );					\

+	}

+

+#define SET_PARAM_FLOAT_IF_NOT_DEFINED( nParamIndex, kDefaultValue )      \

+	if ( ( nParamIndex != -1 ) && ( !params[nParamIndex]->IsDefined() ) ) \

+	{																	  \

+		params[nParamIndex]->SetFloatValue( kDefaultValue );			  \

+	}

+

+#define SET_PARAM_VEC_IF_NOT_DEFINED( nParamIndex, kDefaultValue, nSize ) \

+	if ( ( nParamIndex != -1 ) && ( !params[nParamIndex]->IsDefined() ) ) \

+	{																	  \

+		params[nParamIndex]->SetVecValue( kDefaultValue, nSize );		  \

+	}

+

+// Typesafe flag setting

+inline void CShader_SetFlags2( IMaterialVar **params, MaterialVarFlags2_t _flag )

+{

+	params[FLAGS2]->SetIntValue( params[FLAGS2]->GetIntValue() | (_flag) );

+}

+

+inline bool CShader_IsFlag2Set( IMaterialVar **params, MaterialVarFlags2_t _flag )

+{

+	return ((params[FLAGS2]->GetIntValue() & (_flag) ) != 0);

+}

+

+#define SET_FLAGS2( _flag )		CShader_SetFlags2( params, _flag )

+#define CLEAR_FLAGS2( _flag )	params[FLAGS2]->SetIntValue( params[FLAGS2]->GetIntValue() & ~(_flag) )

+#define IS_FLAG2_SET( _flag )	CShader_IsFlag2Set( params, _flag )

+#define IS_FLAG2_DEFINED( _flag ) ((params[FLAGS_DEFINED2]->GetIntValue() & (_flag) ) != 0)

+

+#define __BEGIN_SHADER_INTERNAL(_baseclass, name, help, flags) \

+	namespace name \

+	{\

+		typedef _baseclass CBaseClass;\

+		static const char *s_HelpString = help; \

+		static const char *s_Name = #name; \

+		static int s_nFlags = flags; \

+		class CShaderParam;\

+		static CUtlVector<CShaderParam *> s_ShaderParams;\

+		static CShaderParam *s_pShaderParamOverrides[NUM_SHADER_MATERIAL_VARS];\

+		class CShaderParam\

+		{\

+		public:\

+			CShaderParam( ShaderMaterialVars_t var, ShaderParamType_t type, const char *pDefaultParam, const char *pHelp, int nFlags )\

+			{\

+				m_Info.m_pName = "override";\

+				m_Info.m_Type = type;\

+				m_Info.m_pDefaultValue = pDefaultParam;\

+				m_Info.m_pHelp = pHelp;\

+				m_Info.m_nFlags = nFlags;\

+				AssertMsg( !s_pShaderParamOverrides[var], ( "Shader parameter override duplicately defined!" ) );\

+				s_pShaderParamOverrides[var] = this;\

+				m_Index = var;\

+			}\

+			CShaderParam( const char *pName, ShaderParamType_t type, const char *pDefaultParam, const char *pHelp, int nFlags )\

+			{\

+				m_Info.m_pName = pName;\

+				m_Info.m_Type = type;\

+				m_Info.m_pDefaultValue = pDefaultParam;\

+				m_Info.m_pHelp = pHelp;\

+				m_Info.m_nFlags = nFlags;\

+				m_Index = NUM_SHADER_MATERIAL_VARS + s_ShaderParams.Count();\

+				s_ShaderParams.AddToTail( this );\

+			}\

+			operator int()	\

+			{\

+				return m_Index;\

+			}\

+			const char *GetName()\

+			{\

+				return m_Info.m_pName;\

+			}\

+			ShaderParamType_t GetType()\

+			{\

+				return m_Info.m_Type;\

+			}\

+			const char *GetDefault()\

+			{\

+				return m_Info.m_pDefaultValue;\

+			}\

+			int GetFlags() const\

+			{\

+				return m_Info.m_nFlags;\

+			}\

+			const char *GetHelp()\

+			{\

+				return m_Info.m_pHelp;\

+			}\

+		private:\

+			ShaderParamInfo_t m_Info; \

+			int m_Index;\

+		};\

+

+#define BEGIN_SHADER(name,help)	__BEGIN_SHADER_INTERNAL( CBaseShader, name, help, 0 )

+#define BEGIN_SHADER_FLAGS(name,help,flags)	__BEGIN_SHADER_INTERNAL( CBaseShader, name, help, flags )

+

+#define BEGIN_SHADER_PARAMS

+

+#define SHADER_PARAM( param, paramtype, paramdefault, paramhelp ) \

+	static CShaderParam param( "$" #param, paramtype, paramdefault, paramhelp, 0 );

+

+#define SHADER_PARAM_FLAGS( param, paramtype, paramdefault, paramhelp, flags ) \

+	static CShaderParam param( "$" #param, paramtype, paramdefault, paramhelp, flags );

+

+#define SHADER_PARAM_OVERRIDE( param, paramtype, paramdefault, paramhelp, flags ) \

+	static CShaderParam param( (ShaderMaterialVars_t) ::param, paramtype, paramdefault, paramhelp, flags );

+

+	// regarding the macro above: the "::" was added to the first argument in order to disambiguate it for GCC.

+	// for example, in cloak.cpp, this usage appears:

+	// 		SHADER_PARAM_OVERRIDE( COLOR, SHADER_PARAM_TYPE_COLOR, "{255 255 255}", "unused", SHADER_PARAM_NOT_EDITABLE )

+	// which in turn tries to ask the compiler to instantiate an object like so:

+	// 		static CShaderParam COLOR( (ShaderMaterialVars_t)COLOR, SHADER_PARAM_TYPE_COLOR, "{255 255 255}", "unused", SHADER_PARAM_NOT_EDITABLE )

+	// and GCC thinks that the reference to COLOR in the arg list is actually a reference to the object we're in the middle of making.

+	// and you get --> error: invalid cast from type ‘Cloak_DX90::CShaderParam’ to type ‘ShaderMaterialVars_t’

+	// Resolved: add the "::" so compiler knows that reference is to the enum, not to the name of the object being made.

+	

+	

+#define END_SHADER_PARAMS \

+	class CShader : public CBaseClass\

+	{\

+	public:

+			

+#define END_SHADER }; \

+	static CShader s_ShaderInstance;\

+} // namespace

+

+

+#define SHADER_INIT						\

+	char const* GetName() const			\

+	{									\

+		return s_Name;					\

+	}									\

+	int GetFlags() const				\

+	{									\

+		return s_nFlags;				\

+	}									\

+	int GetNumParams() const			\

+	{\

+		return CBaseClass::GetNumParams() + s_ShaderParams.Count();\

+	}\

+	char const* GetParamName( int param ) const \

+	{\

+		int nBaseClassParamCount = CBaseClass::GetNumParams();	\

+		if (param < nBaseClassParamCount)					\

+			return CBaseClass::GetParamName(param);			\

+		else												\

+			return s_ShaderParams[param - nBaseClassParamCount]->GetName();	\

+	}\

+	char const* GetParamHelp( int param ) const \

+	{\

+		int nBaseClassParamCount = CBaseClass::GetNumParams();	\

+		if (param < nBaseClassParamCount)						\

+		{														\

+			if ( !s_pShaderParamOverrides[param] )				\

+				return CBaseClass::GetParamHelp( param );		\

+			else												\

+				return s_pShaderParamOverrides[param]->GetHelp(); \

+		}														\

+		else													\

+			return s_ShaderParams[param - nBaseClassParamCount]->GetHelp();		\

+	}\

+	ShaderParamType_t GetParamType( int param ) const \

+	{\

+		int nBaseClassParamCount = CBaseClass::GetNumParams();	\

+		if (param < nBaseClassParamCount)				\

+			return CBaseClass::GetParamType( param ); \

+		else \

+			return s_ShaderParams[param - nBaseClassParamCount]->GetType();		\

+	}\

+	char const* GetParamDefault( int param ) const \

+	{\

+		int nBaseClassParamCount = CBaseClass::GetNumParams();	\

+		if (param < nBaseClassParamCount)						\

+		{														\

+			if ( !s_pShaderParamOverrides[param] )				\

+				return CBaseClass::GetParamDefault( param );	\

+			else												\

+				return s_pShaderParamOverrides[param]->GetDefault(); \

+		}														\

+		else													\

+			return s_ShaderParams[param - nBaseClassParamCount]->GetDefault();	\

+	}\

+	int GetParamFlags( int param ) const \

+	{\

+		int nBaseClassParamCount = CBaseClass::GetNumParams();	\

+		if (param < nBaseClassParamCount)						\

+		{														\

+			if ( !s_pShaderParamOverrides[param] )				\

+				return CBaseClass::GetParamFlags( param );		\

+			else												\

+				return s_pShaderParamOverrides[param]->GetFlags(); \

+		}														\

+		else													\

+			return s_ShaderParams[param - nBaseClassParamCount]->GetFlags(); \

+	}\

+	void OnInitShaderInstance( IMaterialVar **params, IShaderInit *pShaderInit, const char *pMaterialName )

+

+#define SHADER_DRAW \

+	void OnDrawElements( IMaterialVar **params, IShaderShadow* pShaderShadow, IShaderDynamicAPI* pShaderAPI, VertexCompressionType_t vertexCompression, CBasePerMaterialContextData **pContextDataPtr )

+

+#define SHADOW_STATE if (pShaderShadow)

+#define DYNAMIC_STATE if (pShaderAPI)

+

+#define ShaderWarning	if (pShaderShadow) Warning

+

+//-----------------------------------------------------------------------------

+// Used to easily define a shader which *always* falls back

+//-----------------------------------------------------------------------------

+#define DEFINE_FALLBACK_SHADER( _shadername, _fallbackshadername )	\

+	BEGIN_SHADER( _shadername, "" )	\

+	BEGIN_SHADER_PARAMS	\

+	END_SHADER_PARAMS \

+	SHADER_FALLBACK { return #_fallbackshadername; }	\

+	SHADER_INIT {} \

+	SHADER_DRAW {} \

+	END_SHADER

+

+

+//-----------------------------------------------------------------------------

+// Used to easily define a shader which inherits from another shader

+//-----------------------------------------------------------------------------

+

+// FIXME: There's a compiler bug preventing this from working. 

+// Maybe it'll work under VC7!

+

+//#define BEGIN_INHERITED_SHADER( name, _baseclass, help ) \

+//	namespace _baseclass \

+//	{\

+//	__BEGIN_SHADER_INTERNAL( _baseclass::CShader, name, help )

+

+//#define END_INHERITED_SHADER END_SHADER }

+

+//#define CHAIN_SHADER_INIT_PARAMS()	CBaseClass::OnInitShaderParams( params, pMaterialName )

+//#define CHAIN_SHADER_FALLBACK()	 CBaseClass::GetFallbackShader( params )

+//#define CHAIN_SHADER_INIT()	CBaseClass::OnInitShaderInstance( params, pShaderInit, pMaterialName )

+//#define CHAIN_SHADER_DRAW()	CBaseClass::OnDrawElements( params, pShaderShadow, pShaderAPI )

+

+// A dumbed-down version which does what I need now which works

+// This version doesn't allow you to do chain *anything* down to the base class

+#define BEGIN_INHERITED_SHADER_FLAGS( _name, _base, _help, _flags ) \

+	namespace _base\

+	{\

+		namespace _name\

+		{\

+			static const char *s_Name = #_name; \

+			static const char *s_HelpString = _help;\

+			static int s_nFlags = _flags;\

+			class CShader : public _base::CShader\

+			{\

+			public:\

+				char const* GetName() const			\

+				{									\

+					return s_Name;					\

+				}									\

+				int GetFlags() const				\

+				{									\

+					return s_nFlags;				\

+				}

+

+#define BEGIN_INHERITED_SHADER( _name, _base, _help ) BEGIN_INHERITED_SHADER_FLAGS( _name, _base, _help, 0 )

+#define END_INHERITED_SHADER END_SHADER }

+

+// psh ## shader is used here to generate a warning if you don't ever call SET_DYNAMIC_PIXEL_SHADER

+#define DECLARE_DYNAMIC_PIXEL_SHADER( shader ) \

+	int declaredynpixshader_ ## shader ## _missingcurlybraces = 0; \

+	declaredynpixshader_ ## shader ## _missingcurlybraces = declaredynpixshader_ ## shader ## _missingcurlybraces; \

+	shader ## _Dynamic_Index _pshIndex; \

+	int psh ## shader = 0

+

+// vsh ## shader is used here to generate a warning if you don't ever call SET_DYNAMIC_VERTEX_SHADER

+#define DECLARE_DYNAMIC_VERTEX_SHADER( shader ) \

+	int declaredynvertshader_ ## shader ## _missingcurlybraces = 0; \

+	declaredynvertshader_ ## shader ## _missingcurlybraces = declaredynvertshader_ ## shader ## _missingcurlybraces; \

+	shader ## _Dynamic_Index _vshIndex; \

+	int vsh ## shader = 0

+

+

+// psh ## shader is used here to generate a warning if you don't ever call SET_STATIC_PIXEL_SHADER

+#define DECLARE_STATIC_PIXEL_SHADER( shader ) \

+	int declarestaticpixshader_ ## shader ## _missingcurlybraces = 0; \

+	declarestaticpixshader_ ## shader ## _missingcurlybraces = declarestaticpixshader_ ## shader ## _missingcurlybraces; \

+	shader ## _Static_Index _pshIndex; \

+	int psh ## shader = 0

+

+// vsh ## shader is used here to generate a warning if you don't ever call SET_STATIC_VERTEX_SHADER

+#define DECLARE_STATIC_VERTEX_SHADER( shader ) \

+	int declarestaticvertshader_ ## shader ## _missingcurlybraces = 0; \

+	declarestaticvertshader_ ## shader ## _missingcurlybraces = declarestaticvertshader_ ## shader ## _missingcurlybraces; \

+	shader ## _Static_Index _vshIndex; \

+	int vsh ## shader = 0

+

+

+// psh_forgot_to_set_dynamic_ ## var is used to make sure that you set all

+// all combos.  If you don't, you will get an undefined variable used error 

+// in the SET_DYNAMIC_PIXEL_SHADER block.

+#define SET_DYNAMIC_PIXEL_SHADER_COMBO( var, val ) \

+	int dynpixshadercombo_ ## var ## _missingcurlybraces = 0; \

+	dynpixshadercombo_ ## var ## _missingcurlybraces = dynpixshadercombo_ ## var ## _missingcurlybraces; \

+	_pshIndex.Set ## var( ( val ) );  if(g_shaderConfigDumpEnable){printf("\n   PS dyn  var %s = %d (%s)", #var, (int) val, #val );}; \

+	int psh_forgot_to_set_dynamic_ ## var = 0

+

+// vsh_forgot_to_set_dynamic_ ## var is used to make sure that you set all

+// all combos.  If you don't, you will get an undefined variable used error 

+// in the SET_DYNAMIC_VERTEX_SHADER block.

+#define SET_DYNAMIC_VERTEX_SHADER_COMBO( var, val ) \

+	int dynvertshadercombo_ ## var ## _missingcurlybraces = 0; \

+	dynvertshadercombo_ ## var ## _missingcurlybraces = dynvertshadercombo_ ## var ## _missingcurlybraces; \

+	_vshIndex.Set ## var( ( val ) );  if(g_shaderConfigDumpEnable){printf("\n   VS dyn  var %s = %d (%s)", #var, (int) val, #val );}; \

+	int vsh_forgot_to_set_dynamic_ ## var = 0

+

+

+// psh_forgot_to_set_static_ ## var is used to make sure that you set all

+// all combos.  If you don't, you will get an undefined variable used error 

+// in the SET_STATIC_PIXEL_SHADER block.

+#define SET_STATIC_PIXEL_SHADER_COMBO( var, val ) \

+	int staticpixshadercombo_ ## var ## _missingcurlybraces = 0; \

+	staticpixshadercombo_ ## var ## _missingcurlybraces = staticpixshadercombo_ ## var ## _missingcurlybraces; \

+	_pshIndex.Set ## var( ( val ) ); if(g_shaderConfigDumpEnable){printf("\n   PS stat var %s = %d (%s)", #var, (int) val, #val );}; \

+	int psh_forgot_to_set_static_ ## var = 0

+

+// vsh_forgot_to_set_static_ ## var is used to make sure that you set all

+// all combos.  If you don't, you will get an undefined variable used error 

+// in the SET_STATIC_VERTEX_SHADER block.

+#define SET_STATIC_VERTEX_SHADER_COMBO( var, val ) \

+	int staticvertshadercombo_ ## var ## _missingcurlybraces = 0; \

+	staticvertshadercombo_ ## var ## _missingcurlybraces = staticvertshadercombo_ ## var ## _missingcurlybraces; \

+	_vshIndex.Set ## var( ( val ) ); if(g_shaderConfigDumpEnable){printf("\n   VS stat var %s = %d (%s)", #var, (int) val, #val );}; \

+	int vsh_forgot_to_set_static_ ## var = 0

+

+

+// psh_testAllCombos adds up all of the psh_forgot_to_set_dynamic_ ## var's from 

+// SET_DYNAMIC_PIXEL_SHADER_COMBO so that an error is generated if they aren't set.

+// psh_testAllCombos is set to itself to avoid an unused variable warning.

+// psh ## shader being set to itself ensures that DECLARE_DYNAMIC_PIXEL_SHADER 

+// was called for this particular shader.

+#define SET_DYNAMIC_PIXEL_SHADER( shader ) \

+	int dynamicpixshader_ ## shader ## _missingcurlybraces = 0; \

+	dynamicpixshader_ ## shader ## _missingcurlybraces = dynamicpixshader_ ## shader ## _missingcurlybraces; \

+	int psh_testAllCombos = shaderDynamicTest_ ## shader; \

+	psh_testAllCombos = psh_testAllCombos; \

+	psh ## shader = psh ## shader; \

+	pShaderAPI->SetPixelShaderIndex( _pshIndex.GetIndex() )

+

+#define SET_DYNAMIC_PIXEL_SHADER_CMD( cmdstream, shader ) \

+	int dynamicpixshader_ ## shader ## _missingcurlybraces = 0; \

+	dynamicpixshader_ ## shader ## _missingcurlybraces = dynamicpixshader_ ## shader ## _missingcurlybraces; \

+	int psh_testAllCombos = shaderDynamicTest_ ## shader; \

+	psh_testAllCombos = psh_testAllCombos; \

+	psh ## shader = psh ## shader; \

+	cmdstream.SetPixelShaderIndex( _pshIndex.GetIndex() )

+

+

+// vsh_testAllCombos adds up all of the vsh_forgot_to_set_dynamic_ ## var's from 

+// SET_DYNAMIC_VERTEX_SHADER_COMBO so that an error is generated if they aren't set.

+// vsh_testAllCombos is set to itself to avoid an unused variable warning.

+// vsh ## shader being set to itself ensures that DECLARE_DYNAMIC_VERTEX_SHADER 

+// was called for this particular shader.

+#define SET_DYNAMIC_VERTEX_SHADER( shader ) \

+	int dynamicvertshader_ ## shader ## _missingcurlybraces = 0; \

+	dynamicvertshader_ ## shader ## _missingcurlybraces = dynamicvertshader_ ## shader ## _missingcurlybraces; \

+	int vsh_testAllCombos = shaderDynamicTest_ ## shader; \

+	vsh_testAllCombos = vsh_testAllCombos; \

+	vsh ## shader = vsh ## shader; \

+	pShaderAPI->SetVertexShaderIndex( _vshIndex.GetIndex() )

+

+#define SET_DYNAMIC_VERTEX_SHADER_CMD( cmdstream, shader ) \

+	int dynamicvertshader_ ## shader ## _missingcurlybraces = 0; \

+	dynamicvertshader_ ## shader ## _missingcurlybraces = dynamicvertshader_ ## shader ## _missingcurlybraces; \

+	int vsh_testAllCombos = shaderDynamicTest_ ## shader; \

+	vsh_testAllCombos = vsh_testAllCombos; \

+	vsh ## shader = vsh ## shader; \

+	cmdstream.SetVertexShaderIndex( _vshIndex.GetIndex() )

+

+

+// psh_testAllCombos adds up all of the psh_forgot_to_set_static_ ## var's from 

+// SET_STATIC_PIXEL_SHADER_COMBO so that an error is generated if they aren't set.

+// psh_testAllCombos is set to itself to avoid an unused variable warning.

+// psh ## shader being set to itself ensures that DECLARE_STATIC_PIXEL_SHADER 

+// was called for this particular shader.

+#define SET_STATIC_PIXEL_SHADER( shader ) \

+	int staticpixshader_ ## shader ## _missingcurlybraces = 0; \

+	staticpixshader_ ## shader ## _missingcurlybraces = staticpixshader_ ## shader ## _missingcurlybraces; \

+	int psh_testAllCombos = shaderStaticTest_ ## shader; \

+	psh_testAllCombos = psh_testAllCombos; \

+	psh ## shader = psh ## shader; \

+	pShaderShadow->SetPixelShader( #shader, _pshIndex.GetIndex() )

+

+// vsh_testAllCombos adds up all of the vsh_forgot_to_set_static_ ## var's from 

+// SET_STATIC_VERTEX_SHADER_COMBO so that an error is generated if they aren't set.

+// vsh_testAllCombos is set to itself to avoid an unused variable warning.

+// vsh ## shader being set to itself ensures that DECLARE_STATIC_VERTEX_SHADER 

+// was called for this particular shader.

+#define SET_STATIC_VERTEX_SHADER( shader ) \

+	int staticvertshader_ ## shader ## _missingcurlybraces = 0; \

+	staticvertshader_ ## shader ## _missingcurlybraces = staticvertshader_ ## shader ## _missingcurlybraces; \

+	int vsh_testAllCombos = shaderStaticTest_ ## shader; \

+	vsh_testAllCombos = vsh_testAllCombos; \

+	vsh ## shader = vsh ## shader; \

+	pShaderShadow->SetVertexShader( #shader, _vshIndex.GetIndex() )

+

+#endif // CSHADER_H