370 lines
14 KiB
C++
370 lines
14 KiB
C++
//========= 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
|