//========= 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 "convar.h" #include "materialsystem/IShader.h" #include "materialsystem/imaterialsystemhardwareconfig.h" #include "materialsystem/imaterialvar.h" #include "materialsystem/ishaderapi.h" #include "shaderlib/BaseShader.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