void CBaseShader::DefaultFog( void ) { if ( CurrentMaterialVarFlags() & MATERIAL_VAR_ADDITIVE ) { FogToBlack(); } else { FogToFogColor(); } }
//----------------------------------------------------------------------------- // Fixed function Self illumination pass //----------------------------------------------------------------------------- void CBaseShader::FixedFunctionSelfIlluminationPass( TextureStage_t stage, int baseTextureVar, int frameVar, int baseTextureTransformVar, int selfIllumTintVar ) { // IMaterialVar** params = s_ppParams; if (IsSnapshotting()) { // A little setup for self illum here... SetModulationShadowState( selfIllumTintVar ); s_pShaderShadow->EnableTexGen( SHADER_TEXTURE_STAGE0, false ); s_pShaderShadow->EnableTexGen( SHADER_TEXTURE_STAGE1, false ); s_pShaderShadow->EnableAlphaTest( false ); s_pShaderShadow->EnableTexture( SHADER_TEXTURE_STAGE0, false ); s_pShaderShadow->EnableTexture( SHADER_TEXTURE_STAGE1, false ); s_pShaderShadow->EnableTexture( stage, true ); // No overbrighting s_pShaderShadow->OverbrightValue( SHADER_TEXTURE_STAGE0, 1.0f ); s_pShaderShadow->OverbrightValue( SHADER_TEXTURE_STAGE1, 1.0f ); // Don't bother with z writes here... s_pShaderShadow->EnableDepthWrites( false ); // We're always blending EnableAlphaBlending( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE_MINUS_SRC_ALPHA ); int flags = SHADER_DRAW_POSITION; if (stage == SHADER_TEXTURE_STAGE0) flags |= SHADER_DRAW_TEXCOORD0; else flags |= SHADER_DRAW_TEXCOORD1; s_pShaderShadow->DrawFlags( flags ); } else { SetFixedFunctionTextureTransform( (stage == SHADER_TEXTURE_STAGE0) ? MATERIAL_TEXTURE0 : MATERIAL_TEXTURE1, baseTextureTransformVar ); BindTexture( stage, baseTextureVar, frameVar ); // NOTE: Texture + texture offset are set from BaseTimesLightmap SetModulationDynamicState( selfIllumTintVar ); FogToFogColor(); } Draw(); }
void DrawDecal( IMaterialVar **params, IShaderDynamicAPI *pShaderAPI, IShaderShadow *pShaderShadow ) { if( IsSnapshotting() ) { // Be sure not to write to dest alpha pShaderShadow->EnableAlphaWrites( false ); pShaderShadow->EnableTexture( SHADER_SAMPLER0, true ); pShaderShadow->EnableTexture( SHADER_SAMPLER1, true ); pShaderShadow->EnableTexture( SHADER_SAMPLER2, true ); pShaderShadow->EnableTexture( SHADER_SAMPLER3, true ); SetNormalBlendingShadowState( BASETEXTURE, true ); int pTexCoords[3] = { 2, 2, 1 }; pShaderShadow->VertexShaderVertexFormat( VERTEX_POSITION | VERTEX_COLOR, 3, pTexCoords, 0 ); sdk_lightmappedgeneric_decal_Static_Index vshIndex; pShaderShadow->SetVertexShader( "SDK_LightmappedGeneric_Decal", vshIndex.GetIndex() ); pShaderShadow->SetPixelShader( "SDK_LightmappedGeneric_Decal" ); FogToFogColor(); } else { BindTexture( SHADER_SAMPLER0, BASETEXTURE, FRAME ); // Load the z^2 components of the lightmap coordinate axes only // This is (N dot basis)^2 Vector vecZValues( g_localBumpBasis[0].z, g_localBumpBasis[1].z, g_localBumpBasis[2].z ); vecZValues *= vecZValues; Vector4D basis[3]; basis[0].Init( vecZValues.x, vecZValues.x, vecZValues.x, 0.0f ); basis[1].Init( vecZValues.y, vecZValues.y, vecZValues.y, 0.0f ); basis[2].Init( vecZValues.z, vecZValues.z, vecZValues.z, 0.0f ); pShaderAPI->SetPixelShaderConstant( 0, (float*)basis, 3 ); pShaderAPI->BindStandardTexture( SHADER_SAMPLER1, TEXTURE_LIGHTMAP_BUMPED ); SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, BASETEXTURETRANSFORM ); SetModulationPixelShaderDynamicState( 3 ); sdk_lightmappedgeneric_decal_Dynamic_Index vshIndex; vshIndex.SetDOWATERFOG( pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z ); pShaderAPI->SetVertexShaderIndex( vshIndex.GetIndex() ); } Draw(); }
void DrawUsingVertexShader( IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow, VertexCompressionType_t vertexCompression ) { bool hasBump = params[BUMPMAP]->IsTexture(); BlendType_t nBlendType = EvaluateBlendRequirements( BASETEXTURE, true ); bool bFullyOpaque = (nBlendType != BT_BLENDADD) && (nBlendType != BT_BLEND) && !IS_FLAG_SET(MATERIAL_VAR_ALPHATEST); //dest alpha is free for special use SHADOW_STATE { pShaderShadow->EnableTexture( SHADER_SAMPLER0, true ); // Base map int flags = VERTEX_POSITION | VERTEX_NORMAL; int nTexCoordCount = 1; int userDataSize = 0; if ( hasBump ) { pShaderShadow->EnableTexture( SHADER_SAMPLER1, true ); // Bump map pShaderShadow->EnableTexture( SHADER_SAMPLER2, true ); // Normalization sampler for per-pixel lighting userDataSize = 4; // tangent S } // This shader supports compressed vertices, so OR in that flag: flags |= VERTEX_FORMAT_COMPRESSED; pShaderShadow->VertexShaderVertexFormat( flags, nTexCoordCount, NULL, userDataSize ); if ( hasBump ) { #ifndef _X360 if ( !g_pHardwareConfig->HasFastVertexTextures() ) #endif { DECLARE_STATIC_VERTEX_SHADER( sdk_teeth_bump_vs20 ); SET_STATIC_VERTEX_SHADER_COMBO( INTRO, params[INTRO]->GetIntValue() ? 1 : 0 ); SET_STATIC_VERTEX_SHADER( sdk_teeth_bump_vs20 ); // ps_2_b version which does phong if ( g_pHardwareConfig->SupportsPixelShaders_2_b() ) { DECLARE_STATIC_PIXEL_SHADER( sdk_teeth_bump_ps20b ); SET_STATIC_PIXEL_SHADER( sdk_teeth_bump_ps20b ); } else { DECLARE_STATIC_PIXEL_SHADER( sdk_teeth_bump_ps20 ); SET_STATIC_PIXEL_SHADER( sdk_teeth_bump_ps20 ); } } #ifndef _X360 else { // The vertex shader uses the vertex id stream SET_FLAGS2( MATERIAL_VAR2_USES_VERTEXID ); DECLARE_STATIC_VERTEX_SHADER( sdk_teeth_bump_vs30 ); SET_STATIC_VERTEX_SHADER_COMBO( INTRO, params[INTRO]->GetIntValue() ? 1 : 0 ); SET_STATIC_VERTEX_SHADER( sdk_teeth_bump_vs30 ); DECLARE_STATIC_PIXEL_SHADER( sdk_teeth_bump_ps30 ); SET_STATIC_PIXEL_SHADER( sdk_teeth_bump_ps30 ); } #endif } else { #ifndef _X360 if ( !g_pHardwareConfig->HasFastVertexTextures() ) #endif { DECLARE_STATIC_VERTEX_SHADER( sdk_teeth_vs20 ); SET_STATIC_VERTEX_SHADER_COMBO( INTRO, params[INTRO]->GetIntValue() ? 1 : 0 ); SET_STATIC_VERTEX_SHADER( sdk_teeth_vs20 ); if( g_pHardwareConfig->SupportsPixelShaders_2_b() ) { DECLARE_STATIC_PIXEL_SHADER( sdk_teeth_ps20b ); SET_STATIC_PIXEL_SHADER( sdk_teeth_ps20b ); } else { DECLARE_STATIC_PIXEL_SHADER( sdk_teeth_ps20 ); SET_STATIC_PIXEL_SHADER( sdk_teeth_ps20 ); } } #ifndef _X360 else { // The vertex shader uses the vertex id stream SET_FLAGS2( MATERIAL_VAR2_USES_VERTEXID ); DECLARE_STATIC_VERTEX_SHADER( sdk_teeth_vs30 ); SET_STATIC_VERTEX_SHADER_COMBO( INTRO, params[INTRO]->GetIntValue() ? 1 : 0 ); SET_STATIC_VERTEX_SHADER( sdk_teeth_vs30 ); DECLARE_STATIC_PIXEL_SHADER( sdk_teeth_ps30 ); SET_STATIC_PIXEL_SHADER( sdk_teeth_ps30 ); } #endif } // On DX9, do sRGB pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, true ); pShaderShadow->EnableSRGBWrite( true ); FogToFogColor(); pShaderShadow->EnableAlphaWrites( bFullyOpaque ); } DYNAMIC_STATE { BindTexture( SHADER_SAMPLER0, BASETEXTURE, FRAME ); if ( hasBump ) { BindTexture( SHADER_SAMPLER1, BUMPMAP ); } pShaderAPI->BindStandardTexture( SHADER_SAMPLER2, TEXTURE_NORMALIZATION_CUBEMAP_SIGNED ); pShaderAPI->SetPixelShaderStateAmbientLightCube( PSREG_AMBIENT_CUBE ); pShaderAPI->CommitPixelShaderLighting( PSREG_LIGHT_INFO_ARRAY ); Vector4D lighting; params[FORWARD]->GetVecValue( lighting.Base(), 3 ); lighting[3] = params[ILLUMFACTOR]->GetFloatValue(); pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, lighting.Base() ); LightState_t lightState; pShaderAPI->GetDX9LightState( &lightState ); 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 ( hasBump ) { #ifndef _X360 if ( !g_pHardwareConfig->HasFastVertexTextures() ) #endif { DECLARE_DYNAMIC_VERTEX_SHADER( sdk_teeth_bump_vs20 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( DOWATERFOG, pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z ); SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, pShaderAPI->GetCurrentNumBones() > 0 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( STATIC_LIGHT, lightState.m_bStaticLight ? 1 : 0 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression ); SET_DYNAMIC_VERTEX_SHADER( sdk_teeth_bump_vs20 ); // ps_2_b version which does Phong if ( g_pHardwareConfig->SupportsPixelShaders_2_b() ) { Vector4D vSpecExponent; vSpecExponent[3] = params[PHONGEXPONENT]->GetFloatValue(); pShaderAPI->SetPixelShaderConstant( PSREG_EYEPOS_SPEC_EXPONENT, vSpecExponent.Base(), 1 ); DECLARE_DYNAMIC_PIXEL_SHADER( sdk_teeth_bump_ps20b ); SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() ); SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_LIGHTS, lightState.m_nNumLights ); SET_DYNAMIC_PIXEL_SHADER_COMBO( AMBIENT_LIGHT, lightState.m_bAmbientLight ? 1 : 0 ); SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bFullyOpaque && pShaderAPI->ShouldWriteDepthToDestAlpha() ); SET_DYNAMIC_PIXEL_SHADER( sdk_teeth_bump_ps20b ); } else { DECLARE_DYNAMIC_PIXEL_SHADER( sdk_teeth_bump_ps20 ); SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() ); SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_LIGHTS, lightState.m_nNumLights ); SET_DYNAMIC_PIXEL_SHADER_COMBO( AMBIENT_LIGHT, lightState.m_bAmbientLight ? 1 : 0 ); SET_DYNAMIC_PIXEL_SHADER( sdk_teeth_bump_ps20 ); } } #ifndef _X360 else { SetHWMorphVertexShaderState( VERTEX_SHADER_SHADER_SPECIFIC_CONST_6, VERTEX_SHADER_SHADER_SPECIFIC_CONST_7, SHADER_VERTEXTEXTURE_SAMPLER0 ); DECLARE_DYNAMIC_VERTEX_SHADER( sdk_teeth_bump_vs30 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( DOWATERFOG, pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z ); SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, pShaderAPI->GetCurrentNumBones() > 0 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( STATIC_LIGHT, lightState.m_bStaticLight ? 1 : 0 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( MORPHING, pShaderAPI->IsHWMorphingEnabled() ); SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression ); SET_DYNAMIC_VERTEX_SHADER( sdk_teeth_bump_vs30 ); Vector4D vSpecExponent; vSpecExponent[3] = params[PHONGEXPONENT]->GetFloatValue(); pShaderAPI->SetPixelShaderConstant( PSREG_EYEPOS_SPEC_EXPONENT, vSpecExponent.Base(), 1 ); DECLARE_DYNAMIC_PIXEL_SHADER( sdk_teeth_bump_ps30 ); SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() ); SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_LIGHTS, lightState.m_nNumLights ); SET_DYNAMIC_PIXEL_SHADER_COMBO( AMBIENT_LIGHT, lightState.m_bAmbientLight ? 1 : 0 ); SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bFullyOpaque && pShaderAPI->ShouldWriteDepthToDestAlpha() ); SET_DYNAMIC_PIXEL_SHADER( sdk_teeth_bump_ps30 ); } #endif } else { // For non-bumped case, ambient cube is computed in the vertex shader SetAmbientCubeDynamicStateVertexShader(); #ifndef _X360 if ( !g_pHardwareConfig->HasFastVertexTextures() ) #endif { DECLARE_DYNAMIC_VERTEX_SHADER( sdk_teeth_vs20 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( DOWATERFOG, pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z ); SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, pShaderAPI->GetCurrentNumBones() > 0 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( DYNAMIC_LIGHT, lightState.HasDynamicLight() ); SET_DYNAMIC_VERTEX_SHADER_COMBO( STATIC_LIGHT, lightState.m_bStaticLight ? 1 : 0 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression ); SET_DYNAMIC_VERTEX_SHADER( sdk_teeth_vs20 ); if( g_pHardwareConfig->SupportsPixelShaders_2_b() ) { DECLARE_DYNAMIC_PIXEL_SHADER( sdk_teeth_ps20b ); SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() ); SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bFullyOpaque && pShaderAPI->ShouldWriteDepthToDestAlpha() ); SET_DYNAMIC_PIXEL_SHADER( sdk_teeth_ps20b ); } else { DECLARE_DYNAMIC_PIXEL_SHADER( sdk_teeth_ps20 ); SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() ); SET_DYNAMIC_PIXEL_SHADER( sdk_teeth_ps20 ); } } #ifndef _X360 else { SetHWMorphVertexShaderState( VERTEX_SHADER_SHADER_SPECIFIC_CONST_6, VERTEX_SHADER_SHADER_SPECIFIC_CONST_7, SHADER_VERTEXTEXTURE_SAMPLER0 ); DECLARE_DYNAMIC_VERTEX_SHADER( sdk_teeth_vs30 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( DOWATERFOG, pShaderAPI->GetSceneFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z ); SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, pShaderAPI->GetCurrentNumBones() > 0 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( DYNAMIC_LIGHT, lightState.HasDynamicLight() ); SET_DYNAMIC_VERTEX_SHADER_COMBO( STATIC_LIGHT, lightState.m_bStaticLight ? 1 : 0 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( MORPHING, pShaderAPI->IsHWMorphingEnabled() ); SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression ); SET_DYNAMIC_VERTEX_SHADER( sdk_teeth_vs30 ); DECLARE_DYNAMIC_PIXEL_SHADER( sdk_teeth_ps30 ); SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() ); SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bFullyOpaque && pShaderAPI->ShouldWriteDepthToDestAlpha() ); SET_DYNAMIC_PIXEL_SHADER( sdk_teeth_ps30 ); } #endif } if( params[INTRO]->GetIntValue() ) { float curTime = params[WARPPARAM]->GetFloatValue(); float timeVec[4] = { 0.0f, 0.0f, 0.0f, curTime }; Assert( params[ENTITYORIGIN]->IsDefined() ); params[ENTITYORIGIN]->GetVecValue( timeVec, 3 ); pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_1, timeVec, 1 ); } } Draw(); }
inline void DrawReflectionRefraction( IMaterialVar **params, IShaderShadow* pShaderShadow, IShaderDynamicAPI* pShaderAPI, bool bReflection, bool bRefraction ) { BlendType_t nBlendType = EvaluateBlendRequirements( BASETEXTURE, true ); bool bFullyOpaque = (nBlendType != BT_BLENDADD) && (nBlendType != BT_BLEND) && !IS_FLAG_SET(MATERIAL_VAR_ALPHATEST); //dest alpha is free for special use SHADOW_STATE { SetInitialShadowState( ); if( bRefraction ) { pShaderShadow->EnableTexture( SHADER_SAMPLER0, true ); pShaderShadow->EnableTexture( SHADER_SAMPLER1, true ); if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_INTEGER ) { pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, true ); } } if( bReflection ) { pShaderShadow->EnableTexture( SHADER_SAMPLER2, true ); pShaderShadow->EnableTexture( SHADER_SAMPLER3, true ); if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_INTEGER ) { pShaderShadow->EnableSRGBRead( SHADER_SAMPLER2, true ); } } if( params[BASETEXTURE]->IsTexture() ) { // BASETEXTURE pShaderShadow->EnableTexture( SHADER_SAMPLER1, true ); // LIGHTMAP pShaderShadow->EnableTexture( SHADER_SAMPLER3, true ); if ( params[ENVMAPMASK]->IsTexture() ) { pShaderShadow->EnableTexture( SHADER_SAMPLER6, true ); } } // normal map pShaderShadow->EnableTexture( SHADER_SAMPLER4, true ); int fmt = VERTEX_POSITION | VERTEX_NORMAL | VERTEX_TANGENT_S | VERTEX_TANGENT_T; // texcoord0 : base texcoord // texcoord1 : lightmap texcoord // texcoord2 : lightmap texcoord offset int numTexCoords = 1; if( params[BASETEXTURE]->IsTexture() ) { numTexCoords = 3; } pShaderShadow->VertexShaderVertexFormat( fmt, numTexCoords, 0, 0 ); if ( IS_FLAG_SET(MATERIAL_VAR_TRANSLUCENT ) ) { EnableAlphaBlending( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE_MINUS_SRC_ALPHA ); } DECLARE_STATIC_VERTEX_SHADER( sdk_lightmappedreflective_vs20 ); SET_STATIC_VERTEX_SHADER_COMBO( BASETEXTURE, params[BASETEXTURE]->IsTexture() ); SET_STATIC_VERTEX_SHADER( sdk_lightmappedreflective_vs20 ); // "REFLECT" "0..1" // "REFRACT" "0..1" if( g_pHardwareConfig->SupportsPixelShaders_2_b() ) { DECLARE_STATIC_PIXEL_SHADER( sdk_lightmappedreflective_ps20b ); SET_STATIC_PIXEL_SHADER_COMBO( REFLECT, bReflection ); SET_STATIC_PIXEL_SHADER_COMBO( REFRACT, bRefraction ); SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE, params[BASETEXTURE]->IsTexture() ); SET_STATIC_PIXEL_SHADER_COMBO( ENVMAPMASK, params[ENVMAPMASK]->IsTexture() && params[BASETEXTURE]->IsTexture() ); SET_STATIC_PIXEL_SHADER( sdk_lightmappedreflective_ps20b ); } else { DECLARE_STATIC_PIXEL_SHADER( sdk_lightmappedreflective_ps20 ); SET_STATIC_PIXEL_SHADER_COMBO( REFLECT, bReflection ); SET_STATIC_PIXEL_SHADER_COMBO( REFRACT, bRefraction ); SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE, params[BASETEXTURE]->IsTexture() ); SET_STATIC_PIXEL_SHADER_COMBO( ENVMAPMASK, params[ENVMAPMASK]->IsTexture() && params[BASETEXTURE]->IsTexture() ); SET_STATIC_PIXEL_SHADER( sdk_lightmappedreflective_ps20 ); } FogToFogColor(); if( g_pHardwareConfig->GetHDRType() != HDR_TYPE_NONE ) { // we are writing linear values from this shader. pShaderShadow->EnableSRGBWrite( true ); } pShaderShadow->EnableAlphaWrites( bFullyOpaque ); } DYNAMIC_STATE { if( bRefraction ) { // HDRFIXME: add comment about binding.. Specify the number of MRTs in the enable BindTexture( SHADER_SAMPLER0, REFRACTTEXTURE, -1 ); } if( bReflection ) { BindTexture( SHADER_SAMPLER2, REFLECTTEXTURE, -1 ); } BindTexture( SHADER_SAMPLER4, NORMALMAP, BUMPFRAME ); if( params[BASETEXTURE]->IsTexture() ) { BindTexture( SHADER_SAMPLER1, BASETEXTURE, FRAME ); pShaderAPI->BindStandardTexture( SHADER_SAMPLER3, TEXTURE_LIGHTMAP ); SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_3, BASETEXTURETRANSFORM ); if ( params[ENVMAPMASK]->IsTexture() ) { BindTexture( SHADER_SAMPLER6, ENVMAPMASK, ENVMAPMASKFRAME ); } } // Refraction tint if( bRefraction ) { SetPixelShaderConstantGammaToLinear( 1, REFRACTTINT ); } // Reflection tint if( bReflection ) { SetPixelShaderConstantGammaToLinear( 4, REFLECTTINT ); } SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_1, BUMPTRANSFORM ); float c0[4] = { 1.0f / 3.0f, 1.0f / 3.0f, 1.0f / 3.0f, 0.0f }; pShaderAPI->SetPixelShaderConstant( 0, c0, 1 ); float c2[4] = { 0.5f, 0.5f, 0.5f, 0.5f }; pShaderAPI->SetPixelShaderConstant( 2, c2, 1 ); // fresnel constants float flFresnelFactor = params[MAXREFLECTIVITY]->GetFloatValue() - params[MINREFLECTIVITY]->GetFloatValue(); float c3[4] = { flFresnelFactor, params[FRESNELPOWER]->GetFloatValue(), params[MINREFLECTIVITY]->GetFloatValue(), 0.0f }; pShaderAPI->SetPixelShaderConstant( 3, c3, 1 ); float c5[4] = { params[REFLECTAMOUNT]->GetFloatValue(), params[REFLECTAMOUNT]->GetFloatValue(), params[REFRACTAMOUNT]->GetFloatValue(), params[REFRACTAMOUNT]->GetFloatValue() }; pShaderAPI->SetPixelShaderConstant( 5, c5, 1 ); pShaderAPI->SetPixelShaderFogParams( 8 ); DECLARE_DYNAMIC_VERTEX_SHADER( sdk_lightmappedreflective_vs20 ); SET_DYNAMIC_VERTEX_SHADER( sdk_lightmappedreflective_vs20 ); if( g_pHardwareConfig->SupportsPixelShaders_2_b() ) { DECLARE_DYNAMIC_PIXEL_SHADER( sdk_lightmappedreflective_ps20b ); SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bFullyOpaque && pShaderAPI->ShouldWriteDepthToDestAlpha() ); SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() ); SET_DYNAMIC_PIXEL_SHADER( sdk_lightmappedreflective_ps20b ); } else { DECLARE_DYNAMIC_PIXEL_SHADER( sdk_lightmappedreflective_ps20 ); SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() ); SET_DYNAMIC_PIXEL_SHADER( sdk_lightmappedreflective_ps20 ); } } Draw(); }