You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
412 lines
10 KiB
412 lines
10 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// Purpose: |
|
// |
|
// $NoKeywords: $ |
|
// Utility class for building command buffers into memory |
|
//===========================================================================// |
|
|
|
#ifndef COMMANDBUILDER_H |
|
#define COMMANDBUILDER_H |
|
|
|
#ifndef COMMANDBUFFER_H |
|
#include "shaderapi/commandbuffer.h" |
|
#endif |
|
|
|
#include "BaseVSShader.h" |
|
#include "shaderapi/ishaderapi.h" |
|
|
|
#ifdef _WIN32 |
|
#pragma once |
|
#endif |
|
|
|
extern ConVar my_mat_fullbright; |
|
|
|
template<int N> class CFixedCommandStorageBuffer |
|
{ |
|
public: |
|
uint8 m_Data[N]; |
|
|
|
uint8 *m_pDataOut; |
|
#ifdef DBGFLAG_ASSERT |
|
size_t m_nNumBytesRemaining; |
|
#endif |
|
|
|
FORCEINLINE CFixedCommandStorageBuffer( void ) |
|
{ |
|
m_pDataOut = m_Data; |
|
#ifdef DBGFLAG_ASSERT |
|
m_nNumBytesRemaining = N; |
|
#endif |
|
|
|
} |
|
|
|
FORCEINLINE void EnsureCapacity( size_t sz ) |
|
{ |
|
Assert( m_nNumBytesRemaining >= sz ); |
|
} |
|
|
|
template<class T> FORCEINLINE void Put( T const &nValue ) |
|
{ |
|
EnsureCapacity( sizeof( T ) ); |
|
*( reinterpret_cast<T *>( m_pDataOut ) ) = nValue; |
|
m_pDataOut += sizeof( nValue ); |
|
#ifdef DBGFLAG_ASSERT |
|
m_nNumBytesRemaining -= sizeof( nValue ); |
|
#endif |
|
} |
|
|
|
FORCEINLINE void PutInt( int nValue ) |
|
{ |
|
Put( nValue ); |
|
} |
|
|
|
FORCEINLINE void PutIntPtr( intp nValue ) |
|
{ |
|
Put( nValue ); |
|
} |
|
|
|
FORCEINLINE void PutFloat( float nValue ) |
|
{ |
|
Put( nValue ); |
|
} |
|
|
|
FORCEINLINE void PutPtr( void * pPtr ) |
|
{ |
|
Put( pPtr ); |
|
} |
|
|
|
FORCEINLINE void PutMemory( const void *pMemory, size_t nBytes ) |
|
{ |
|
EnsureCapacity( nBytes ); |
|
memcpy( m_pDataOut, pMemory, nBytes ); |
|
m_pDataOut += nBytes; |
|
} |
|
|
|
FORCEINLINE uint8 *Base( void ) |
|
{ |
|
return m_Data; |
|
} |
|
|
|
FORCEINLINE void Reset( void ) |
|
{ |
|
m_pDataOut = m_Data; |
|
#ifdef DBGFLAG_ASSERT |
|
m_nNumBytesRemaining = N; |
|
#endif |
|
} |
|
|
|
FORCEINLINE size_t Size( void ) const |
|
{ |
|
return m_pDataOut - m_Data; |
|
} |
|
|
|
}; |
|
|
|
template<class S> class CCommandBufferBuilder |
|
{ |
|
public: |
|
S m_Storage; |
|
|
|
FORCEINLINE void End( void ) |
|
{ |
|
m_Storage.PutInt( CBCMD_END ); |
|
} |
|
|
|
|
|
FORCEINLINE IMaterialVar *Param( int nVar ) const |
|
{ |
|
return CBaseShader::s_ppParams[nVar]; |
|
} |
|
|
|
FORCEINLINE void SetPixelShaderConstants( int nFirstConstant, int nConstants ) |
|
{ |
|
m_Storage.PutInt( CBCMD_SET_PIXEL_SHADER_FLOAT_CONST ); |
|
m_Storage.PutInt( nFirstConstant ); |
|
m_Storage.PutInt( nConstants ); |
|
} |
|
|
|
FORCEINLINE void OutputConstantData( float const *pSrcData ) |
|
{ |
|
m_Storage.PutFloat( pSrcData[0] ); |
|
m_Storage.PutFloat( pSrcData[1] ); |
|
m_Storage.PutFloat( pSrcData[2] ); |
|
m_Storage.PutFloat( pSrcData[3] ); |
|
} |
|
|
|
FORCEINLINE void OutputConstantData4( float flVal0, float flVal1, float flVal2, float flVal3 ) |
|
{ |
|
m_Storage.PutFloat( flVal0 ); |
|
m_Storage.PutFloat( flVal1 ); |
|
m_Storage.PutFloat( flVal2 ); |
|
m_Storage.PutFloat( flVal3 ); |
|
} |
|
|
|
FORCEINLINE void SetPixelShaderConstant( int nFirstConstant, float const *pSrcData, int nNumConstantsToSet ) |
|
{ |
|
SetPixelShaderConstants( nFirstConstant, nNumConstantsToSet ); |
|
m_Storage.PutMemory( pSrcData, 4 * sizeof( float ) * nNumConstantsToSet ); |
|
} |
|
|
|
FORCEINLINE void SetPixelShaderConstant( int nFirstConstant, int nVar ) |
|
{ |
|
SetPixelShaderConstant( nFirstConstant, Param( nVar )->GetVecValue() ); |
|
} |
|
|
|
void SetPixelShaderConstantGammaToLinear( int pixelReg, int constantVar ) |
|
{ |
|
float val[4]; |
|
Param(constantVar)->GetVecValue( val, 3 ); |
|
val[0] = val[0] > 1.0f ? val[0] : GammaToLinear( val[0] ); |
|
val[1] = val[1] > 1.0f ? val[1] : GammaToLinear( val[1] ); |
|
val[2] = val[2] > 1.0f ? val[2] : GammaToLinear( val[2] ); |
|
val[3] = 1.0; |
|
SetPixelShaderConstant( pixelReg, val ); |
|
} |
|
|
|
FORCEINLINE void SetPixelShaderConstant( int nFirstConstant, float const *pSrcData ) |
|
{ |
|
SetPixelShaderConstants( nFirstConstant, 1 ); |
|
OutputConstantData( pSrcData ); |
|
} |
|
|
|
FORCEINLINE void SetPixelShaderConstant4( int nFirstConstant, float flVal0, float flVal1, float flVal2, float flVal3 ) |
|
{ |
|
SetPixelShaderConstants( nFirstConstant, 1 ); |
|
OutputConstantData4( flVal0, flVal1, flVal2, flVal3 ); |
|
} |
|
|
|
FORCEINLINE void SetPixelShaderConstant_W( int pixelReg, int constantVar, float fWValue ) |
|
{ |
|
if ( constantVar != -1 ) |
|
{ |
|
float val[3]; |
|
Param(constantVar)->GetVecValue( val, 3); |
|
SetPixelShaderConstant4( pixelReg, val[0], val[1], val[2], fWValue ); |
|
} |
|
} |
|
|
|
FORCEINLINE void SetVertexShaderConstant( int nFirstConstant, float const *pSrcData ) |
|
{ |
|
m_Storage.PutInt( CBCMD_SET_VERTEX_SHADER_FLOAT_CONST ); |
|
m_Storage.PutInt( nFirstConstant ); |
|
m_Storage.PutInt( 1 ); |
|
OutputConstantData( pSrcData ); |
|
} |
|
|
|
FORCEINLINE void SetVertexShaderConstant( int nFirstConstant, float const *pSrcData, int nConsts ) |
|
{ |
|
m_Storage.PutInt( CBCMD_SET_VERTEX_SHADER_FLOAT_CONST ); |
|
m_Storage.PutInt( nFirstConstant ); |
|
m_Storage.PutInt( nConsts ); |
|
m_Storage.PutMemory( pSrcData, 4 * nConsts * sizeof( float ) ); |
|
} |
|
|
|
|
|
FORCEINLINE void SetVertexShaderConstant4( int nFirstConstant, float flVal0, float flVal1, float flVal2, float flVal3 ) |
|
{ |
|
m_Storage.PutInt( CBCMD_SET_VERTEX_SHADER_FLOAT_CONST ); |
|
m_Storage.PutInt( nFirstConstant ); |
|
m_Storage.PutInt( 1 ); |
|
m_Storage.PutFloat( flVal0 ); |
|
m_Storage.PutFloat( flVal1 ); |
|
m_Storage.PutFloat( flVal2 ); |
|
m_Storage.PutFloat( flVal3 ); |
|
} |
|
|
|
void SetVertexShaderTextureTransform( int vertexReg, int transformVar ) |
|
{ |
|
Vector4D transformation[2]; |
|
IMaterialVar* pTransformationVar = Param( transformVar ); |
|
if (pTransformationVar && (pTransformationVar->GetType() == MATERIAL_VAR_TYPE_MATRIX)) |
|
{ |
|
const VMatrix &mat = pTransformationVar->GetMatrixValue(); |
|
transformation[0].Init( mat[0][0], mat[0][1], mat[0][2], mat[0][3] ); |
|
transformation[1].Init( mat[1][0], mat[1][1], mat[1][2], mat[1][3] ); |
|
} |
|
else |
|
{ |
|
transformation[0].Init( 1.0f, 0.0f, 0.0f, 0.0f ); |
|
transformation[1].Init( 0.0f, 1.0f, 0.0f, 0.0f ); |
|
} |
|
SetVertexShaderConstant( vertexReg, transformation[0].Base(), 2 ); |
|
} |
|
|
|
|
|
void SetVertexShaderTextureScaledTransform( int vertexReg, int transformVar, int scaleVar ) |
|
{ |
|
Vector4D transformation[2]; |
|
IMaterialVar* pTransformationVar = Param( transformVar ); |
|
if (pTransformationVar && (pTransformationVar->GetType() == MATERIAL_VAR_TYPE_MATRIX)) |
|
{ |
|
const VMatrix &mat = pTransformationVar->GetMatrixValue(); |
|
transformation[0].Init( mat[0][0], mat[0][1], mat[0][2], mat[0][3] ); |
|
transformation[1].Init( mat[1][0], mat[1][1], mat[1][2], mat[1][3] ); |
|
} |
|
else |
|
{ |
|
transformation[0].Init( 1.0f, 0.0f, 0.0f, 0.0f ); |
|
transformation[1].Init( 0.0f, 1.0f, 0.0f, 0.0f ); |
|
} |
|
|
|
Vector2D scale( 1, 1 ); |
|
IMaterialVar* pScaleVar = Param( scaleVar ); |
|
if (pScaleVar) |
|
{ |
|
if (pScaleVar->GetType() == MATERIAL_VAR_TYPE_VECTOR) |
|
pScaleVar->GetVecValue( scale.Base(), 2 ); |
|
else if (pScaleVar->IsDefined()) |
|
scale[0] = scale[1] = pScaleVar->GetFloatValue(); |
|
} |
|
|
|
// Apply the scaling |
|
transformation[0][0] *= scale[0]; |
|
transformation[0][1] *= scale[1]; |
|
transformation[1][0] *= scale[0]; |
|
transformation[1][1] *= scale[1]; |
|
transformation[0][3] *= scale[0]; |
|
transformation[1][3] *= scale[1]; |
|
SetVertexShaderConstant( vertexReg, transformation[0].Base(), 2 ); |
|
} |
|
|
|
FORCEINLINE void SetEnvMapTintPixelShaderDynamicState( int pixelReg, int tintVar ) |
|
{ |
|
if( g_pConfig->bShowSpecular && my_mat_fullbright.GetInt() != 2 ) |
|
{ |
|
SetPixelShaderConstant( pixelReg, Param( tintVar)->GetVecValue() ); |
|
} |
|
else |
|
{ |
|
SetPixelShaderConstant4( pixelReg, 0.0, 0.0, 0.0, 0.0 ); |
|
} |
|
} |
|
|
|
FORCEINLINE void SetEnvMapTintPixelShaderDynamicStateGammaToLinear( int pixelReg, int tintVar, float flAlphaValue = 1.0 ) |
|
{ |
|
if( ( tintVar != -1 ) && g_pConfig->bShowSpecular && my_mat_fullbright.GetInt() != 2 ) |
|
{ |
|
float color[4]; |
|
color[3] = flAlphaValue; |
|
Param( tintVar)->GetLinearVecValue( color, 3 ); |
|
SetPixelShaderConstant( pixelReg, color ); |
|
} |
|
else |
|
{ |
|
SetPixelShaderConstant4( pixelReg, 0.0, 0.0, 0.0, flAlphaValue ); |
|
} |
|
} |
|
|
|
FORCEINLINE void StoreEyePosInPixelShaderConstant( int nConst ) |
|
{ |
|
m_Storage.PutInt( CBCMD_STORE_EYE_POS_IN_PSCONST ); |
|
m_Storage.PutInt( nConst ); |
|
} |
|
|
|
FORCEINLINE void CommitPixelShaderLighting( int nConst ) |
|
{ |
|
m_Storage.PutInt( CBCMD_COMMITPIXELSHADERLIGHTING ); |
|
m_Storage.PutInt( nConst ); |
|
} |
|
|
|
FORCEINLINE void SetPixelShaderStateAmbientLightCube( int nConst ) |
|
{ |
|
m_Storage.PutInt( CBCMD_SETPIXELSHADERSTATEAMBIENTLIGHTCUBE ); |
|
m_Storage.PutInt( nConst ); |
|
} |
|
|
|
FORCEINLINE void SetAmbientCubeDynamicStateVertexShader( void ) |
|
{ |
|
m_Storage.PutInt( CBCMD_SETAMBIENTCUBEDYNAMICSTATEVERTEXSHADER ); |
|
} |
|
|
|
FORCEINLINE void SetPixelShaderFogParams( int nReg ) |
|
{ |
|
m_Storage.PutInt( CBCMD_SETPIXELSHADERFOGPARAMS ); |
|
m_Storage.PutInt( nReg ); |
|
} |
|
|
|
FORCEINLINE void BindStandardTexture( Sampler_t nSampler, StandardTextureId_t nTextureId ) |
|
{ |
|
m_Storage.PutInt( CBCMD_BIND_STANDARD_TEXTURE ); |
|
m_Storage.PutInt( nSampler ); |
|
m_Storage.PutInt( nTextureId ); |
|
} |
|
|
|
|
|
FORCEINLINE void BindTexture( Sampler_t nSampler, ShaderAPITextureHandle_t hTexture ) |
|
{ |
|
Assert( hTexture != INVALID_SHADERAPI_TEXTURE_HANDLE ); |
|
if ( hTexture != INVALID_SHADERAPI_TEXTURE_HANDLE ) |
|
{ |
|
m_Storage.PutInt( CBCMD_BIND_SHADERAPI_TEXTURE_HANDLE ); |
|
m_Storage.PutInt( nSampler ); |
|
m_Storage.PutIntPtr( hTexture ); |
|
} |
|
} |
|
|
|
FORCEINLINE void BindTexture( CBaseVSShader *pShader, Sampler_t nSampler, int nTextureVar, int nFrameVar ) |
|
{ |
|
ShaderAPITextureHandle_t hTexture = pShader->GetShaderAPITextureBindHandle( nTextureVar, nFrameVar ); |
|
BindTexture( nSampler, hTexture ); |
|
} |
|
|
|
FORCEINLINE void BindMultiTexture( CBaseVSShader *pShader, Sampler_t nSampler1, Sampler_t nSampler2, int nTextureVar, int nFrameVar ) |
|
{ |
|
ShaderAPITextureHandle_t hTexture = pShader->GetShaderAPITextureBindHandle( nTextureVar, nFrameVar, 0 ); |
|
BindTexture( nSampler1, hTexture ); |
|
hTexture = pShader->GetShaderAPITextureBindHandle( nTextureVar, nFrameVar, 1 ); |
|
BindTexture( nSampler2, hTexture ); |
|
} |
|
|
|
FORCEINLINE void SetPixelShaderIndex( int nIndex ) |
|
{ |
|
m_Storage.PutInt( CBCMD_SET_PSHINDEX ); |
|
m_Storage.PutInt( nIndex ); |
|
} |
|
|
|
FORCEINLINE void SetVertexShaderIndex( int nIndex ) |
|
{ |
|
m_Storage.PutInt( CBCMD_SET_VSHINDEX ); |
|
m_Storage.PutInt( nIndex ); |
|
} |
|
|
|
FORCEINLINE void SetDepthFeatheringPixelShaderConstant( int iConstant, float fDepthBlendScale ) |
|
{ |
|
m_Storage.PutInt( CBCMD_SET_DEPTH_FEATHERING_CONST ); |
|
m_Storage.PutInt( iConstant ); |
|
m_Storage.PutFloat( fDepthBlendScale ); |
|
} |
|
|
|
FORCEINLINE void Goto( uint8 *pCmdBuf ) |
|
{ |
|
m_Storage.PutInt( CBCMD_JUMP ); |
|
m_Storage.PutPtr( pCmdBuf ); |
|
} |
|
|
|
FORCEINLINE void Call( uint8 *pCmdBuf ) |
|
{ |
|
m_Storage.PutInt( CBCMD_JSR ); |
|
m_Storage.PutPtr( pCmdBuf ); |
|
} |
|
|
|
FORCEINLINE void Reset( void ) |
|
{ |
|
m_Storage.Reset(); |
|
} |
|
|
|
FORCEINLINE size_t Size( void ) const |
|
{ |
|
return m_Storage.Size(); |
|
} |
|
|
|
FORCEINLINE uint8 *Base( void ) |
|
{ |
|
return m_Storage.Base(); |
|
} |
|
|
|
|
|
|
|
}; |
|
|
|
|
|
#endif // commandbuilder_h
|
|
|