void SetSpriteCommonDynamicState( unsigned int shaderFlags )
{
IShaderDynamicAPI *pShaderAPI = s_pShaderAPI;
bool bSRGB = s_ppParams[NOSRGB]->GetIntValue() == 0;
BindTexture( SHADER_SAMPLER0, BASETEXTURE, FRAME );
MaterialFogMode_t fogType = s_pShaderAPI->GetSceneFogMode();
int fogIndex = ( fogType == MATERIAL_FOG_LINEAR_BELOW_FOG_Z ) ? 1 : 0;
DECLARE_DYNAMIC_VERTEX_SHADER( jl_sprite_vs20 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( DOWATERFOG, fogIndex );
SET_DYNAMIC_VERTEX_SHADER( jl_sprite_vs20 );
if( g_pHardwareConfig->SupportsPixelShaders_2_b() || g_pHardwareConfig->ShouldAlwaysUseShaderModel2bShaders() ) // Always send GL down this path
{
DECLARE_DYNAMIC_PIXEL_SHADER( jl_sprite_ps20b );
SET_DYNAMIC_PIXEL_SHADER_COMBO( HDRENABLED, IsHDREnabled() );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
SET_DYNAMIC_PIXEL_SHADER( jl_sprite_ps20b );
}
else
{
DECLARE_DYNAMIC_PIXEL_SHADER( jl_sprite_ps20 );
SET_DYNAMIC_PIXEL_SHADER_COMBO( HDRENABLED, IsHDREnabled() );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
SET_DYNAMIC_PIXEL_SHADER( jl_sprite_ps20 );
}
pShaderAPI->SetPixelShaderFogParams( PSREG_FOG_PARAMS );
float vEyePos_SpecExponent[4];
pShaderAPI->GetWorldSpaceCameraPosition( vEyePos_SpecExponent );
vEyePos_SpecExponent[3] = 0.0f;
pShaderAPI->SetPixelShaderConstant( PSREG_EYEPOS_SPEC_EXPONENT, vEyePos_SpecExponent, 1 );
if( shaderFlags & SHADER_USE_CONSTANT_COLOR )
{
if ( bSRGB )
SetPixelShaderConstantGammaToLinear( 0, COLOR, ALPHA );
else
SetPixelShaderConstant( 0, COLOR, ALPHA );
}
if( IsHDREnabled() )
{
if ( bSRGB )
SetPixelShaderConstantGammaToLinear( 1, HDRCOLORSCALE );
else
SetPixelShaderConstant( 1, HDRCOLORSCALE );
}
}
void DrawUnbumpedUsingVertexShader( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow, bool bBumpedEnvMap )
{
bool hasEnvmap = params[ENVMAP]->IsTexture() && !bBumpedEnvMap;
bool hasBaseTexture = params[BASETEXTURE]->IsTexture();
bool hasVertexColor = IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR );
bool hasEnvmapCameraSpace = IS_FLAG_SET( MATERIAL_VAR_ENVMAPCAMERASPACE );
bool hasEnvmapSphere = IS_FLAG_SET( MATERIAL_VAR_ENVMAPSPHERE );
if ( hasEnvmap || hasBaseTexture || hasVertexColor || !bBumpedEnvMap )
{
SHADOW_STATE
{
// Alpha test
pShaderShadow->EnableAlphaTest( IS_FLAG_SET(MATERIAL_VAR_ALPHATEST) );
if ( params[ALPHATESTREFERENCE]->GetFloatValue() > 0.0f )
{
pShaderShadow->AlphaFunc( SHADER_ALPHAFUNC_GEQUAL, params[ALPHATESTREFERENCE]->GetFloatValue() );
}
// Base texture on stage 0
if (params[BASETEXTURE]->IsTexture())
{
pShaderShadow->EnableTexture( SHADER_SAMPLER0, true );
}
// Lightmap on stage 1
pShaderShadow->EnableTexture( SHADER_SAMPLER1, true );
int fmt = VERTEX_POSITION;
if ( hasEnvmap )
{
fmt |= VERTEX_NORMAL;
// envmap on stage 2
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
// envmapmask on stage 3
if (params[ENVMAPMASK]->IsTexture() || IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK ) )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
}
}
if (params[BASETEXTURE]->IsTexture() || bBumpedEnvMap)
{
SetDefaultBlendingShadowState( BASETEXTURE, true );
}
else
{
SetDefaultBlendingShadowState( ENVMAPMASK, false );
}
if (IS_FLAG_SET(MATERIAL_VAR_VERTEXCOLOR))
{
fmt |= VERTEX_COLOR;
}
pShaderShadow->VertexShaderVertexFormat( fmt, 2, 0, 0 );
lightmappedgeneric_vs11_Static_Index vshIndex;
vshIndex.SetDETAIL( false );
vshIndex.SetENVMAP( hasEnvmap );
vshIndex.SetENVMAPCAMERASPACE( hasEnvmap && hasEnvmapCameraSpace );
vshIndex.SetENVMAPSPHERE( hasEnvmap && hasEnvmapSphere );
vshIndex.SetVERTEXCOLOR( hasVertexColor );
pShaderShadow->SetVertexShader( "LightmappedGeneric_vs11", vshIndex.GetIndex() );
const char *pshName = GetPixelShaderName( params, bBumpedEnvMap );
pShaderShadow->SetPixelShader( pshName );
DefaultFog();
}
DYNAMIC_STATE
{
if (hasBaseTexture)
{
BindTexture( SHADER_SAMPLER0, BASETEXTURE, FRAME );
SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, BASETEXTURETRANSFORM );
}
pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_LIGHTMAP );
if ( hasEnvmap )
{
BindTexture( SHADER_SAMPLER2, ENVMAP, ENVMAPFRAME );
if (params[ENVMAPMASK]->IsTexture() || IS_FLAG_SET(MATERIAL_VAR_BASEALPHAENVMAPMASK) )
{
if (params[ENVMAPMASK]->IsTexture() )
BindTexture( SHADER_SAMPLER3, ENVMAPMASK, ENVMAPMASKFRAME );
else
BindTexture( SHADER_SAMPLER3, BASETEXTURE, FRAME );
SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, BASETEXTURETRANSFORM, ENVMAPMASKSCALE );
}
if (IS_FLAG_SET(MATERIAL_VAR_ENVMAPSPHERE) ||
IS_FLAG_SET(MATERIAL_VAR_ENVMAPCAMERASPACE))
{
LoadViewMatrixIntoVertexShaderConstant( VERTEX_SHADER_VIEWMODEL );
}
SetEnvMapTintPixelShaderDynamicState( 2, ENVMAPTINT, -1 );
}
if ( !hasEnvmap || hasBaseTexture || hasVertexColor )
{
SetModulationVertexShaderDynamicState();
}
EnablePixelShaderOverbright( 0, true, true );
SetPixelShaderConstant( 1, SELFILLUMTINT );
lightmappedgeneric_vs11_Dynamic_Index vshIndex;
vshIndex.SetDOWATERFOG( pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z );
pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() );
}
Draw();
}
inline void DrawPass( IMaterialVar **params, IShaderShadow* pShaderShadow,
IShaderDynamicAPI* pShaderAPI, int nPass, VertexCompressionType_t vertexCompression )
{
bool bIsModel = IS_FLAG_SET( MATERIAL_VAR_MODEL );
bool bHasEnvmap = params[ENVMAP]->IsTexture();
bool bHasFlowmap = params[FLOWMAP]->IsTexture();
bool bHasCoreColorTexture = params[CORECOLORTEXTURE]->IsTexture();
SHADOW_STATE
{
SetInitialShadowState( );
if( nPass == 0 )
{
// Alpha test: FIXME: shouldn't this be handled in Shader_t::SetInitialShadowState
pShaderShadow->EnableAlphaTest( IS_FLAG_SET(MATERIAL_VAR_ALPHATEST) );
}
else
{
pShaderShadow->DepthFunc( SHADER_DEPTHFUNC_EQUAL );
EnableAlphaBlending( SHADER_BLEND_ONE, SHADER_BLEND_ONE );
}
// If envmap is not specified, the alpha channel is the translucency
// (If envmap *is* specified, alpha channel is the reflection amount)
if ( params[NORMALMAP]->IsTexture() && !bHasEnvmap )
{
SetDefaultBlendingShadowState( NORMALMAP, false );
}
// source render target that contains the image that we are warping.
pShaderShadow->EnableTexture( SHADER_SAMPLER2, true );
if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_INTEGER )
{
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER2, true );
}
// normal map
pShaderShadow->EnableTexture( SHADER_SAMPLER3, true );
if( bHasEnvmap )
{
// envmap
pShaderShadow->EnableTexture( SHADER_SAMPLER4, true );
if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_INTEGER )
{
pShaderShadow->EnableSRGBRead( SHADER_SAMPLER4, true );
}
}
if( bHasFlowmap )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER6, true );
}
if( bHasCoreColorTexture )
{
pShaderShadow->EnableTexture( SHADER_SAMPLER7, true );
}
if( g_pHardwareConfig->GetHDRType() != HDR_TYPE_NONE )
{
pShaderShadow->EnableSRGBWrite( true );
}
unsigned int flags = VERTEX_POSITION | VERTEX_NORMAL;
int userDataSize = 0;
int nTexCoordCount = 1;
if( bIsModel )
{
userDataSize = 4;
}
else
{
flags |= VERTEX_TANGENT_S | VERTEX_TANGENT_T;
}
// This shader supports compressed vertices, so OR in that flag:
flags |= VERTEX_FORMAT_COMPRESSED;
pShaderShadow->VertexShaderVertexFormat( flags, nTexCoordCount, NULL, userDataSize );
DECLARE_STATIC_VERTEX_SHADER( sdk_core_vs20 );
SET_STATIC_VERTEX_SHADER_COMBO( MODEL, bIsModel );
SET_STATIC_VERTEX_SHADER( sdk_core_vs20 );
if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
DECLARE_STATIC_PIXEL_SHADER( sdk_core_ps20b );
SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, bHasEnvmap && ( nPass == 1 ) );
SET_STATIC_PIXEL_SHADER_COMBO( FLOWMAP, bHasFlowmap );
SET_STATIC_PIXEL_SHADER_COMBO( CORECOLORTEXTURE, bHasCoreColorTexture && ( nPass == 0 ) );
SET_STATIC_PIXEL_SHADER_COMBO( REFRACT, nPass == 0 );
SET_STATIC_PIXEL_SHADER( sdk_core_ps20b );
}
else
{
DECLARE_STATIC_PIXEL_SHADER( sdk_core_ps20 );
SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, bHasEnvmap && ( nPass == 1 ) );
SET_STATIC_PIXEL_SHADER_COMBO( FLOWMAP, bHasFlowmap );
SET_STATIC_PIXEL_SHADER_COMBO( CORECOLORTEXTURE, bHasCoreColorTexture && ( nPass == 0 ) );
SET_STATIC_PIXEL_SHADER_COMBO( REFRACT, nPass == 0 );
SET_STATIC_PIXEL_SHADER( sdk_core_ps20 );
}
DefaultFog();
}
DYNAMIC_STATE
{
pShaderAPI->SetDefaultState();
if ( params[BASETEXTURE]->IsTexture() )
{
BindTexture( SHADER_SAMPLER2, BASETEXTURE, FRAME );
}
else
{
pShaderAPI->BindStandardTexture( SHADER_SAMPLER2, TEXTURE_FRAME_BUFFER_FULL_TEXTURE_0 );
}
BindTexture( SHADER_SAMPLER3, NORMALMAP, BUMPFRAME );
if( bHasEnvmap )
{
BindTexture( SHADER_SAMPLER4, ENVMAP, ENVMAPFRAME );
}
if( bHasFlowmap )
{
BindTexture( SHADER_SAMPLER6, FLOWMAP, FLOWMAPFRAME );
}
if( bHasCoreColorTexture )
{
BindTexture( SHADER_SAMPLER7, CORECOLORTEXTURE, CORECOLORTEXTUREFRAME );
}
DECLARE_DYNAMIC_VERTEX_SHADER( sdk_core_vs20 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, pShaderAPI->GetCurrentNumBones() > 0 );
SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression );
SET_DYNAMIC_VERTEX_SHADER( sdk_core_vs20 );
if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
DECLARE_DYNAMIC_PIXEL_SHADER( sdk_core_ps20b );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
SET_DYNAMIC_PIXEL_SHADER( sdk_core_ps20b );
}
else
{
DECLARE_DYNAMIC_PIXEL_SHADER( sdk_core_ps20 );
SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() );
SET_DYNAMIC_PIXEL_SHADER( sdk_core_ps20 );
}
SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_1, BUMPTRANSFORM );
if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_NONE )
{
SetPixelShaderConstant( 0, ENVMAPTINT );
SetPixelShaderConstant( 1, REFRACTTINT );
}
else
{
SetPixelShaderConstantGammaToLinear( 0, ENVMAPTINT );
SetPixelShaderConstantGammaToLinear( 1, REFRACTTINT );
}
SetPixelShaderConstant( 2, ENVMAPCONTRAST );
SetPixelShaderConstant( 3, ENVMAPSATURATION );
float c5[4] = { params[REFRACTAMOUNT]->GetFloatValue(),
params[REFRACTAMOUNT]->GetFloatValue(), 0.0f, 0.0f };
pShaderAPI->SetPixelShaderConstant( 5, c5, 1 );
float eyePos[4];
s_pShaderAPI->GetWorldSpaceCameraPosition( eyePos );
s_pShaderAPI->SetPixelShaderConstant( 8, eyePos, 1 );
pShaderAPI->SetPixelShaderFogParams( 11 );
if( bHasFlowmap )
{
float curTime = pShaderAPI->CurrentTime();
float timeVec[4] = { curTime, curTime, curTime, curTime };
pShaderAPI->SetPixelShaderConstant( 6, timeVec, 1 );
SetPixelShaderConstant( 7, FLOWMAPSCROLLRATE );
SetPixelShaderConstant( 9, FLOWMAPTEXCOORDOFFSET );
}
}
Draw();
}
