//========= 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