diff options
Diffstat (limited to 'public/shaderlib')
| -rw-r--r-- | public/shaderlib/BaseShader.h | 341 | ||||
| -rw-r--r-- | public/shaderlib/ShaderDLL.h | 49 | ||||
| -rw-r--r-- | public/shaderlib/cshader.h | 492 |
3 files changed, 882 insertions, 0 deletions
diff --git a/public/shaderlib/BaseShader.h b/public/shaderlib/BaseShader.h new file mode 100644 index 0000000..6119183 --- /dev/null +++ b/public/shaderlib/BaseShader.h @@ -0,0 +1,341 @@ +//========= 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 ); + + void GetTextureDimensions( float* pOutWidth, float* pOutHeight, int nTextureVar ); + + // 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/public/shaderlib/ShaderDLL.h b/public/shaderlib/ShaderDLL.h new file mode 100644 index 0000000..69520d9 --- /dev/null +++ b/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/public/shaderlib/cshader.h b/public/shaderlib/cshader.h new file mode 100644 index 0000000..9c693638 --- /dev/null +++ b/public/shaderlib/cshader.h @@ -0,0 +1,492 @@ +//========= 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; \ + NOTE_UNUSED( 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; \ + NOTE_UNUSED( 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; \ + NOTE_UNUSED( 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; \ + NOTE_UNUSED( 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; \ + NOTE_UNUSED( 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; \ + NOTE_UNUSED( 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; \ + NOTE_UNUSED( 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; \ + NOTE_UNUSED( 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; \ + NOTE_UNUSED( dynamicpixshader_ ## shader ## _missingcurlybraces ); \ + int psh_testAllCombos = shaderDynamicTest_ ## shader; \ + NOTE_UNUSED( psh_testAllCombos ); \ + NOTE_UNUSED( psh ## shader ); \ + pShaderAPI->SetPixelShaderIndex( _pshIndex.GetIndex() ) + +#define SET_DYNAMIC_PIXEL_SHADER_CMD( cmdstream, shader ) \ + int dynamicpixshader_ ## shader ## _missingcurlybraces = 0; \ + NOTE_UNUSED( dynamicpixshader_ ## shader ## _missingcurlybraces ); \ + int psh_testAllCombos = shaderDynamicTest_ ## shader; \ + NOTE_UNUSED( psh_testAllCombos ); \ + NOTE_UNUSED( 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; \ + NOTE_UNUSED( dynamicvertshader_ ## shader ## _missingcurlybraces ); \ + int vsh_testAllCombos = shaderDynamicTest_ ## shader; \ + NOTE_UNUSED( vsh_testAllCombos ); \ + NOTE_UNUSED( vsh ## shader ); \ + pShaderAPI->SetVertexShaderIndex( _vshIndex.GetIndex() ) + +#define SET_DYNAMIC_VERTEX_SHADER_CMD( cmdstream, shader ) \ + int dynamicvertshader_ ## shader ## _missingcurlybraces = 0; \ + NOTE_UNUSED( dynamicvertshader_ ## shader ## _missingcurlybraces ); \ + int vsh_testAllCombos = shaderDynamicTest_ ## shader; \ + NOTE_UNUSED( vsh_testAllCombos ); \ + NOTE_UNUSED( 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; \ + NOTE_UNUSED( staticpixshader_ ## shader ## _missingcurlybraces ); \ + int psh_testAllCombos = shaderStaticTest_ ## shader; \ + NOTE_UNUSED( psh_testAllCombos ); \ + NOTE_UNUSED( 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; \ + NOTE_UNUSED( staticvertshader_ ## shader ## _missingcurlybraces ); \ + int vsh_testAllCombos = shaderStaticTest_ ## shader; \ + NOTE_UNUSED( vsh_testAllCombos ); \ + NOTE_UNUSED( vsh ## shader ); \ + pShaderShadow->SetVertexShader( #shader, _vshIndex.GetIndex() ) + +#endif // CSHADER_H |