d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
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.
387 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: af8c358ce9
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'af8c358ce9'
${ noResults }
source-engine/materialsystem/stdshaders/compositor.cpp

455 lines
18 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================
#include "BaseVSShader.h"
#include "compositor_ps20.inc"
#include "compositor_ps20b.inc"
#include "materialsystem/combineoperations.h"
#include "tier0/memdbgon.h"
struct CompositorInfo_t
{
static const int cTextureCount = 4;
static const int cSelectorCount = 16;
CompositorInfo_t( ) { memset( this, -1, sizeof( *this ) ); }
int m_nCombineMode;
int m_nTextureInputCount;
int m_nTexTransform[ cTextureCount ];
int m_nTexAdjustLevels[ cTextureCount ];
int m_nSrcTexture[ cTextureCount ];
int m_nSelector[ cSelectorCount ];
int m_nTexturesPerPass;
int m_bDebug;
};
#ifdef STAGING_ONLY
ConVar r_texcomp_debug_stickers( "r_texcomp_debug_stickers", "0" );
#endif
static void DrawCompositorStage_ps20( CBaseVSShader *pShader, IMaterialVar **params, IShaderShadow* pShaderShadow, IShaderDynamicAPI* pShaderAPI, VertexCompressionType_t vertexCompression, const CompositorInfo_t &info );
static void DrawCompositorStage_ps20b( CBaseVSShader *pShader, IMaterialVar **params, IShaderShadow* pShaderShadow, IShaderDynamicAPI* pShaderAPI, VertexCompressionType_t vertexCompression, const CompositorInfo_t &info );
BEGIN_VS_SHADER( Compositor, "Help for Compositor" )
BEGIN_SHADER_PARAMS
SHADER_PARAM( COMBINE_MODE, SHADER_PARAM_TYPE_INTEGER, "", "Which mode should the combiner operate in? 0: Mul, 1: Add, 2: Lerp, 3: Select" )
SHADER_PARAM( TEXTUREINPUTCOUNT, SHADER_PARAM_TYPE_INTEGER, "", "" )
SHADER_PARAM( TEXTRANSFORM0, SHADER_PARAM_TYPE_MATRIX4X2, "", "" )
SHADER_PARAM( TEXTRANSFORM1, SHADER_PARAM_TYPE_MATRIX4X2, "", "" )
SHADER_PARAM( TEXTRANSFORM2, SHADER_PARAM_TYPE_MATRIX4X2, "", "" )
SHADER_PARAM( TEXTRANSFORM3, SHADER_PARAM_TYPE_MATRIX4X2, "", "" )
SHADER_PARAM( TEXADJUSTLEVELS0, SHADER_PARAM_TYPE_VEC3, "", "" )
SHADER_PARAM( TEXADJUSTLEVELS1, SHADER_PARAM_TYPE_VEC3, "", "" )
SHADER_PARAM( TEXADJUSTLEVELS2, SHADER_PARAM_TYPE_VEC3, "", "" )
SHADER_PARAM( TEXADJUSTLEVELS3, SHADER_PARAM_TYPE_VEC3, "", "" )
SHADER_PARAM( SRCTEXTURE0, SHADER_PARAM_TYPE_TEXTURE, "", "" )
SHADER_PARAM( SRCTEXTURE1, SHADER_PARAM_TYPE_TEXTURE, "", "" )
SHADER_PARAM( SRCTEXTURE2, SHADER_PARAM_TYPE_TEXTURE, "", "" )
SHADER_PARAM( SRCTEXTURE3, SHADER_PARAM_TYPE_TEXTURE, "", "" )
SHADER_PARAM( SELECTOR0, SHADER_PARAM_TYPE_INTEGER, "", "" )
SHADER_PARAM( SELECTOR1, SHADER_PARAM_TYPE_INTEGER, "", "" )
SHADER_PARAM( SELECTOR2, SHADER_PARAM_TYPE_INTEGER, "", "" )
SHADER_PARAM( SELECTOR3, SHADER_PARAM_TYPE_INTEGER, "", "" )
SHADER_PARAM( SELECTOR4, SHADER_PARAM_TYPE_INTEGER, "", "" )
SHADER_PARAM( SELECTOR5, SHADER_PARAM_TYPE_INTEGER, "", "" )
SHADER_PARAM( SELECTOR6, SHADER_PARAM_TYPE_INTEGER, "", "" )
SHADER_PARAM( SELECTOR7, SHADER_PARAM_TYPE_INTEGER, "", "" )
SHADER_PARAM( SELECTOR8, SHADER_PARAM_TYPE_INTEGER, "", "" )
SHADER_PARAM( SELECTOR9, SHADER_PARAM_TYPE_INTEGER, "", "" )
SHADER_PARAM( SELECTOR10, SHADER_PARAM_TYPE_INTEGER, "", "" )
SHADER_PARAM( SELECTOR11, SHADER_PARAM_TYPE_INTEGER, "", "" )
SHADER_PARAM( SELECTOR12, SHADER_PARAM_TYPE_INTEGER, "", "" )
SHADER_PARAM( SELECTOR13, SHADER_PARAM_TYPE_INTEGER, "", "" )
SHADER_PARAM( SELECTOR14, SHADER_PARAM_TYPE_INTEGER, "", "" )
SHADER_PARAM( SELECTOR15, SHADER_PARAM_TYPE_INTEGER, "", "" )
SHADER_PARAM( DEBUG_MODE, SHADER_PARAM_TYPE_BOOL, "", "" )
END_SHADER_PARAMS
void SetupVarsCompositorInfo( CompositorInfo_t* pOutInfo )
{
Assert( pOutInfo != NULL );
( *pOutInfo ).m_nCombineMode = COMBINE_MODE;
( *pOutInfo ).m_nTextureInputCount = TEXTUREINPUTCOUNT;
( *pOutInfo ).m_nTexTransform[ 0 ] = TEXTRANSFORM0;
( *pOutInfo ).m_nTexTransform[ 1 ] = TEXTRANSFORM1;
( *pOutInfo ).m_nTexTransform[ 2 ] = TEXTRANSFORM2;
( *pOutInfo ).m_nTexTransform[ 3 ] = TEXTRANSFORM3;
( *pOutInfo ).m_nTexAdjustLevels[ 0 ] = TEXADJUSTLEVELS0;
( *pOutInfo ).m_nTexAdjustLevels[ 1 ] = TEXADJUSTLEVELS1;
( *pOutInfo ).m_nTexAdjustLevels[ 2 ] = TEXADJUSTLEVELS2;
( *pOutInfo ).m_nTexAdjustLevels[ 3 ] = TEXADJUSTLEVELS3;
( *pOutInfo ).m_nSrcTexture[ 0 ] = SRCTEXTURE0;
( *pOutInfo ).m_nSrcTexture[ 1 ] = SRCTEXTURE1;
( *pOutInfo ).m_nSrcTexture[ 2 ] = SRCTEXTURE2;
( *pOutInfo ).m_nSrcTexture[ 3 ] = SRCTEXTURE3;
( *pOutInfo ).m_nSelector[ 0 ] = SELECTOR0;
( *pOutInfo ).m_nSelector[ 1 ] = SELECTOR1;
( *pOutInfo ).m_nSelector[ 2 ] = SELECTOR2;
( *pOutInfo ).m_nSelector[ 3 ] = SELECTOR3;
( *pOutInfo ).m_nSelector[ 4 ] = SELECTOR4;
( *pOutInfo ).m_nSelector[ 5 ] = SELECTOR5;
( *pOutInfo ).m_nSelector[ 6 ] = SELECTOR6;
( *pOutInfo ).m_nSelector[ 7 ] = SELECTOR7;
( *pOutInfo ).m_nSelector[ 8 ] = SELECTOR8;
( *pOutInfo ).m_nSelector[ 9 ] = SELECTOR9;
( *pOutInfo ).m_nSelector[ 10 ] = SELECTOR10;
( *pOutInfo ).m_nSelector[ 11 ] = SELECTOR11;
( *pOutInfo ).m_nSelector[ 12 ] = SELECTOR12;
( *pOutInfo ).m_nSelector[ 13 ] = SELECTOR13;
( *pOutInfo ).m_nSelector[ 14 ] = SELECTOR14;
( *pOutInfo ).m_nSelector[ 15 ] = SELECTOR15;
( *pOutInfo ).m_bDebug = DEBUG_MODE;
if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
( *pOutInfo).m_nTexturesPerPass = 4;
else
( *pOutInfo).m_nTexturesPerPass = 2;
}
SHADER_INIT
{
}
SHADER_FALLBACK
{
// Requires DX9 + above
if ( !g_pHardwareConfig->SupportsVertexAndPixelShaders() )
{
Assert( 0 );
return "Wireframe";
}
return 0;
}
SHADER_DRAW
{
CompositorInfo_t info;
SetupVarsCompositorInfo( &info );
if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
DrawCompositorStage_ps20b( this, params, pShaderShadow, pShaderAPI, vertexCompression, info );
else
DrawCompositorStage_ps20( this, params, pShaderShadow, pShaderAPI, vertexCompression, info );
}
END_SHADER
static void DrawCompositorStage_common( CBaseVSShader *pShader, IMaterialVar **params, IShaderShadow* pShaderShadow, IShaderDynamicAPI* pShaderAPI, VertexCompressionType_t vertexCompression, const CompositorInfo_t &info )
{
int nCombineMode = params[ info.m_nCombineMode ]->GetIntValue();
SHADOW_STATE
{
pShader->SetInitialShadowState();
// It's a quad, don't cull me bro.
pShaderShadow->EnableCulling( false );
pShaderShadow->EnablePolyOffset( SHADER_POLYOFFSET_DISABLE );
pShaderShadow->EnableDepthWrites( false );
pShaderShadow->EnableDepthTest( false );
// In 2.0b shaders, we use the skin shader and alpha carries specular mask information--
// so we need to write it
// But with 2.0 shaders used by at least one customer in 2015, we fall back to
// vertexlitgeneric and it doesn't do the same transforms as skin to the alpha shader
// Since it won't be used anyways and it breaks the item model panel icons to write alpha
// DON'T when we're running with 2.0 shaders.
pShaderShadow->EnableAlphaWrites( g_pHardwareConfig->SupportsPixelShaders_2_b() );
pShaderShadow->EnableSRGBWrite( true );
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, nCombineMode != ECO_Select );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER1, true );
int fmt = VERTEX_POSITION;
pShaderShadow->VertexShaderVertexFormat( fmt, 1, 0, 0 );
pShaderShadow->SetVertexShader( "compositor_vs20", 0 );
}
DYNAMIC_STATE
{
pShaderAPI->SetDefaultState();
pShaderAPI->SetVertexShaderIndex( 0 );
int textureCount = GetIntParam( info.m_nTextureInputCount, params );
int textureCountThisPass = Min( textureCount, info.m_nTexturesPerPass );
float f4TextureCountThisPass[] = { ( float ) textureCountThisPass, 0.0f, 0.0f, 0.0f };
Assert( ARRAYSIZE( f4TextureCountThisPass ) == 4 );
pShaderAPI->SetPixelShaderConstant( 6, f4TextureCountThisPass );
if ( textureCountThisPass > 0 ) pShader->BindTexture( SHADER_SAMPLER0, info.m_nSrcTexture[0] );
if ( textureCountThisPass > 0 ) pShader->SetVertexShaderMatrix2x4( 2, info.m_nTexTransform[0] );
if ( nCombineMode == ECO_Select )
{
static const float cFac = 1.0f / 16.0f;
float selectors[] =
{
cFac * GetIntParam( info.m_nSelector[ 0 ], params ),
cFac * GetIntParam( info.m_nSelector[ 1 ], params ),
cFac * GetIntParam( info.m_nSelector[ 2 ], params ),
cFac * GetIntParam( info.m_nSelector[ 3 ], params ),
cFac * GetIntParam( info.m_nSelector[ 4 ], params ),
cFac * GetIntParam( info.m_nSelector[ 5 ], params ),
cFac * GetIntParam( info.m_nSelector[ 6 ], params ),
cFac * GetIntParam( info.m_nSelector[ 7 ], params ),
cFac * GetIntParam( info.m_nSelector[ 8 ], params ),
cFac * GetIntParam( info.m_nSelector[ 9 ], params ),
cFac * GetIntParam( info.m_nSelector[ 10 ], params ),
cFac * GetIntParam( info.m_nSelector[ 11 ], params ),
cFac * GetIntParam( info.m_nSelector[ 12 ], params ),
cFac * GetIntParam( info.m_nSelector[ 13 ], params ),
cFac * GetIntParam( info.m_nSelector[ 14 ], params ),
cFac * GetIntParam( info.m_nSelector[ 15 ], params )
};
pShaderAPI->SetPixelShaderConstant( 7, selectors, 4 );
}
}
}
// Helper function when using ps20 and performing multiply and add operations.
static void DrawCompositorStage_ps20_muladdblend( CBaseVSShader *pShader, IMaterialVar **params, IShaderShadow* pShaderShadow, IShaderDynamicAPI* pShaderAPI, VertexCompressionType_t vertexCompression, const CompositorInfo_t &info )
{
int nCombineMode = params[ info.m_nCombineMode ]->GetIntValue();
SHADOW_STATE
{
{
DECLARE_STATIC_PIXEL_SHADER( compositor_ps20 );
SET_STATIC_PIXEL_SHADER_COMBO( COMBINE_MODE, nCombineMode );
SET_STATIC_PIXEL_SHADER( compositor_ps20 );
}
pShader->Draw();
// We can blend on top for second and subsequent writes.
pShaderShadow->EnableBlending( true );
if ( nCombineMode == ECO_Multiply )
pShaderShadow->BlendFunc( SHADER_BLEND_DST_COLOR, SHADER_BLEND_ZERO );
else
pShaderShadow->BlendFunc( SHADER_BLEND_ONE, SHADER_BLEND_ONE );
pShader->Draw();
}
DYNAMIC_STATE
{
int textureCount = GetIntParam( info.m_nTextureInputCount, params );
int textureCountThisPass = Min( textureCount, info.m_nTexturesPerPass );
Assert( textureCount > 0 ); // Valid, but would be really weird.
Assert( textureCountThisPass > 0 ); // That's bogus
if ( textureCountThisPass > 0 ) pShader->SetPixelShaderConstantGammaToLinear( 2, info.m_nTexAdjustLevels[ 0 ] );
if ( textureCountThisPass > 1 ) pShader->BindTexture( SHADER_SAMPLER1, info.m_nSrcTexture[ 1 ] );
if ( textureCountThisPass > 1 ) pShader->SetVertexShaderMatrix2x4( 4, info.m_nTexTransform[ 1 ] );
if ( textureCountThisPass > 1 ) pShader->SetPixelShaderConstantGammaToLinear( 3, info.m_nTexAdjustLevels[ 1 ] );
{
DECLARE_DYNAMIC_PIXEL_SHADER( compositor_ps20 );
SET_DYNAMIC_PIXEL_SHADER_COMBO( DEBUG_MODE, 0 );
SET_DYNAMIC_PIXEL_SHADER( compositor_ps20 );
}
pShader->Draw();
textureCountThisPass = Max( 0, textureCount - textureCountThisPass );
Assert( textureCountThisPass <= info.m_nTexturesPerPass );
float f4TextureCountThisPass[] = { (float)textureCountThisPass, 0.0f, 0.0f, 0.0f };
Assert( ARRAYSIZE( f4TextureCountThisPass ) == 4 );
pShaderAPI->SetPixelShaderConstant( 6, f4TextureCountThisPass );
if ( textureCountThisPass > 0 ) pShader->BindTexture( SHADER_SAMPLER0, info.m_nSrcTexture[ 2 ] );
if ( textureCountThisPass > 0 ) pShader->SetVertexShaderMatrix2x4( 2, info.m_nTexTransform[ 2 ] );
if ( textureCountThisPass > 0 ) pShader->SetPixelShaderConstantGammaToLinear( 2, info.m_nTexAdjustLevels[ 2 ] );
if ( textureCountThisPass > 1 ) pShader->BindTexture( SHADER_SAMPLER1, info.m_nSrcTexture[ 3 ] );
if ( textureCountThisPass > 1 ) pShader->SetVertexShaderMatrix2x4( 4, info.m_nTexTransform[ 3 ] );
if ( textureCountThisPass > 1 ) pShader->SetPixelShaderConstantGammaToLinear( 3, info.m_nTexAdjustLevels[ 3 ] );
pShader->Draw( textureCountThisPass > 0 );
}
}
// Helper function when using ps20 and performing lerp operations.
static void DrawCompositorStage_ps20_lerp( CBaseVSShader *pShader, IMaterialVar **params, IShaderShadow* pShaderShadow, IShaderDynamicAPI* pShaderAPI, VertexCompressionType_t vertexCompression, const CompositorInfo_t &info )
{
SHADOW_STATE
{
{
DECLARE_STATIC_PIXEL_SHADER( compositor_ps20 );
SET_STATIC_PIXEL_SHADER_COMBO( COMBINE_MODE, ECO_Legacy_Lerp_FirstPass );
SET_STATIC_PIXEL_SHADER( compositor_ps20 );
}
pShader->Draw();
// We can blend on top for second write.
pShaderShadow->EnableBlending( true );
pShaderShadow->BlendFunc( SHADER_BLEND_ONE, SHADER_BLEND_ONE );
{
DECLARE_STATIC_PIXEL_SHADER( compositor_ps20 );
SET_STATIC_PIXEL_SHADER_COMBO( COMBINE_MODE, ECO_Legacy_Lerp_SecondPass );
SET_STATIC_PIXEL_SHADER( compositor_ps20 );
}
pShader->Draw();
}
DYNAMIC_STATE
{
Assert( GetIntParam( info.m_nTextureInputCount, params ) == 3 );
pShader->SetPixelShaderConstantGammaToLinear( 2, info.m_nTexAdjustLevels[ 0 ] );
pShader->BindTexture( SHADER_SAMPLER1, info.m_nSrcTexture[ 2 ] );
pShader->SetVertexShaderMatrix2x4( 4, info.m_nTexTransform[ 2 ] );
pShader->SetPixelShaderConstantGammaToLinear( 3, info.m_nTexAdjustLevels[ 2 ] );
{
DECLARE_DYNAMIC_PIXEL_SHADER( compositor_ps20 );
SET_DYNAMIC_PIXEL_SHADER_COMBO( DEBUG_MODE, 0 );
SET_DYNAMIC_PIXEL_SHADER( compositor_ps20 );
}
pShader->Draw();
pShader->BindTexture( SHADER_SAMPLER0, info.m_nSrcTexture[ 1 ] );
pShader->SetVertexShaderMatrix2x4( 2, info.m_nTexTransform[ 1 ] );
pShader->SetPixelShaderConstantGammaToLinear( 2, info.m_nTexAdjustLevels[ 1 ] );
pShader->Draw();
}
}
// Helper function when using ps20 and performing lerp operations.
static void DrawCompositorStage_ps20_select( CBaseVSShader *pShader, IMaterialVar **params, IShaderShadow* pShaderShadow, IShaderDynamicAPI* pShaderAPI, VertexCompressionType_t vertexCompression, const CompositorInfo_t &info )
{
int nCombineMode = params[ info.m_nCombineMode ]->GetIntValue();
SHADOW_STATE
{
{
DECLARE_STATIC_PIXEL_SHADER( compositor_ps20 );
SET_STATIC_PIXEL_SHADER_COMBO( COMBINE_MODE, nCombineMode );
SET_STATIC_PIXEL_SHADER( compositor_ps20 );
}
pShader->Draw();
}
DYNAMIC_STATE
{
Assert( GetIntParam( info.m_nTextureInputCount, params ) == 1 );
pShader->SetPixelShaderConstantGammaToLinear( 2, info.m_nTexAdjustLevels[ 0 ] );
{
DECLARE_DYNAMIC_PIXEL_SHADER( compositor_ps20 );
SET_DYNAMIC_PIXEL_SHADER_COMBO( DEBUG_MODE, 0 );
SET_DYNAMIC_PIXEL_SHADER( compositor_ps20 );
}
pShader->Draw();
}
}
static void DrawCompositorStage_ps20( CBaseVSShader *pShader, IMaterialVar **params, IShaderShadow* pShaderShadow, IShaderDynamicAPI* pShaderAPI, VertexCompressionType_t vertexCompression, const CompositorInfo_t &info )
{
DrawCompositorStage_common( pShader, params, pShaderShadow, pShaderAPI, vertexCompression, info );
int nCombineMode = params[ info.m_nCombineMode ]->GetIntValue();
switch ( nCombineMode )
{
case ECO_Multiply:
case ECO_Add:
case ECO_Blend:
DrawCompositorStage_ps20_muladdblend( pShader, params, pShaderShadow, pShaderAPI, vertexCompression, info );
return;
case ECO_Lerp:
DrawCompositorStage_ps20_lerp( pShader, params, pShaderShadow, pShaderAPI, vertexCompression, info );
return;
case ECO_Select:
DrawCompositorStage_ps20_select( pShader, params, pShaderShadow, pShaderAPI, vertexCompression, info );
return;
default:
Assert( !"Need to update DrawCompositoreStage_ps20 with how to draw this mode." );
break;
}
}
static void DrawCompositorStage_ps20b( CBaseVSShader *pShader, IMaterialVar **params, IShaderShadow* pShaderShadow, IShaderDynamicAPI* pShaderAPI, VertexCompressionType_t vertexCompression, const CompositorInfo_t &info )
{
int nCombineMode = params[ info.m_nCombineMode ]->GetIntValue();
DrawCompositorStage_common( pShader, params, pShaderShadow, pShaderAPI, vertexCompression, info );
SHADOW_STATE
{
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER2, true );
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER3, true );
DECLARE_STATIC_PIXEL_SHADER( compositor_ps20b );
SET_STATIC_PIXEL_SHADER_COMBO( COMBINE_MODE, nCombineMode );
SET_STATIC_PIXEL_SHADER( compositor_ps20b );
pShader->Draw();
}
DYNAMIC_STATE
{
int textureCount = GetIntParam( info.m_nTextureInputCount, params );
int textureCountThisPass = Min( textureCount, info.m_nTexturesPerPass );
Assert( textureCount > 0 ); // Valid, but would be really weird.
Assert( textureCountThisPass > 0 ); // That's bogus
// Slot 0 is mostly already handled by common
if ( textureCountThisPass > 0 ) pShader->SetPixelShaderConstant( 2, info.m_nTexAdjustLevels[ 0 ] );
if ( textureCountThisPass > 1 ) pShader->BindTexture( SHADER_SAMPLER1, info.m_nSrcTexture[ 1 ] );
if ( textureCountThisPass > 1 ) pShader->SetVertexShaderMatrix2x4( 4, info.m_nTexTransform[ 1 ] );
if ( textureCountThisPass > 1 ) pShader->SetPixelShaderConstant( 3, info.m_nTexAdjustLevels[ 1 ] );
if ( textureCountThisPass > 2 ) pShader->BindTexture( SHADER_SAMPLER2, info.m_nSrcTexture[ 2 ] );
if ( textureCountThisPass > 2 ) pShader->SetVertexShaderMatrix2x4( 6, info.m_nTexTransform[ 2 ] );
if ( textureCountThisPass > 2 ) pShader->SetPixelShaderConstant( 4, info.m_nTexAdjustLevels[ 2 ] );
if ( textureCountThisPass > 3 ) pShader->BindTexture( SHADER_SAMPLER3, info.m_nSrcTexture[ 3 ] );
if ( textureCountThisPass > 3 ) pShader->SetVertexShaderMatrix2x4( 8, info.m_nTexTransform[ 3 ] );
if ( textureCountThisPass > 3 ) pShader->SetPixelShaderConstant( 5, info.m_nTexAdjustLevels[ 3 ] );
DECLARE_DYNAMIC_PIXEL_SHADER( compositor_ps20b );
#ifdef STAGING_ONLY
SET_DYNAMIC_PIXEL_SHADER_COMBO( DEBUG_MODE, r_texcomp_debug_stickers.GetBool() ? 1 : 0 );
#else
SET_DYNAMIC_PIXEL_SHADER_COMBO( DEBUG_MODE, 0 );
#endif
SET_DYNAMIC_PIXEL_SHADER( compositor_ps20b );
pShader->Draw();
}
}