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(); }