SHADER_INIT_PARAMS() { SetupVars( s_info ); InitParamsLightmappedGeneric_DX9( this, params, pMaterialName, s_info ); bool bDeferredActive = GetDeferredExt()->IsDeferredLightingEnabled(); if( bDeferredActive ) { defParms_gBuffer parms_gbuffer; SetupParmsGBuffer( parms_gbuffer ); InitParmsGBuffer( parms_gbuffer, this, params ); defParms_shadow parms_shadow; SetupParmsShadow( parms_shadow ); InitParmsShadowPass( parms_shadow, this, params ); } }
SHADER_INIT_PARAMS() { SET_FLAGS2( MATERIAL_VAR2_SUPPORTS_HW_SKINNING ); if ( g_pHardwareConfig->HasFastVertexTextures() ) SET_FLAGS2( MATERIAL_VAR2_USES_VERTEXID ); //const bool bIsDecal = IS_FLAG_SET( MATERIAL_VAR_DECAL ); const bool bDeferredActive = GetDeferredExt()->IsDeferredLightingEnabled(); if( bDeferredActive )// && !bIsDecal ) { const bool bTranslucent = IS_FLAG_SET( MATERIAL_VAR_TRANSLUCENT ); const bool bAlphaTest = IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ); if( bTranslucent ) { CLEAR_FLAGS( MATERIAL_VAR_TRANSLUCENT ); SET_FLAGS( MATERIAL_VAR_ALPHATEST ); params[ALPHATESTREFERENCE]->SetFloatValue( 0.5f ); } else if( bAlphaTest ) { if( params[ALPHATESTREFERENCE]->GetFloatValue() == 0.0f ) params[ALPHATESTREFERENCE]->SetFloatValue( 0.5f ); } } const bool bDrawToGBuffer = DrawToGBuffer( params ); if ( bDrawToGBuffer ) { defParms_gBuffer parms_gbuffer; SetupParmsGBuffer( parms_gbuffer ); InitParmsGBuffer( parms_gbuffer, this, params ); defParms_shadow parms_shadow; SetupParmsShadow( parms_shadow ); InitParmsShadowPass( parms_shadow, this, params ); } }
bool CDeferredManagerClient::Init() { CopyDev(); AssertMsg( g_pCurrentViewRender == NULL, "viewrender already allocated?!" ); const bool bForceDeferred = CommandLine() && CommandLine()->FindParm("-forcedeferred") != 0; bool bSM30 = g_pMaterialSystemHardwareConfig->GetDXSupportLevel() >= 95; if ( !bSM30 ) { Warning( "The engine doesn't recognize your GPU to support SM3.0, running deferred anyway...\n" ); bSM30 = true; } if ( bSM30 || bForceDeferred ) { bool bGotDefShaderDll = ConnectDeferredExt(); if ( bGotDefShaderDll ) { g_pOldMatSystem = materials; g_DeferredMaterialSystem.InitPassThru( materials ); materials = &g_DeferredMaterialSystem; engine->Mat_Stub( &g_DeferredMaterialSystem ); m_bDefRenderingEnabled = true; GetDeferredExt()->EnableDeferredLighting(); g_pCurrentViewRender = new CDeferredViewRender(); ConVarRef r_shadows( "r_shadows" ); r_shadows.SetValue( "0" ); InitDeferredRTs( true ); materials->AddModeChangeCallBack( &DefRTsOnModeChanged ); InitializeDeferredMaterials(); } } if ( !m_bDefRenderingEnabled ) { Assert( g_pCurrentViewRender == NULL ); Warning( "Your hardware does not seem to support shader model 3.0. If you think that this is an error (hybrid GPUs), add -forcedeferred as start parameter.\n" ); g_pCurrentViewRender = new CViewRender(); } else { #define VENDOR_NVIDIA 0x10DE #define VENDOR_INTEL 0x8086 #define VENDOR_ATI 0x1002 #define VENDOR_AMD 0x1022 #ifndef SHADOWMAPPING_USE_COLOR MaterialAdapterInfo_t info; materials->GetDisplayAdapterInfo( materials->GetCurrentAdapter(), info ); if ( info.m_VendorID == VENDOR_ATI || info.m_VendorID == VENDOR_AMD ) { vgui::MessageBox *pATIWarning = new vgui::MessageBox("UNSUPPORTED HARDWARE", VarArgs( "AMD/ATI IS NOT YET SUPPORTED IN HARDWARE FILTERING MODE\n" "(cdeferred_manager_client.cpp #%i).", __LINE__ ) ); pATIWarning->InvalidateLayout(); pATIWarning->DoModal(); } #endif } return true; }
void InitDeferredRTs( bool bInitial ) { if( bInitial ) // TODO: Does not work correctly mid game { // First determine if we are using low or high if( GetGPUMemLevel() <= GPU_MEM_LEVEL_LOW || GetCPULevel() <= CPU_LEVEL_LOW ) { g_cms_comp_res_x = CSM_COMP_RES_X_LOW; g_cms_comp_res_y = CSM_COMP_RES_Y_LOW; g_cms_comp_res_islow = true; } else { g_cms_comp_res_x = CSM_COMP_RES_X_HIGH; g_cms_comp_res_y = CSM_COMP_RES_Y_HIGH; g_cms_comp_res_islow = false; } } if ( !bInitial ) materials->ReEnableRenderTargetAllocation_IRealizeIfICallThisAllTexturesWillBeUnloadedAndLoadTimeWillSufferHorribly(); // HAHAHAHA. No. //int screen_w, screen_h; int dummy = 128; //materials->GetBackBufferDimensions( screen_w, screen_h ); const ImageFormat fmt_gbuffer0 = #if DEFCFG_LIGHTCTRL_PACKING IMAGE_FORMAT_RGBA8888; #else IMAGE_FORMAT_RGB888; #endif #if !DEFCFG_LIGHTCTRL_PACKING const ImageFormat fmt_gbuffer2 = IMAGE_FORMAT_RGBA8888; #endif #if DEFCFG_DEFERRED_SHADING == 1 const ImageFormat fmt_gbuffer2 = IMAGE_FORMAT_RGBA8888; const ImageFormat fmt_gbuffer3 = IMAGE_FORMAT_RGB888; #endif const ImageFormat fmt_gbuffer1 = IMAGE_FORMAT_R32F; const ImageFormat fmt_lightAccum = #if DEFCFG_LIGHTACCUM_COMPRESSED IMAGE_FORMAT_RGBA8888; #else IMAGE_FORMAT_RGBA16161616F; #endif const ImageFormat fmt_volumAccum = IMAGE_FORMAT_RGB888; const ImageFormat fmt_projVGUI = IMAGE_FORMAT_RGB888; const bool bShadowUseColor = #ifdef SHADOWMAPPING_USE_COLOR true; #else false; #endif const ImageFormat fmt_depth = GetDeferredManager()->GetShadowDepthFormat(); const ImageFormat fmt_depthColor = bShadowUseColor ? IMAGE_FORMAT_R32F : g_pMaterialSystemHardwareConfig->GetNullTextureFormat(); #if DEFCFG_ENABLE_RADIOSITY == 1 const ImageFormat fmt_radAlbedo = IMAGE_FORMAT_RGB888; const ImageFormat fmt_radNormal = IMAGE_FORMAT_RGB888; const ImageFormat fmt_radBuffer = IMAGE_FORMAT_RGB888; #endif // DEFCFG_ENABLE_RADIOSITY if ( fmt_depth == IMAGE_FORMAT_D16_SHADOW ) g_flDepthScalar = pow( 2.0, 16 ); else if ( fmt_depth == IMAGE_FORMAT_D24X8_SHADOW ) g_flDepthScalar = pow( 2.0, 24 ); AssertMsg( fmt_depth == IMAGE_FORMAT_D16_SHADOW || fmt_depth == IMAGE_FORMAT_D24X8_SHADOW, "Unexpected depth format" ); unsigned int gbufferFlags = TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT | TEXTUREFLAGS_RENDERTARGET | TEXTUREFLAGS_POINTSAMPLE; unsigned int lightAccumFlags = TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT | TEXTUREFLAGS_RENDERTARGET | TEXTUREFLAGS_POINTSAMPLE; unsigned int volumAccumFlags = TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT | TEXTUREFLAGS_RENDERTARGET; unsigned int depthFlags = TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT | TEXTUREFLAGS_RENDERTARGET; unsigned int shadowColorFlags = TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT | TEXTUREFLAGS_RENDERTARGET | TEXTUREFLAGS_POINTSAMPLE; unsigned int projVGUIFlags = TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT | TEXTUREFLAGS_RENDERTARGET; #if DEFCFG_ENABLE_RADIOSITY == 1 unsigned int radAlbedoNormalFlags = TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT | TEXTUREFLAGS_RENDERTARGET | TEXTUREFLAGS_POINTSAMPLE; unsigned int radBufferFlags = TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT | TEXTUREFLAGS_RENDERTARGET; unsigned int radNormalFlags = TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT | TEXTUREFLAGS_RENDERTARGET | TEXTUREFLAGS_POINTSAMPLE; #endif // DEFCFG_ENABLE_RADIOSITY materials->BeginRenderTargetAllocation(); shadowData_general_t generalShadowData; if ( bInitial ) { g_tex_Normals.Init( materials->CreateNamedRenderTargetTextureEx2( DEFRTNAME_GBUFFER0, dummy, dummy, RT_SIZE_FULL_FRAME_BUFFER_ROUNDED_UP, fmt_gbuffer0, #if DEFCFG_DEFERRED_SHADING == 1 MATERIAL_RT_DEPTH_NONE, #else MATERIAL_RT_DEPTH_SHARED, #endif gbufferFlags, 0 ) ); g_tex_Depth.Init( materials->CreateNamedRenderTargetTextureEx2( DEFRTNAME_GBUFFER1, dummy, dummy, RT_SIZE_FULL_FRAME_BUFFER_ROUNDED_UP, fmt_gbuffer1, MATERIAL_RT_DEPTH_NONE, gbufferFlags, 0 ) ); #if ( DEFCFG_LIGHTCTRL_PACKING == 0 ) g_tex_LightCtrl.Init( materials->CreateNamedRenderTargetTextureEx2( DEFRTNAME_GBUFFER2, dummy, dummy, RT_SIZE_FULL_FRAME_BUFFER_ROUNDED_UP, fmt_gbuffer2, MATERIAL_RT_DEPTH_NONE, gbufferFlags, 0 ) ); #elif DEFCFG_DEFERRED_SHADING == 1 g_tex_Albedo.Init( materials->CreateNamedRenderTargetTextureEx2( DEFRTNAME_GBUFFER2, dummy, dummy, RT_SIZE_FULL_FRAME_BUFFER_ROUNDED_UP, fmt_gbuffer2, MATERIAL_RT_DEPTH_SHARED, gbufferFlags, 0 ) ); g_tex_Specular.Init( materials->CreateNamedRenderTargetTextureEx2( DEFRTNAME_GBUFFER3, dummy, dummy, RT_SIZE_FULL_FRAME_BUFFER_ROUNDED_UP, fmt_gbuffer3, MATERIAL_RT_DEPTH_NONE, gbufferFlags, 0 ) ); #endif g_tex_Lightaccum.Init( materials->CreateNamedRenderTargetTextureEx2( DEFRTNAME_LIGHTACCUM, dummy, dummy, RT_SIZE_FULL_FRAME_BUFFER_ROUNDED_UP, fmt_lightAccum, MATERIAL_RT_DEPTH_NONE, lightAccumFlags, 0 ) ); g_tex_Lightaccum2.Init( materials->CreateNamedRenderTargetTextureEx2( DEFRTNAME_LIGHTACCUM2, dummy, dummy, RT_SIZE_FULL_FRAME_BUFFER_ROUNDED_UP, fmt_lightAccum, MATERIAL_RT_DEPTH_NONE, lightAccumFlags, 0 ) ); for ( int i = 0; i < 2; i++ ) g_tex_VolumetricsBuffer[ i ].Init( materials->CreateNamedRenderTargetTextureEx2( VarArgs( "%s%02i", DEFRTNAME_VOLUMACCUM, i ), dummy, dummy, RT_SIZE_HDR, fmt_volumAccum, MATERIAL_RT_DEPTH_NONE, volumAccumFlags, 0 ) ); g_tex_VolumePrepass.Init( materials->CreateNamedRenderTargetTextureEx2( DEFRTNAME_VOLUMPREPASS, dummy, dummy, RT_SIZE_HDR, fmt_gbuffer1, MATERIAL_RT_DEPTH_NONE, gbufferFlags, 0 ) ); for ( int i = 0; i < MAX_SHADOW_ORTHO; i++ ) { #if CSM_USE_COMPOSITED_TARGET int iResolution_x = CSM_COMP_RES_X; int iResolution_y = CSM_COMP_RES_Y; #else const cascade_t &c = GetCascadeInfo( i ); int iResolution_x = c.iResolution; int iResolution_y = c.iResolution; #endif g_tex_ShadowDepth_Ortho[i].Init( materials->CreateNamedRenderTargetTextureEx2( VarArgs( "%s%02i", DEFRTNAME_SHADOWDEPTH_ORTHO, i ), iResolution_x, iResolution_y, RT_SIZE_NO_CHANGE, fmt_depth, MATERIAL_RT_DEPTH_NONE, depthFlags, 0 ) ); g_tex_ShadowColor_Ortho[i].Init( materials->CreateNamedRenderTargetTextureEx2( VarArgs( "%s%02i", DEFRTNAME_SHADOWCOLOR_ORTHO, i ), iResolution_x, iResolution_y, RT_SIZE_NO_CHANGE, fmt_depthColor, MATERIAL_RT_DEPTH_NONE, shadowColorFlags, 0 ) ); #if DEFCFG_ENABLE_RADIOSITY != 0 g_tex_ShadowRad_Albedo_Ortho[i].Init( materials->CreateNamedRenderTargetTextureEx2( VarArgs( "%s%02i", DEFRTNAME_SHADOWRAD_ALBEDO_ORTHO, i ), iResolution_x, iResolution_y, RT_SIZE_NO_CHANGE, fmt_radAlbedo, MATERIAL_RT_DEPTH_NONE, radAlbedoNormalFlags, 0 ) ); g_tex_ShadowRad_Normal_Ortho[i].Init( materials->CreateNamedRenderTargetTextureEx2( VarArgs( "%s%02i", DEFRTNAME_SHADOWRAD_NORMAL_ORTHO, i ), iResolution_x, iResolution_y, RT_SIZE_NO_CHANGE, fmt_radNormal, MATERIAL_RT_DEPTH_NONE, radAlbedoNormalFlags, 0 ) ); #endif Assert( iResolution_y == g_tex_ShadowDepth_Ortho[i]->GetActualHeight() ); Assert( iResolution_y == g_tex_ShadowColor_Ortho[i]->GetActualHeight() ); Assert( iResolution_x == g_tex_ShadowDepth_Ortho[i]->GetActualWidth() ); Assert( iResolution_x == g_tex_ShadowColor_Ortho[i]->GetActualWidth() ); } for ( int i = 0; i < NUM_PROJECTABLE_VGUI; i++ ) { g_tex_ProjectableVGUI[i].Init( materials->CreateNamedRenderTargetTextureEx2( VarArgs( "%s%02i", DEFRTNAME_PROJECTABLE_VGUI, i ), PROJECTABLE_VGUI_RES, PROJECTABLE_VGUI_RES, RT_SIZE_NO_CHANGE, fmt_projVGUI, MATERIAL_RT_DEPTH_NONE, projVGUIFlags, 0 ) ); } #if DEFCFG_ENABLE_RADIOSITY for ( int i = 0; i < 2; i++ ) { g_tex_RadiosityBuffer[i].Init( materials->CreateNamedRenderTargetTextureEx2( VarArgs( "%s%02i", DEFRTNAME_RADIOSITY_BUFFER, i ), RADIOSITY_BUFFER_RES_X, RADIOSITY_BUFFER_RES_Y, RT_SIZE_NO_CHANGE, fmt_radBuffer, MATERIAL_RT_DEPTH_NONE, radBufferFlags, 0 ) ); g_tex_RadiosityNormal[i].Init( materials->CreateNamedRenderTargetTextureEx2( VarArgs( "%s%02i", DEFRTNAME_RADIOSITY_NORMAL, i ), RADIOSITY_BUFFER_RES_X, RADIOSITY_BUFFER_RES_Y, RT_SIZE_NO_CHANGE, fmt_radNormal, MATERIAL_RT_DEPTH_NONE, radNormalFlags, 0 ) ); } #endif } for ( int i = 0; i < MAX_SHADOW_PROJ; i++ ) { int res = GetShadowResolution_Spot(); generalShadowData.iPROJ_Res = res; bool bFirst = i == 0; if ( !bShadowUseColor || bFirst ) g_tex_ShadowDepth_Proj[i].Init( materials->CreateNamedRenderTargetTextureEx2( VarArgs( "%s%02i", DEFRTNAME_SHADOWDEPTH_PROJ, i ), res, res, RT_SIZE_NO_CHANGE, fmt_depth, MATERIAL_RT_DEPTH_NONE, depthFlags, 0 ) ); else g_tex_ShadowDepth_Proj[i].Init( g_tex_ShadowDepth_Proj[0] ); if ( bShadowUseColor || bFirst ) g_tex_ShadowColor_Proj[i].Init( materials->CreateNamedRenderTargetTextureEx2( VarArgs( "%s%02i", DEFRTNAME_SHADOWCOLOR_PROJ, i ), res, res, RT_SIZE_NO_CHANGE, fmt_depthColor, MATERIAL_RT_DEPTH_NONE, shadowColorFlags, 0 ) ); else g_tex_ShadowColor_Proj[i].Init( g_tex_ShadowColor_Proj[0] ); Assert( res == g_tex_ShadowDepth_Proj[i]->GetActualHeight() ); Assert( res == g_tex_ShadowColor_Proj[i]->GetActualHeight() ); Assert( res == g_tex_ShadowDepth_Proj[i]->GetActualWidth() ); Assert( res == g_tex_ShadowColor_Proj[i]->GetActualWidth() ); #if DEFCFG_ADAPTIVE_SHADOWMAP_LOD res = GetShadowResolution_Spot_LOD1(); generalShadowData.iPROJ_Res_LOD1 = res; if ( !bShadowUseColor || bFirst ) g_tex_ShadowDepth_Proj_LOD1[i].Init( materials->CreateNamedRenderTargetTextureEx2( VarArgs( "%s%02i", DEFRTNAME_SHADOWDEPTH_PROJ_LOD1, i ), res, res, RT_SIZE_NO_CHANGE, fmt_depth, MATERIAL_RT_DEPTH_NONE, depthFlags, 0 ) ); else g_tex_ShadowDepth_Proj_LOD1[i].Init( g_tex_ShadowDepth_Proj_LOD1[0] ); if ( bShadowUseColor || bFirst ) g_tex_ShadowColor_Proj_LOD1[i].Init( materials->CreateNamedRenderTargetTextureEx2( VarArgs( "%s%02i", DEFRTNAME_SHADOWCOLOR_PROJ_LOD1, i ), res, res, RT_SIZE_NO_CHANGE, fmt_depthColor, MATERIAL_RT_DEPTH_NONE, shadowColorFlags, 0 ) ); else g_tex_ShadowColor_Proj_LOD1[i].Init( g_tex_ShadowColor_Proj_LOD1[0] ); Assert( res == g_tex_ShadowDepth_Proj_LOD1[i]->GetActualHeight() ); Assert( res == g_tex_ShadowColor_Proj_LOD1[i]->GetActualHeight() ); Assert( res == g_tex_ShadowDepth_Proj_LOD1[i]->GetActualWidth() ); Assert( res == g_tex_ShadowColor_Proj_LOD1[i]->GetActualWidth() ); res = GetShadowResolution_Spot_LOD2(); generalShadowData.iPROJ_Res_LOD2 = res; if ( !bShadowUseColor || bFirst ) g_tex_ShadowDepth_Proj_LOD2[i].Init( materials->CreateNamedRenderTargetTextureEx2( VarArgs( "%s%02i", DEFRTNAME_SHADOWDEPTH_PROJ_LOD2, i ), res, res, RT_SIZE_NO_CHANGE, fmt_depth, MATERIAL_RT_DEPTH_NONE, depthFlags, 0 ) ); else g_tex_ShadowDepth_Proj_LOD2[i].Init( g_tex_ShadowDepth_Proj_LOD2[0] ); if ( bShadowUseColor || bFirst ) g_tex_ShadowColor_Proj_LOD2[i].Init( materials->CreateNamedRenderTargetTextureEx2( VarArgs( "%s%02i", DEFRTNAME_SHADOWCOLOR_PROJ_LOD2, i ), res, res, RT_SIZE_NO_CHANGE, fmt_depthColor, MATERIAL_RT_DEPTH_NONE, shadowColorFlags, 0 ) ); else g_tex_ShadowColor_Proj_LOD2[i].Init( g_tex_ShadowColor_Proj_LOD2[0] ); Assert( res == g_tex_ShadowDepth_Proj_LOD2[i]->GetActualHeight() ); Assert( res == g_tex_ShadowColor_Proj_LOD2[i]->GetActualHeight() ); Assert( res == g_tex_ShadowDepth_Proj_LOD2[i]->GetActualWidth() ); Assert( res == g_tex_ShadowColor_Proj_LOD2[i]->GetActualWidth() ); #endif } for ( int i = 0; i < MAX_SHADOW_DP; i++ ) { int res_x = GetShadowResolution_Point(); int res_y = res_x * 2; generalShadowData.iDPSM_Res_x = res_x; generalShadowData.iDPSM_Res_y = res_y; bool bFirst = i == 0; if ( !bShadowUseColor || bFirst ) g_tex_ShadowDepth_DP[i].Init( materials->CreateNamedRenderTargetTextureEx2( VarArgs( "%s%02i", DEFRTNAME_SHADOWDEPTH_DP, i ), res_x, res_y, RT_SIZE_NO_CHANGE, fmt_depth, MATERIAL_RT_DEPTH_NONE, depthFlags, 0 ) ); else g_tex_ShadowDepth_DP[i].Init( g_tex_ShadowDepth_DP[0] ); if ( bShadowUseColor || bFirst ) g_tex_ShadowColor_DP[i].Init( materials->CreateNamedRenderTargetTextureEx2( VarArgs( "%s%02i", DEFRTNAME_SHADOWCOLOR_DP, i ), res_x, res_y, RT_SIZE_NO_CHANGE, fmt_depthColor, MATERIAL_RT_DEPTH_NONE, shadowColorFlags, 0 ) ); else g_tex_ShadowColor_DP[i].Init( g_tex_ShadowColor_DP[0] ); Assert( res_y == g_tex_ShadowDepth_DP[i]->GetActualHeight() ); Assert( res_y == g_tex_ShadowColor_DP[i]->GetActualHeight() ); Assert( res_x == g_tex_ShadowDepth_DP[i]->GetActualWidth() ); Assert( res_x == g_tex_ShadowColor_DP[i]->GetActualWidth() ); } materials->EndRenderTargetAllocation(); if( !bInitial ) { materials->FinishRenderTargetAllocation(); } GetDeferredExt()->CommitTexture_General( g_tex_Normals, g_tex_Depth, #if ( DEFCFG_LIGHTCTRL_PACKING == 0 ) g_tex_LightCtrl, #elif DEFCFG_DEFERRED_SHADING == 1 g_tex_Albedo, g_tex_Specular, #endif g_tex_Lightaccum, g_tex_Lightaccum2 ); for ( int i = 0; i < MAX_SHADOW_ORTHO; i++ ) GetDeferredExt()->CommitTexture_CascadedDepth( i, bShadowUseColor ? g_tex_ShadowColor_Ortho[i] : g_tex_ShadowDepth_Ortho[i] ); for ( int i = 0; i < MAX_SHADOW_DP; i++ ) GetDeferredExt()->CommitTexture_DualParaboloidDepth( i, bShadowUseColor ? g_tex_ShadowColor_DP[i] : g_tex_ShadowDepth_DP[i] ); for ( int i = 0; i < MAX_SHADOW_PROJ; i++ ) GetDeferredExt()->CommitTexture_ProjectedDepth( i, bShadowUseColor ? g_tex_ShadowColor_Proj[i] : g_tex_ShadowDepth_Proj[i] ); GetDeferredExt()->CommitTexture_VolumePrePass( g_tex_VolumePrepass ); GetDeferredExt()->CommitShadowData_General( generalShadowData ); #if DEFCFG_ENABLE_RADIOSITY AssertMsg( MAX_SHADOW_ORTHO == 1, "You gotta fix the commit func now.." ); GetDeferredExt()->CommitTexture_ShadowRadOutput_Ortho( g_tex_ShadowRad_Albedo_Ortho[0], g_tex_ShadowRad_Normal_Ortho[0] ); GetDeferredExt()->CommitTexture_Radiosity( g_tex_RadiosityBuffer[0], g_tex_RadiosityBuffer[1], g_tex_RadiosityNormal[0], g_tex_RadiosityNormal[1] ); #endif }
bool CDeferredManagerClient::Init() { AssertMsg( g_pCurrentViewRender == NULL, "viewrender already allocated?!" ); // Make sure deferred lighting setting is read out at this point ReadVideoCfgExt(); const bool bLowPerfSystem = GetGPULevel() <= GPU_LEVEL_LOW || GetGPUMemLevel() <= GPU_MEM_LEVEL_LOW || GetCPULevel() <= CPU_LEVEL_LOW; const int iDeferredLevel = CommandLine() ? CommandLine()->ParmValue("-deferred", 1) : 1; const bool bAllowDeferred = deferred_lighting_enabled.GetBool() && !bLowPerfSystem && (!CommandLine() || CommandLine()->FindParm("-disabledeferred") == 0); const bool bForceDeferred = CommandLine() && CommandLine()->FindParm("-forcedeferred") != 0; bool bSM30 = g_pMaterialSystemHardwareConfig->GetDXSupportLevel() >= 95; if ( !bSM30 ) { Warning( "The engine doesn't recognize your GPU to support SM3.0, running deferred anyway...\n" ); bSM30 = true; } if ( bAllowDeferred && (bSM30 || bForceDeferred) ) { bool bGotDefShaderDll = ConnectDeferredExt(); if ( bGotDefShaderDll ) { m_bDefRenderingEnabled = true; GetDeferredExt()->EnableDeferredLighting(); if( iDeferredLevel > 1 ) g_pCurrentViewRender = new CDeferredViewRender(); else g_pCurrentViewRender = new CViewRender(); ConVarRef r_shadows( "r_shadows" ); r_shadows.SetValue( "0" ); InitDeferredRTs( true ); materials->AddModeChangeCallBack( &DefRTsOnModeChanged ); InitializeDeferredMaterials(); } } if ( !m_bDefRenderingEnabled ) { Assert( g_pCurrentViewRender == NULL ); if( bAllowDeferred ) Warning( "Your hardware does not seem to support shader model 3.0. If you think that this is an error (hybrid GPUs), add -forcedeferred as start parameter.\n" ); g_pCurrentViewRender = new CViewRender(); } else { #define VENDOR_NVIDIA 0x10DE #define VENDOR_INTEL 0x8086 #define VENDOR_ATI 0x1002 #define VENDOR_AMD 0x1022 #ifndef SHADOWMAPPING_USE_COLOR MaterialAdapterInfo_t info; materials->GetDisplayAdapterInfo( materials->GetCurrentAdapter(), info ); if ( info.m_VendorID == VENDOR_ATI || info.m_VendorID == VENDOR_AMD ) { vgui::MessageBox *pATIWarning = new vgui::MessageBox("UNSUPPORTED HARDWARE", VarArgs( "AMD/ATI IS NOT YET SUPPORTED IN HARDWARE FILTERING MODE\n" "(cdeferred_manager_client.cpp #%i).", __LINE__ ) ); pATIWarning->InvalidateLayout(); pATIWarning->DoModal(); } #endif } return true; }
void DrawPassComposite( const defParms_composite &info, CBaseVSShader *pShader, IMaterialVar **params, IShaderShadow* pShaderShadow, IShaderDynamicAPI* pShaderAPI, VertexCompressionType_t vertexCompression, CDeferredPerMaterialContextData *pDeferredContext ) { const bool bModel = info.bModel; const bool bIsDecal = IS_FLAG_SET( MATERIAL_VAR_DECAL ); const bool bFastVTex = g_pHardwareConfig->HasFastVertexTextures(); const bool bAlbedo = PARM_TEX( info.iAlbedo ); const bool bAlbedo2 = !bModel && bAlbedo && PARM_TEX( info.iAlbedo2 ); const bool bAlbedo3 = !bModel && bAlbedo && PARM_TEX( info.iAlbedo3 ); const bool bAlbedo4 = !bModel && bAlbedo && PARM_TEX( info.iAlbedo4 ); const bool bAlphatest = IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) && bAlbedo; const bool bTranslucent = IS_FLAG_SET( MATERIAL_VAR_TRANSLUCENT ) && bAlbedo && !bAlphatest; const bool bNoCull = IS_FLAG_SET( MATERIAL_VAR_NOCULL ); const bool bUseSRGB = DEFCFG_USE_SRGB_CONVERSION != 0; const bool bPhongFresnel = PARM_SET( info.iPhongFresnel ); const bool bEnvmap = PARM_TEX( info.iEnvmap ); const bool bEnvmapMask = bEnvmap && PARM_TEX( info.iEnvmapMask ); const bool bEnvmapMask2 = bEnvmapMask && PARM_TEX( info.iEnvmapMask2 ); const bool bEnvmapFresnel = bEnvmap && PARM_SET( info.iEnvmapFresnel ); const bool bRimLight = PARM_SET( info.iRimlightEnable ); const bool bRimLightModLight = bRimLight && PARM_SET( info.iRimlightModLight ); const bool bBlendmodulate = bAlbedo2 && PARM_TEX( info.iBlendmodulate ); const bool bBlendmodulate2 = bBlendmodulate && PARM_TEX( info.iBlendmodulate2 ); const bool bBlendmodulate3 = bBlendmodulate && PARM_TEX( info.iBlendmodulate3 ); const bool bSelfIllum = !bAlbedo2 && IS_FLAG_SET( MATERIAL_VAR_SELFILLUM ); const bool bSelfIllumMaskInEnvmapMask = bSelfIllum && bEnvmapMask && PARM_SET( info.iSelfIllumMaskInEnvmapAlpha ); const bool bSelfIllumMask = bSelfIllum && !bSelfIllumMaskInEnvmapMask && !bEnvmapMask && PARM_TEX( info.iSelfIllumMask ); const bool bMultiBlend = PARM_SET( info.iMultiblend ) && bAlbedo && bAlbedo2 && bAlbedo3 && !bEnvmapMask && !bSelfIllumMask; const bool bNeedsFresnel = bPhongFresnel || bEnvmapFresnel; const bool bGBufferNormal = bEnvmap || bRimLight || bNeedsFresnel; const bool bWorldEyeVec = bGBufferNormal; AssertMsgOnce( !(bTranslucent || bAlphatest) || !bAlbedo2, "blended albedo not supported by gbuffer pass!" ); AssertMsgOnce( IS_FLAG_SET( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK ) == false, "Normal map sampling should stay out of composition pass." ); AssertMsgOnce( !PARM_TEX( info.iSelfIllumMask ) || !bEnvmapMask, "Can't use separate selfillum mask with envmap mask - use SELFILLUM_ENVMAPMASK_ALPHA instead." ); AssertMsgOnce( PARM_SET( info.iMultiblend ) == bMultiBlend, "Multiblend forced off due to invalid usage! May cause vertexformat mis-matches between passes." ); SHADOW_STATE { pShaderShadow->SetDefaultState(); pShaderShadow->EnableSRGBWrite( bUseSRGB ); if ( bNoCull ) { pShaderShadow->EnableCulling( false ); } int iVFmtFlags = VERTEX_POSITION; int iUserDataSize = 0; int *pTexCoordDim; int iTexCoordNum; GetTexcoordSettings( ( bModel && bIsDecal && bFastVTex ), bMultiBlend, iTexCoordNum, &pTexCoordDim ); if ( bModel ) { iVFmtFlags |= VERTEX_NORMAL; iVFmtFlags |= VERTEX_FORMAT_COMPRESSED; } else { if ( bAlbedo2 ) iVFmtFlags |= VERTEX_COLOR; } pShaderShadow->EnableTexture( SHADER_SAMPLER0, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, bUseSRGB ); if ( bGBufferNormal ) { pShaderShadow->EnableTexture( SHADER_SAMPLER1, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER1, false ); } if ( bTranslucent ) { pShader->EnableAlphaBlending( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE_MINUS_SRC_ALPHA ); } pShaderShadow->EnableTexture( SHADER_SAMPLER2, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER2, false ); if ( bEnvmap ) { pShaderShadow->EnableTexture( SHADER_SAMPLER3, true ); if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_NONE ) pShaderShadow->EnableSRGBRead( SHADER_SAMPLER3, true ); if ( bEnvmapMask ) { pShaderShadow->EnableTexture( SHADER_SAMPLER4, true ); if ( bAlbedo2 ) pShaderShadow->EnableTexture( SHADER_SAMPLER7, true ); } } else if ( bSelfIllumMask ) { pShaderShadow->EnableTexture( SHADER_SAMPLER4, true ); } if ( bAlbedo2 ) { pShaderShadow->EnableTexture( SHADER_SAMPLER5, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER5, bUseSRGB ); if ( bBlendmodulate ) pShaderShadow->EnableTexture( SHADER_SAMPLER6, true ); } if ( bMultiBlend ) { pShaderShadow->EnableTexture( SHADER_SAMPLER7, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER7, bUseSRGB ); if ( bAlbedo4 ) { pShaderShadow->EnableTexture( SHADER_SAMPLER8, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER8, bUseSRGB ); } if ( bBlendmodulate ) { pShaderShadow->EnableTexture( SHADER_SAMPLER9, true ); pShaderShadow->EnableTexture( SHADER_SAMPLER10, true ); } } pShaderShadow->EnableAlphaWrites( false ); pShaderShadow->EnableDepthWrites( !bTranslucent ); pShader->DefaultFog(); pShaderShadow->VertexShaderVertexFormat( iVFmtFlags, iTexCoordNum, pTexCoordDim, iUserDataSize ); DECLARE_STATIC_VERTEX_SHADER( composite_vs30 ); SET_STATIC_VERTEX_SHADER_COMBO( MODEL, bModel ); SET_STATIC_VERTEX_SHADER_COMBO( MORPHING_VTEX, bModel && bFastVTex ); SET_STATIC_VERTEX_SHADER_COMBO( DECAL, bModel && bIsDecal ); SET_STATIC_VERTEX_SHADER_COMBO( EYEVEC, bWorldEyeVec ); SET_STATIC_VERTEX_SHADER_COMBO( BASETEXTURE2, bAlbedo2 && !bMultiBlend ); SET_STATIC_VERTEX_SHADER_COMBO( BLENDMODULATE, bBlendmodulate ); SET_STATIC_VERTEX_SHADER_COMBO( MULTIBLEND, bMultiBlend ); SET_STATIC_VERTEX_SHADER( composite_vs30 ); DECLARE_STATIC_PIXEL_SHADER( composite_ps30 ); SET_STATIC_PIXEL_SHADER_COMBO( ALPHATEST, bAlphatest ); SET_STATIC_PIXEL_SHADER_COMBO( TRANSLUCENT, bTranslucent ); SET_STATIC_PIXEL_SHADER_COMBO( READNORMAL, bGBufferNormal ); SET_STATIC_PIXEL_SHADER_COMBO( NOCULL, bNoCull ); SET_STATIC_PIXEL_SHADER_COMBO( ENVMAP, bEnvmap ); SET_STATIC_PIXEL_SHADER_COMBO( ENVMAPMASK, bEnvmapMask ); SET_STATIC_PIXEL_SHADER_COMBO( ENVMAPFRESNEL, bEnvmapFresnel ); SET_STATIC_PIXEL_SHADER_COMBO( PHONGFRESNEL, bPhongFresnel ); SET_STATIC_PIXEL_SHADER_COMBO( RIMLIGHT, bRimLight ); SET_STATIC_PIXEL_SHADER_COMBO( RIMLIGHTMODULATELIGHT, bRimLightModLight ); SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE2, bAlbedo2 && !bMultiBlend ); SET_STATIC_PIXEL_SHADER_COMBO( BLENDMODULATE, bBlendmodulate ); SET_STATIC_PIXEL_SHADER_COMBO( MULTIBLEND, bMultiBlend ); SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, bSelfIllum ); SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM_MASK, bSelfIllumMask ); SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM_ENVMAP_ALPHA, bSelfIllumMaskInEnvmapMask ); SET_STATIC_PIXEL_SHADER( composite_ps30 ); } DYNAMIC_STATE { Assert( pDeferredContext != NULL ); if ( pDeferredContext->m_bMaterialVarsChanged || !pDeferredContext->HasCommands( CDeferredPerMaterialContextData::DEFSTAGE_COMPOSITE ) || building_cubemaps.GetBool() ) { tmpBuf.Reset(); if ( bAlphatest ) { PARM_VALIDATE( info.iAlphatestRef ); tmpBuf.SetPixelShaderConstant1( 0, PARM_FLOAT( info.iAlphatestRef ) ); } if ( bAlbedo ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER0, info.iAlbedo ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_GREY ); if ( bEnvmap ) { if ( building_cubemaps.GetBool() ) tmpBuf.BindStandardTexture( SHADER_SAMPLER3, TEXTURE_BLACK ); else { if ( PARM_TEX( info.iEnvmap ) && !bModel ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER3, info.iEnvmap ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER3, TEXTURE_LOCAL_ENV_CUBEMAP ); } if ( bEnvmapMask ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER4, info.iEnvmapMask ); if ( bAlbedo2 ) { if ( bEnvmapMask2 ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER7, info.iEnvmapMask2 ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER7, TEXTURE_WHITE ); } tmpBuf.SetPixelShaderConstant( 5, info.iEnvmapTint ); float fl6[4] = { 0 }; fl6[0] = PARM_FLOAT( info.iEnvmapSaturation ); fl6[1] = PARM_FLOAT( info.iEnvmapContrast ); tmpBuf.SetPixelShaderConstant( 6, fl6 ); } if ( bNeedsFresnel ) { tmpBuf.SetPixelShaderConstant( 7, info.iFresnelRanges ); } if ( bRimLight ) { float fl9[4] = { 0 }; fl9[0] = PARM_FLOAT( info.iRimlightExponent ); fl9[1] = PARM_FLOAT( info.iRimlightAlbedoScale ); tmpBuf.SetPixelShaderConstant( 9, fl9 ); } if ( bAlbedo2 ) { tmpBuf.BindTexture( pShader, SHADER_SAMPLER5, info.iAlbedo2 ); if ( bBlendmodulate ) { tmpBuf.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_1, info.iBlendmodulateTransform ); tmpBuf.BindTexture( pShader, SHADER_SAMPLER6, info.iBlendmodulate ); } } if ( bMultiBlend ) { tmpBuf.BindTexture( pShader, SHADER_SAMPLER7, info.iAlbedo3 ); if ( bAlbedo4 ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER8, info.iAlbedo4 ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER8, TEXTURE_WHITE ); if ( bBlendmodulate ) { tmpBuf.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_3, info.iBlendmodulateTransform2 ); tmpBuf.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_5, info.iBlendmodulateTransform3 ); if ( bBlendmodulate2 ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER9, info.iBlendmodulate2 ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER9, TEXTURE_BLACK ); if ( bBlendmodulate3 ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER10, info.iBlendmodulate3 ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER10, TEXTURE_BLACK ); } } if ( bSelfIllum && bSelfIllumMask ) { tmpBuf.BindTexture( pShader, SHADER_SAMPLER4, info.iSelfIllumMask ); } int x, y, w, t; pShaderAPI->GetCurrentViewport( x, y, w, t ); float fl1[4] = { 1.0f / w, 1.0f / t, 0, 0 }; tmpBuf.SetPixelShaderConstant( 1, fl1 ); tmpBuf.SetPixelShaderFogParams( 2 ); float fl4 = { PARM_FLOAT( info.iPhongScale ) }; tmpBuf.SetPixelShaderConstant1( 4, fl4 ); tmpBuf.End(); pDeferredContext->SetCommands( CDeferredPerMaterialContextData::DEFSTAGE_COMPOSITE, tmpBuf.Copy() ); } pShaderAPI->SetDefaultState(); if ( bModel && bFastVTex ) pShader->SetHWMorphVertexShaderState( VERTEX_SHADER_SHADER_SPECIFIC_CONST_10, VERTEX_SHADER_SHADER_SPECIFIC_CONST_11, SHADER_VERTEXTEXTURE_SAMPLER0 ); DECLARE_DYNAMIC_VERTEX_SHADER( composite_vs30 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (bModel && (int)vertexCompression) ? 1 : 0 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, (bModel && pShaderAPI->GetCurrentNumBones() > 0) ? 1 : 0 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( MORPHING, (bModel && pShaderAPI->IsHWMorphingEnabled()) ? 1 : 0 ); SET_DYNAMIC_VERTEX_SHADER( composite_vs30 ); DECLARE_DYNAMIC_PIXEL_SHADER( composite_ps30 ); SET_DYNAMIC_PIXEL_SHADER_COMBO( PIXELFOGTYPE, pShaderAPI->GetPixelFogCombo() ); SET_DYNAMIC_PIXEL_SHADER( composite_ps30 ); if ( bModel && bFastVTex ) { bool bUnusedTexCoords[3] = { false, true, !pShaderAPI->IsHWMorphingEnabled() || !bIsDecal }; pShaderAPI->MarkUnusedVertexFields( 0, 3, bUnusedTexCoords ); } pShaderAPI->ExecuteCommandBuffer( pDeferredContext->GetCommands( CDeferredPerMaterialContextData::DEFSTAGE_COMPOSITE ) ); if ( bGBufferNormal ) pShader->BindTexture( SHADER_SAMPLER1, GetDeferredExt()->GetTexture_Normals() ); pShader->BindTexture( SHADER_SAMPLER2, GetDeferredExt()->GetTexture_LightAccum() ); CommitBaseDeferredConstants_Origin( pShaderAPI, 3 ); if ( bWorldEyeVec ) { float vEyepos[4] = {0,0,0,0}; pShaderAPI->GetWorldSpaceCameraPosition( vEyepos ); pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, vEyepos ); } if ( bRimLight ) { pShaderAPI->SetPixelShaderConstant( 8, params[ info.iRimlightTint ]->GetVecValue() ); } if ( bSelfIllum ) { pShaderAPI->SetPixelShaderConstant( 10, params[ info.iSelfIllumTint ]->GetVecValue() ); } } pShader->Draw(); }
void DrawPhong_DX9( CBaseVSShader *pShader, IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow, VertexLitGeneric_DX9_Vars_t &info, VertexCompressionType_t vertexCompression, CBasePerMaterialContextData **pContextDataPtr, bool bDeferredActive ) { CPhong_DX9_Context *pContextData = reinterpret_cast< CPhong_DX9_Context *> ( *pContextDataPtr ); bool bHasFlashlight = !bDeferredActive && pShader->UsingFlashlight( params ); bool bHasFlashlightOnly = bHasFlashlight && !IsX360(); #ifndef _X360 bool bIsDecal = IS_FLAG_SET( MATERIAL_VAR_DECAL ); #endif bool bIsAlphaTested = IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) != 0; BlendType_t nBlendType = pShader->EvaluateBlendRequirements( info.m_nBaseTexture, true ); bool bFullyOpaque = (nBlendType != BT_BLENDADD) && (nBlendType != BT_BLEND) && !bIsAlphaTested && !bHasFlashlightOnly; //dest alpha is free for special use bool bHasDisplacement = (info.m_nDisplacementMap != -1) && params[info.m_nDisplacementMap]->IsTexture(); #if !defined( PLATFORM_X360 ) bool bHasDisplacementWrinkles = (info.m_nDisplacementWrinkleMap != -1) && params[info.m_nDisplacementWrinkleMap]->GetIntValue(); #endif bool bHasTeamColorTexture = ( info.m_nTeamColorTexture != -1 ) && params[info.m_nTeamColorTexture]->IsTexture(); bool bHasFoW = ( ( info.m_nFoW != -1 ) && ( params[ info.m_nFoW ]->IsTexture() != 0 ) ); bool bFOWValidTexture = true; if ( bHasFoW == true ) { ITexture *pTexture = params[ info.m_nFoW ]->GetTextureValue(); if ( ( pTexture->GetFlags() & TEXTUREFLAGS_RENDERTARGET ) == 0 ) { bHasFoW = true; bFOWValidTexture = false; } } else { bHasFoW = true; bFOWValidTexture = false; } if( pShader->IsSnapshotting() ) { PhongShaderInfo_t phongInfo; ComputePhongShaderInfo( pShader, params, info, bHasFlashlightOnly, &phongInfo ); bool bShaderSrgbRead = ( IsX360() && IS_PARAM_DEFINED( info.m_nShaderSrgbRead360 ) && params[info.m_nShaderSrgbRead360]->GetIntValue() ); int nDetailBlendMode = ( info.m_nDetailTextureCombineMode == -1 ) ? 0 : params[info.m_nDetailTextureCombineMode]->GetIntValue(); bool bHasVertexColor = IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR ); bool bHasVertexAlpha = IS_FLAG_SET( MATERIAL_VAR_VERTEXALPHA ); // look at color and alphamod stuff. // Unlit generic never uses the flashlight bool bHasEnvmap = !bHasFlashlightOnly && params[info.m_nEnvmap]->IsTexture(); // Alpha test: FIXME: shouldn't this be handled in CBaseVSShader::SetInitialShadowState pShaderShadow->EnableAlphaTest( bIsAlphaTested ); if( info.m_nAlphaTestReference != -1 && params[info.m_nAlphaTestReference]->GetFloatValue() > 0.0f ) { pShaderShadow->AlphaFunc( SHADER_ALPHAFUNC_GEQUAL, params[info.m_nAlphaTestReference]->GetFloatValue() ); } // Based upon vendor and device dependent formats int nShadowFilterMode = bHasFlashlight ? g_pHardwareConfig->GetShadowFilterMode() : 0; if( bHasFlashlightOnly ) { if (params[info.m_nBaseTexture]->IsTexture()) { pShader->SetAdditiveBlendingShadowState( info.m_nBaseTexture, true ); } if( bIsAlphaTested ) { // disable alpha test and use the zfunc zequals since alpha isn't guaranteed to // be the same on both the regular pass and the flashlight pass. pShaderShadow->EnableAlphaTest( false ); pShaderShadow->DepthFunc( SHADER_DEPTHFUNC_EQUAL ); } pShaderShadow->EnableBlending( true ); pShaderShadow->EnableDepthWrites( false ); // Be sure not to write to dest alpha pShaderShadow->EnableAlphaWrites( false ); } if ( !bHasFlashlightOnly ) // not flashlight pass { if (params[info.m_nBaseTexture]->IsTexture()) { pShader->SetDefaultBlendingShadowState( info.m_nBaseTexture, true ); } if ( bHasEnvmap ) { pShaderShadow->EnableTexture( SHADER_SAMPLER8, true ); // Cubic environment map if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_NONE ) { pShaderShadow->EnableSRGBRead( SHADER_SAMPLER8, true ); } } } unsigned int flags = VERTEX_POSITION | VERTEX_NORMAL; int userDataSize = 0; // Always enable...will bind white if nothing specified... pShaderShadow->EnableTexture( SHADER_SAMPLER0, true ); // Base (albedo) map pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, !bShaderSrgbRead ); if ( !bHasFoW && !bDeferredActive && (phongInfo.m_bHasBaseTextureWrinkle) ) { pShaderShadow->EnableTexture( SHADER_SAMPLER9, true ); // Base (albedo) compression map pShaderShadow->EnableSRGBRead( SHADER_SAMPLER9, !bShaderSrgbRead ); pShaderShadow->EnableTexture( SHADER_SAMPLER10, true ); // Base (albedo) stretch map pShaderShadow->EnableSRGBRead( SHADER_SAMPLER10, !bShaderSrgbRead ); } if( phongInfo.m_bHasDiffuseWarp ) { pShaderShadow->EnableTexture( SHADER_SAMPLER2, true ); // Diffuse warp texture } if( phongInfo.m_bHasPhongWarp ) { pShaderShadow->EnableTexture( SHADER_SAMPLER1, true ); // Specular warp texture } // Specular exponent map or dummy pShaderShadow->EnableTexture( SHADER_SAMPLER7, true ); // Specular exponent map if( bHasFlashlight ) { pShaderShadow->EnableTexture( SHADER_SAMPLER4, true ); // Shadow depth map pShaderShadow->SetShadowDepthFiltering( SHADER_SAMPLER4 ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER4, false ); pShaderShadow->EnableTexture( SHADER_SAMPLER5, true ); // Noise map pShaderShadow->EnableTexture( SHADER_SAMPLER6, true ); // Flashlight cookie } // Always enable, since flat normal will be bound pShaderShadow->EnableTexture( SHADER_SAMPLER3, true ); // Normal map userDataSize = 4; // tangent S pShaderShadow->EnableTexture( SHADER_SAMPLER5, true ); // Normalizing cube map if ( !bHasFoW && !bDeferredActive && (phongInfo.m_bHasBumpWrinkle || phongInfo.m_bHasBaseTextureWrinkle) ) { pShaderShadow->EnableTexture( SHADER_SAMPLER11, true ); // Normal compression map pShaderShadow->EnableSRGBRead( SHADER_SAMPLER11, false ); pShaderShadow->EnableTexture( SHADER_SAMPLER12, true ); // Normal stretch map pShaderShadow->EnableSRGBRead( SHADER_SAMPLER12, false ); } if( bHasFoW ) { pShaderShadow->EnableTexture( SHADER_SAMPLER9, true ); } if( bDeferredActive ) { pShaderShadow->EnableTexture( SHADER_SAMPLER10, true ); pShaderShadow->EnableTexture( SHADER_SAMPLER11, true ); } if ( phongInfo.m_bHasDetailTexture ) { pShaderShadow->EnableTexture( SHADER_SAMPLER13, true ); if ( nDetailBlendMode != 0 ) //Not Mod2X { pShaderShadow->EnableSRGBRead( SHADER_SAMPLER13, true ); } } if ( phongInfo.m_bHasSelfIllum ) { pShaderShadow->EnableTexture( SHADER_SAMPLER14, true ); } if( bHasVertexColor || bHasVertexAlpha ) { flags |= VERTEX_COLOR; } // Always enable ambient occlusion sampler on PC on DX10 parts if ( IsPC() && g_pHardwareConfig->HasFastVertexTextures() ) { pShaderShadow->EnableTexture( SHADER_SAMPLER15, true ); } if( bHasTeamColorTexture ) { pShaderShadow->EnableTexture( SHADER_SAMPLER12, true ); } if ( bHasDisplacement && IsPC() && g_pHardwareConfig->HasFastVertexTextures() ) { pShaderShadow->EnableVertexTexture( SHADER_VERTEXTEXTURE_SAMPLER2, true ); } pShaderShadow->EnableSRGBWrite( true ); // texcoord0 : base texcoord, texcoord2 : decal hw morph delta int pTexCoordDim[3] = { 2, 0, 3 }; int nTexCoordCount = 1; #ifndef _X360 // Special morphed decal information if ( bIsDecal && g_pHardwareConfig->HasFastVertexTextures() ) { nTexCoordCount = 3; } #endif // This shader supports compressed vertices, so OR in that flag: flags |= VERTEX_FORMAT_COMPRESSED; pShaderShadow->VertexShaderVertexFormat( flags, nTexCoordCount, pTexCoordDim, userDataSize ); #if !defined( PLATFORM_X360 ) bool bWorldNormal = ( ENABLE_FIXED_LIGHTING_OUTPUTNORMAL_AND_DEPTH == ( IS_FLAG2_SET( MATERIAL_VAR2_USE_GBUFFER0 ) + 2 * IS_FLAG2_SET( MATERIAL_VAR2_USE_GBUFFER1 ))); #endif // This is to allow phong materials to disable half lambert. Half lambert has always been forced on in phong, // so the only safe way to allow artists to disable half lambert is to create this param that disables the // default behavior of forcing half lambert on. bool bPhongHalfLambert = IS_PARAM_DEFINED( info.m_nPhongDisableHalfLambert ) ? ( params[ info.m_nPhongDisableHalfLambert ]->GetIntValue() == 0 ) : true; if ( g_pHardwareConfig->HasFastVertexTextures() ) { // The vertex shader uses the vertex id stream SET_FLAGS2( MATERIAL_VAR2_USES_VERTEXID ); SET_FLAGS2( MATERIAL_VAR2_SUPPORTS_TESSELLATION ); } DECLARE_STATIC_VERTEX_SHADER( phong_vs30 ); SET_STATIC_VERTEX_SHADER_COMBO( WORLD_NORMAL, bWorldNormal ); SET_STATIC_VERTEX_SHADER_COMBO( DECAL, bIsDecal ); SET_STATIC_VERTEX_SHADER_COMBO( FOW, bHasFoW ); SET_STATIC_VERTEX_SHADER( phong_vs30 ); if( bDeferredActive ) { DECLARE_STATIC_PIXEL_SHADER( phong_deferred_ps30 ); SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, bHasFlashlight ); SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, phongInfo.m_bHasSelfIllum && !bHasFlashlightOnly ); SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUMFRESNEL, phongInfo.m_bHasSelfIllumFresnel && !bHasFlashlightOnly ); SET_STATIC_PIXEL_SHADER_COMBO( LIGHTWARPTEXTURE, phongInfo.m_bHasDiffuseWarp && phongInfo.m_bHasPhong ); SET_STATIC_PIXEL_SHADER_COMBO( PHONGWARPTEXTURE, phongInfo.m_bHasPhongWarp && phongInfo.m_bHasPhong ); //SET_STATIC_PIXEL_SHADER_COMBO( WRINKLEMAP, !bHasFoW && phongInfo.m_bHasBaseTextureWrinkle ); SET_STATIC_PIXEL_SHADER_COMBO( DETAILTEXTURE, phongInfo.m_bHasDetailTexture ); SET_STATIC_PIXEL_SHADER_COMBO( DETAIL_BLEND_MODE, nDetailBlendMode ); SET_STATIC_PIXEL_SHADER_COMBO( RIMLIGHT, phongInfo.m_bHasRimLight ); SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, bHasEnvmap ); SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHTDEPTHFILTERMODE, nShadowFilterMode ); SET_STATIC_PIXEL_SHADER_COMBO( SHADER_SRGB_READ, bShaderSrgbRead ); SET_STATIC_PIXEL_SHADER_COMBO( WORLD_NORMAL, bWorldNormal ); SET_STATIC_PIXEL_SHADER_COMBO( PHONG_HALFLAMBERT, bPhongHalfLambert ); SET_STATIC_PIXEL_SHADER_COMBO( TEAMCOLORTEXTURE, bHasTeamColorTexture ); //SET_STATIC_PIXEL_SHADER_COMBO( FOW, /*bHasFoW*/ 1 ); SET_STATIC_PIXEL_SHADER( phong_deferred_ps30 ); } else { DECLARE_STATIC_PIXEL_SHADER( phong_ps30 ); SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHT, bHasFlashlight ); SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, phongInfo.m_bHasSelfIllum && !bHasFlashlightOnly ); SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUMFRESNEL, phongInfo.m_bHasSelfIllumFresnel && !bHasFlashlightOnly ); SET_STATIC_PIXEL_SHADER_COMBO( LIGHTWARPTEXTURE, phongInfo.m_bHasDiffuseWarp && phongInfo.m_bHasPhong ); SET_STATIC_PIXEL_SHADER_COMBO( PHONGWARPTEXTURE, phongInfo.m_bHasPhongWarp && phongInfo.m_bHasPhong ); //SET_STATIC_PIXEL_SHADER_COMBO( WRINKLEMAP, !bHasFoW && phongInfo.m_bHasBaseTextureWrinkle ); SET_STATIC_PIXEL_SHADER_COMBO( DETAILTEXTURE, phongInfo.m_bHasDetailTexture ); SET_STATIC_PIXEL_SHADER_COMBO( DETAIL_BLEND_MODE, nDetailBlendMode ); SET_STATIC_PIXEL_SHADER_COMBO( RIMLIGHT, phongInfo.m_bHasRimLight ); SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, bHasEnvmap ); SET_STATIC_PIXEL_SHADER_COMBO( FLASHLIGHTDEPTHFILTERMODE, nShadowFilterMode ); SET_STATIC_PIXEL_SHADER_COMBO( SHADER_SRGB_READ, bShaderSrgbRead ); SET_STATIC_PIXEL_SHADER_COMBO( WORLD_NORMAL, bWorldNormal ); SET_STATIC_PIXEL_SHADER_COMBO( PHONG_HALFLAMBERT, bPhongHalfLambert ); SET_STATIC_PIXEL_SHADER_COMBO( TEAMCOLORTEXTURE, bHasTeamColorTexture ); //SET_STATIC_PIXEL_SHADER_COMBO( FOW, /*bHasFoW*/ 1 ); SET_STATIC_PIXEL_SHADER( phong_ps30 ); } if( bHasFlashlightOnly ) { pShader->FogToBlack(); } else { pShader->DefaultFog(); } // HACK HACK HACK - enable alpha writes all the time so that we have them for underwater stuff pShaderShadow->EnableAlphaWrites( bFullyOpaque ); pShader->PI_BeginCommandBuffer(); pShader->PI_SetPixelShaderAmbientLightCube( PSREG_AMBIENT_CUBE ); pShader->PI_SetPixelShaderLocalLighting( PSREG_LIGHT_INFO_ARRAY ); pShader->PI_SetVertexShaderAmbientLightCube(); // material can opt out of per-instance modulation via $nodiffusemodulation bool bAllowDiffuseModulation = ( info.m_nAllowDiffuseModulation == -1 ) ? true : ( params[info.m_nAllowDiffuseModulation]->GetIntValue() != 0 ); if ( bAllowDiffuseModulation ) { pShader->PI_SetModulationPixelShaderDynamicState_LinearColorSpace( 1 ); } else { pShader->PI_SetModulationPixelShaderDynamicState_Identity( 1 ); } pShader->PI_EndCommandBuffer(); } else // not snapshotting -- begin dynamic state { // Deal with semisatic if ( ( !pContextData ) || ( pContextData->m_bMaterialVarsChanged ) ) { if ( !pContextData ) // make sure allocated { pContextData = new CPhong_DX9_Context; *pContextDataPtr = pContextData; } pContextData->m_SemiStaticCmdsOut.Reset(); pContextData->m_bMaterialVarsChanged = false; PhongShaderInfo_t phongInfo; ComputePhongShaderInfo( pShader, params, info, bHasFlashlightOnly, &phongInfo ); bool bHasBump = (info.m_nBumpmap != -1) && params[info.m_nBumpmap]->IsTexture(); bool bLightingOnly = mat_fullbright.GetInt() == 2 && !IS_FLAG_SET( MATERIAL_VAR_NO_DEBUG_OVERRIDE ); bool bHasSelfIllumMask = ( phongInfo.m_bHasSelfIllum ) && (info.m_nSelfIllumMask != -1) && params[info.m_nSelfIllumMask]->IsTexture(); float fBlendFactor = ( info.m_nDetailTextureBlendFactor == -1 )? 1 : params[info.m_nDetailTextureBlendFactor]->GetFloatValue(); bool bHasSpecularExponentTexture = (info.m_nPhongExponentTexture != -1) && params[info.m_nPhongExponentTexture]->IsTexture(); bool bHasPhongTintMap = bHasSpecularExponentTexture && (info.m_nPhongAlbedoTint != -1) && ( params[info.m_nPhongAlbedoTint]->GetIntValue() != 0 ); bool bHasNormalMapAlphaEnvmapMask = IS_FLAG_SET( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK ); bool bHasRimMaskMap = bHasSpecularExponentTexture && phongInfo.m_bHasRimLight && (info.m_nRimMask != -1) && ( params[info.m_nRimMask]->GetIntValue() != 0 ); bool bHasSinglePassFlashlight = IsX360(); // NOTE: If you change this, fix state.m_nDepthTweakConstant below! And, deal with SINGLE_PASS_FLASHLIGHT in phong_ps20b.fxc if( phongInfo.m_bHasBaseTexture ) { pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER0, info.m_nBaseTexture, info.m_nBaseTextureFrame ); } else { pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_WHITE ); } if ( !bHasFoW && !bDeferredActive && phongInfo.m_bHasBaseTextureWrinkle ) { pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER9, info.m_nWrinkle, info.m_nBaseTextureFrame ); pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER10, info.m_nStretch, info.m_nBaseTextureFrame ); } if( phongInfo.m_bHasDiffuseWarp && phongInfo.m_bHasPhong ) { if ( r_lightwarpidentity.GetBool() ) { pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER2, TEXTURE_IDENTITY_LIGHTWARP ); } else { pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER2, info.m_nDiffuseWarpTexture ); } } if( phongInfo.m_bHasPhongWarp ) { pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER1, info.m_nPhongWarpTexture ); } if( bHasSpecularExponentTexture && phongInfo.m_bHasPhong ) { pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER7, info.m_nPhongExponentTexture ); } else { pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER7, TEXTURE_WHITE ); } if( !g_pConfig->m_bFastNoBump ) { if( bHasBump ) pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER3, info.m_nBumpmap, info.m_nBumpFrame ); else pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER3, TEXTURE_NORMALMAP_FLAT ); if ( !bHasFoW && !bDeferredActive && phongInfo.m_bHasBumpWrinkle ) { pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER11, info.m_nNormalWrinkle, info.m_nBumpFrame ); pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER12, info.m_nNormalStretch, info.m_nBumpFrame ); } else if ( !bHasFoW && !bDeferredActive && phongInfo.m_bHasBaseTextureWrinkle ) { pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER11, info.m_nBumpmap, info.m_nBumpFrame ); pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER12, info.m_nBumpmap, info.m_nBumpFrame ); } } else // Just flat bump maps { if ( bHasBump ) { pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER3, TEXTURE_NORMALMAP_FLAT ); } if ( !bHasFoW && !bDeferredActive && phongInfo.m_bHasBaseTextureWrinkle || phongInfo.m_bHasBumpWrinkle ) { pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER11, TEXTURE_NORMALMAP_FLAT ); pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER12, TEXTURE_NORMALMAP_FLAT ); } } if ( phongInfo.m_bHasDetailTexture ) { pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER13, info.m_nDetail, info.m_nDetailFrame ); } if ( phongInfo.m_bHasSelfIllum ) { if ( bHasSelfIllumMask ) // Separate texture for self illum? { pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER14, info.m_nSelfIllumMask ); // Bind it } else // else { pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER14, TEXTURE_BLACK ); // Bind dummy } } if( !bHasFlashlightOnly ) { if ( phongInfo.m_bHasEnvmap ) { pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER8, info.m_nEnvmap, info.m_nEnvmapFrame ); } } pContextData->m_SemiStaticCmdsOut.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, info.m_nBaseTextureTransform ); if( bHasBump ) { pContextData->m_SemiStaticCmdsOut.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, info.m_nBumpTransform ); } if ( phongInfo.m_bHasDetailTexture ) { if ( IS_PARAM_DEFINED( info.m_nDetailTextureTransform ) ) { pContextData->m_SemiStaticCmdsOut.SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4, info.m_nDetailTextureTransform, info.m_nDetailScale ); } else { pContextData->m_SemiStaticCmdsOut.SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4, info.m_nBaseTextureTransform, info.m_nDetailScale ); } } pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant_W( PSREG_SELFILLUMTINT, info.m_nSelfIllumTint, fBlendFactor ); bool bInvertPhongMask = ( info.m_nInvertPhongMask != -1 ) && ( params[info.m_nInvertPhongMask]->GetIntValue() != 0 ); float fInvertPhongMask = bInvertPhongMask ? 1 : 0; bool bHasBaseAlphaPhongMask = (info.m_nBaseMapAlphaPhongMask != -1) && ( params[info.m_nBaseMapAlphaPhongMask]->GetIntValue() != 0 ); float fHasBaseAlphaPhongMask = bHasBaseAlphaPhongMask ? 1 : 0; bool bBlendTintByBaseAlpha = (info.m_nBlendTintByBaseAlpha != -1) && ( params[info.m_nBlendTintByBaseAlpha]->GetIntValue() != 0 ); float fBlendTintByBaseAlpha = bBlendTintByBaseAlpha ? 1 : 0; // Controls for lerp-style paths through shader code float vShaderControls[4] = { fHasBaseAlphaPhongMask, 0.0f, 1.0f-fBlendTintByBaseAlpha, fInvertPhongMask }; pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( PSREG_SHADER_CONTROLS, vShaderControls, 1 ); if ( phongInfo.m_bHasSelfIllumFresnel && !bHasFlashlightOnly ) { float vConstScaleBiasExp[4] = { 1.0f, 0.0f, 1.0f, 0.0f }; float flMin = IS_PARAM_DEFINED( info.m_nSelfIllumFresnelMinMaxExp ) ? params[info.m_nSelfIllumFresnelMinMaxExp]->GetVecValue()[0] : 0.0f; float flMax = IS_PARAM_DEFINED( info.m_nSelfIllumFresnelMinMaxExp ) ? params[info.m_nSelfIllumFresnelMinMaxExp]->GetVecValue()[1] : 1.0f; float flExp = IS_PARAM_DEFINED( info.m_nSelfIllumFresnelMinMaxExp ) ? params[info.m_nSelfIllumFresnelMinMaxExp]->GetVecValue()[2] : 1.0f; vConstScaleBiasExp[1] = ( flMax != 0.0f ) ? ( flMin / flMax ) : 0.0f; // Bias vConstScaleBiasExp[0] = 1.0f - vConstScaleBiasExp[1]; // Scale vConstScaleBiasExp[2] = flExp; // Exp vConstScaleBiasExp[3] = flMax; // Brightness pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( PSREG_SELFILLUM_SCALE_BIAS_EXP, vConstScaleBiasExp, 1 ); } if( !bHasFlashlightOnly ) { pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER5, TEXTURE_NORMALIZATION_CUBEMAP_SIGNED ); if( phongInfo.m_bHasEnvmap ) { float vEnvMapTint_MaskControl[4] = {1.0f, 1.0f, 1.0f, 0.0f}; // If we have a tint, grab it if ( (info.m_nEnvmapTint != -1) && params[info.m_nEnvmapTint]->IsDefined() ) params[info.m_nEnvmapTint]->GetVecValue(vEnvMapTint_MaskControl, 3); // Set control for source of env map mask (normal alpha or base alpha) vEnvMapTint_MaskControl[3] = bHasNormalMapAlphaEnvmapMask ? 1.0f : 0.0f; // Handle mat_fullbright 2 (diffuse lighting only with 50% gamma space basetexture) if( bLightingOnly ) { vEnvMapTint_MaskControl[0] = vEnvMapTint_MaskControl[1] = vEnvMapTint_MaskControl[2] = 0.0f; } pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( PSREG_ENVMAP_TINT__SHADOW_TWEAKS, vEnvMapTint_MaskControl, 1 ); } } // Pack Phong exponent in with the eye position float vSpecularTint[4] = {1, 1, 1, 4}; float vFresnelRanges_SpecBoost[4] = {0, 0.5, 1, 1}, vRimBoost[4] = {1, 1, 1, 1}; // Get the tint parameter if ( (info.m_nPhongTint != -1) && params[info.m_nPhongTint]->IsDefined() ) { params[info.m_nPhongTint]->GetVecValue(vSpecularTint, 3); } // Get the rim light power (goes in w of Phong tint) if ( phongInfo.m_bHasRimLight && (info.m_nRimLightPower != -1) && params[info.m_nRimLightPower]->IsDefined() ) { vSpecularTint[3] = params[info.m_nRimLightPower]->GetFloatValue(); vSpecularTint[3] = MAX(vSpecularTint[3], 1.0f); // Make sure this is at least 1 } // Get the rim boost (goes in w of flashlight position) if ( phongInfo.m_bHasRimLight && (info.m_nRimLightBoost != -1) && params[info.m_nRimLightBoost]->IsDefined() ) { vRimBoost[3] = params[info.m_nRimLightBoost]->GetFloatValue(); } // Single pass flashlight has to use a separate constant for this stuff since a flashlight constant is repurposed for rimlighting when doing multi-pass flashlight. if ( phongInfo.m_bHasRimLight ) { if ( bHasSinglePassFlashlight ) { float vRimParams[4] = {0, 0, 0, 0}; vRimParams[0] = bHasRimMaskMap ? params[info.m_nRimMask]->GetFloatValue() : 0.0f; vRimParams[1] = params[info.m_nRimLightBoost]->GetFloatValue(); // Rim mask...if this is true, use alpha channel of spec exponent texture to mask the rim term pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( PSREG_RIMPARAMS, vRimParams, 1 ); } else if ( !bHasFlashlight ) { float vRimMaskControl[4] = {0, 0, 0, 0}; // Only x is relevant in shader code vRimMaskControl[0] = bHasRimMaskMap ? params[info.m_nRimMask]->GetFloatValue() : 0.0f; // Rim mask...if this is true, use alpha channel of spec exponent texture to mask the rim term pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( PSREG_FLASHLIGHT_ATTENUATION, vRimMaskControl, 1 ); } } // If it's all zeros, there was no constant tint in the vmt if ( (vSpecularTint[0] == 0.0f) && (vSpecularTint[1] == 0.0f) && (vSpecularTint[2] == 0.0f) ) { if ( bHasPhongTintMap ) // If we have a map to use, tell the shader { vSpecularTint[0] = -1; } else // Otherwise, just tint with white { vSpecularTint[0] = 1.0f; vSpecularTint[1] = 1.0f; vSpecularTint[2] = 1.0f; } } // handle mat_fullbright 2 (diffuse lighting only) if( bLightingOnly ) { // BASETEXTURE if( phongInfo.m_bHasSelfIllum && !bHasFlashlightOnly ) { pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_GREY_ALPHA_ZERO ); if ( phongInfo.m_bHasBaseTextureWrinkle || phongInfo.m_bHasBumpWrinkle ) { pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER9, TEXTURE_GREY_ALPHA_ZERO ); // Compressed wrinklemap pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER10, TEXTURE_GREY_ALPHA_ZERO ); // Stretched wrinklemap } } else { pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_GREY ); if ( phongInfo.m_bHasBaseTextureWrinkle || phongInfo.m_bHasBumpWrinkle ) { pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER9, TEXTURE_GREY ); // Compressed wrinklemap pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER10, TEXTURE_GREY ); // Stretched wrinklemap } } // DETAILTEXTURE if ( phongInfo.m_bHasDetailTexture ) { pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER13, TEXTURE_GREY ); } // turn off specularity vSpecularTint[0] = vSpecularTint[1] = vSpecularTint[2] = 0.0f; } if ( (info.m_nPhongFresnelRanges != -1) && params[info.m_nPhongFresnelRanges]->IsDefined() ) { params[info.m_nPhongFresnelRanges]->GetVecValue( vFresnelRanges_SpecBoost, 3 ); // Grab optional Fresnel range parameters } if ( (info.m_nPhongBoost != -1 ) && params[info.m_nPhongBoost]->IsDefined()) // Grab optional Phong boost param { vFresnelRanges_SpecBoost[3] = params[info.m_nPhongBoost]->GetFloatValue(); } else { vFresnelRanges_SpecBoost[3] = 1.0f; } bool bHasBaseLuminancePhongMask = (info.m_nBaseMapLuminancePhongMask != -1) && ( params[info.m_nBaseMapLuminancePhongMask]->GetIntValue() != 0 ); float fHasBaseLuminancePhongMask = bHasBaseLuminancePhongMask ? 1 : 0; float vShaderControls2[4] = {0.0f, fHasBaseLuminancePhongMask, 0.0f, 0.0f}; if ( !bHasFlashlightOnly ) { if ( phongInfo.m_bHasEnvmap ) { if ( (info.m_nEnvmapFresnel != -1) && params[info.m_nEnvmapFresnel]->IsDefined() ) { vShaderControls2[0] = params[info.m_nEnvmapFresnel]->GetFloatValue(); } } } if ( (info.m_nPhongExponent != -1) && params[info.m_nPhongExponent]->IsDefined() ) { vShaderControls2[2] = params[info.m_nPhongExponent]->GetFloatValue(); // This overrides the channel in the map } else { vShaderControls2[2] = 0; // Use the alpha channel of the normal map for the exponent } vShaderControls2[3] = bHasSelfIllumMask ? 1.0f : 0.0f; pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( PSREG_FRESNEL_SPEC_PARAMS, vFresnelRanges_SpecBoost, 1 ); pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( PSREG_FLASHLIGHT_POSITION_RIM_BOOST, vRimBoost, 1 ); // Rim boost in w on non-flashlight pass pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( PSREG_SPEC_RIM_PARAMS, vSpecularTint, 1 ); pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( PSREG_SHADER_CONTROLS_2, vShaderControls2, 1 ); pContextData->m_SemiStaticCmdsOut.SetPixelShaderFogParams( PSREG_FOG_PARAMS ); if ( bHasFlashlight ) { CBCmdSetPixelShaderFlashlightState_t state; state.m_LightSampler = SHADER_SAMPLER6; state.m_DepthSampler = SHADER_SAMPLER4; state.m_ShadowNoiseSampler = SHADER_SAMPLER5; state.m_nColorConstant = PSREG_FLASHLIGHT_COLOR; state.m_nAttenConstant = PSREG_FLASHLIGHT_ATTENUATION; state.m_nOriginConstant = PSREG_FLASHLIGHT_POSITION_RIM_BOOST; state.m_nDepthTweakConstant = bHasSinglePassFlashlight ? 43 : PSREG_ENVMAP_TINT__SHADOW_TWEAKS; // NOTE: Reg 43 not available on < ps3.0! state.m_nScreenScaleConstant = PSREG_FLASHLIGHT_SCREEN_SCALE; state.m_nWorldToTextureConstant = PSREG_FLASHLIGHT_TO_WORLD_TEXTURE; state.m_bFlashlightNoLambert = false; state.m_bSinglePassFlashlight = bHasSinglePassFlashlight; pContextData->m_SemiStaticCmdsOut.SetPixelShaderFlashlightState( state ); if ( !IsX360() && ( g_pHardwareConfig->GetDXSupportLevel() > 92 ) ) { pContextData->m_SemiStaticCmdsOut.SetPixelShaderUberLightState( PSREG_UBERLIGHT_SMOOTH_EDGE_0, PSREG_UBERLIGHT_SMOOTH_EDGE_1, PSREG_UBERLIGHT_SMOOTH_EDGE_OOW, PSREG_UBERLIGHT_SHEAR_ROUND, PSREG_UBERLIGHT_AABB, PSREG_UBERLIGHT_WORLD_TO_LIGHT ); } } // Team color constant + sampler if( bHasTeamColorTexture ) { static const float kDefaultTeamColor[4] = { 0.0f, 0.0f, 0.0f, 0.0f }; const float *vecTeamColor = IS_PARAM_DEFINED( info.m_nTeamColor ) ? params[info.m_nTeamColor]->GetVecValue() : kDefaultTeamColor; pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( PSREG_RIMPARAMS, vecTeamColor, 1 ); pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER12, info.m_nTeamColorTexture, -1 ); } pContextData->m_SemiStaticCmdsOut.End(); } CCommandBufferBuilder< CFixedCommandStorageBuffer< 1000 > > DynamicCmdsOut; DynamicCmdsOut.Call( pContextData->m_SemiStaticCmdsOut.Base() ); // On PC, we sample from ambient occlusion texture if ( IsPC() && g_pHardwareConfig->HasFastVertexTextures() ) { ITexture *pAOTexture = pShaderAPI->GetTextureRenderingParameter( TEXTURE_RENDERPARM_AMBIENT_OCCLUSION ); if ( pAOTexture ) { DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER15, pAOTexture, 0 ); } else { DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER15, TEXTURE_WHITE ); } } bool bFlashlightShadows = false; bool bUberlight = false; float flAmbientOcclusionStrength = ( info.m_nAmbientOcclusion == -1 ) ? 0.0f : params[info.m_nAmbientOcclusion]->GetFloatValue(); if ( bHasFlashlight ) { pShaderAPI->GetFlashlightShaderInfo( &bFlashlightShadows, &bUberlight ); flAmbientOcclusionStrength *= pShaderAPI->GetFlashlightAmbientOcclusion(); } float vEyePos_AmbientOcclusion[4]; pShaderAPI->GetWorldSpaceCameraPosition( vEyePos_AmbientOcclusion ); vEyePos_AmbientOcclusion[3] = clamp( flAmbientOcclusionStrength, 0.0f, 1.0f ); DynamicCmdsOut.SetPixelShaderConstant( PSREG_EYEPOS_SPEC_EXPONENT, vEyePos_AmbientOcclusion, 1 ); MaterialFogMode_t fogType = pShaderAPI->GetSceneFogMode(); int numBones = pShaderAPI->GetCurrentNumBones(); bool bWriteDepthToAlpha = false; bool bWriteWaterFogToAlpha = false; if( bFullyOpaque ) { bWriteDepthToAlpha = pShaderAPI->ShouldWriteDepthToDestAlpha(); bWriteWaterFogToAlpha = (fogType == MATERIAL_FOG_LINEAR_BELOW_FOG_Z); AssertMsg( !(bWriteDepthToAlpha && bWriteWaterFogToAlpha), "Can't write two values to alpha at the same time." ); } LightState_t lightState = { 0, false, false }; if( !bHasFlashlightOnly ) { pShaderAPI->GetDX9LightState( &lightState ); } if ( bHasFoW ) { if( bFOWValidTexture ) pShader->BindTexture( SHADER_SAMPLER9, info.m_nFoW, -1 ); else pShaderAPI->BindStandardTexture( SHADER_SAMPLER9, TEXTURE_WHITE ); float vFoWSize[ 4 ]; Vector vMins = pShaderAPI->GetVectorRenderingParameter( VECTOR_RENDERPARM_GLOBAL_FOW_MINS ); Vector vMaxs = pShaderAPI->GetVectorRenderingParameter( VECTOR_RENDERPARM_GLOBAL_FOW_MAXS ); vFoWSize[ 0 ] = vMins.x; vFoWSize[ 1 ] = vMins.y; vFoWSize[ 2 ] = vMaxs.x - vMins.x; vFoWSize[ 3 ] = vMaxs.y - vMins.y; pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_10, vFoWSize ); } if( bDeferredActive ) { pShader->BindTexture( SHADER_SAMPLER10, GetDeferredExt()->GetTexture_LightAccum() ); pShader->BindTexture( SHADER_SAMPLER11, GetDeferredExt()->GetTexture_LightAccum2() ); int x, y, w, t; pShaderAPI->GetCurrentViewport( x, y, w, t ); float fl1[4] = { 1.0f / w, 1.0f / t, 0, 0 }; pShaderAPI->SetPixelShaderConstant( PSREG_UBERLIGHT_SMOOTH_EDGE_0, fl1 ); } pShader->SetHWMorphVertexShaderState( VERTEX_SHADER_SHADER_SPECIFIC_CONST_6, VERTEX_SHADER_SHADER_SPECIFIC_CONST_7, SHADER_VERTEXTEXTURE_SAMPLER0 ); int nLightingPreviewMode = pShaderAPI->GetIntRenderingParameter( INT_RENDERPARM_ENABLE_FIXED_LIGHTING ); if ( ( nLightingPreviewMode == ENABLE_FIXED_LIGHTING_OUTPUTNORMAL_AND_DEPTH ) && IsPC() ) { float vEyeDir[4]; pShaderAPI->GetWorldSpaceCameraDirection( vEyeDir ); float flFarZ = pShaderAPI->GetFarZ(); vEyeDir[0] /= flFarZ; // Divide by farZ for SSAO algorithm vEyeDir[1] /= flFarZ; vEyeDir[2] /= flFarZ; pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_8, vEyeDir ); } TessellationMode_t nTessellationMode = pShaderAPI->GetTessellationMode(); if ( nTessellationMode != TESSELLATION_MODE_DISABLED && g_pHardwareConfig->HasFastVertexTextures() ) { pShaderAPI->BindStandardVertexTexture( SHADER_VERTEXTEXTURE_SAMPLER1, TEXTURE_SUBDIVISION_PATCHES ); float vSubDDimensions[4] = { 1.0f/pShaderAPI->GetSubDHeight(), bHasDisplacement && mat_displacementmap.GetBool() ? 1.0f : 0.0f, bHasDisplacementWrinkles && mat_displacementmap.GetBool() ? 1.0f : 0.0f, 0.0f }; pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_9, vSubDDimensions ); if( bHasDisplacement ) { pShader->BindVertexTexture( SHADER_VERTEXTEXTURE_SAMPLER2, info.m_nDisplacementMap ); } else { pShaderAPI->BindStandardVertexTexture( SHADER_VERTEXTEXTURE_SAMPLER2, TEXTURE_BLACK ); } // Currently, tessellation is mutually exclusive with any kind of GPU-side skinning, morphing or vertex compression Assert( !pShaderAPI->IsHWMorphingEnabled() ); Assert( numBones == 0 ); Assert( vertexCompression == 0); } else { nTessellationMode = TESSELLATION_MODE_DISABLED; } DECLARE_DYNAMIC_VERTEX_SHADER( phong_vs30 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, ( numBones > 0) && ( nTessellationMode == TESSELLATION_MODE_DISABLED ) ); SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (int)vertexCompression && ( nTessellationMode == TESSELLATION_MODE_DISABLED ) ); SET_DYNAMIC_VERTEX_SHADER_COMBO( TESSELLATION, nTessellationMode ); SET_DYNAMIC_VERTEX_SHADER( phong_vs30 ); if( bDeferredActive ) { DECLARE_DYNAMIC_PIXEL_SHADER( phong_deferred_ps30 ); SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_LIGHTS, nLightingPreviewMode ? 0 : lightState.m_nNumLights ); SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, nLightingPreviewMode ? false : bWriteWaterFogToAlpha ); SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bWriteDepthToAlpha ); SET_DYNAMIC_PIXEL_SHADER_COMBO( FLASHLIGHTSHADOWS, nLightingPreviewMode ? false : bFlashlightShadows ); SET_DYNAMIC_PIXEL_SHADER_COMBO( UBERLIGHT, bUberlight ); SET_DYNAMIC_PIXEL_SHADER( phong_deferred_ps30 ); } else { DECLARE_DYNAMIC_PIXEL_SHADER( phong_ps30 ); SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_LIGHTS, nLightingPreviewMode ? 0 : lightState.m_nNumLights ); SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, nLightingPreviewMode ? false : bWriteWaterFogToAlpha ); SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bWriteDepthToAlpha ); SET_DYNAMIC_PIXEL_SHADER_COMBO( FLASHLIGHTSHADOWS, nLightingPreviewMode ? false : bFlashlightShadows ); SET_DYNAMIC_PIXEL_SHADER_COMBO( UBERLIGHT, bUberlight ); SET_DYNAMIC_PIXEL_SHADER( phong_ps30 ); } bool bUnusedTexCoords[3] = { false, false, !pShaderAPI->IsHWMorphingEnabled() || !bIsDecal }; pShaderAPI->MarkUnusedVertexFields( 0, 3, bUnusedTexCoords ); // Set constant to enable translation of VPOS to render target coordinates in ps_3_0 pShaderAPI->SetScreenSizeForVPOS(); DynamicCmdsOut.End(); pShaderAPI->ExecuteCommandBuffer( DynamicCmdsOut.Base() ); } pShader->Draw(); }
inline void DrawFlora( IMaterialVar **params, IShaderShadow* pShaderShadow, IShaderDynamicAPI* pShaderAPI, VertexCompressionType_t vertexCompression, CBasePerMaterialContextData *pContextDataPtr ) { const bool bIsAlphaTested = IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) != 0; const bool bHasVertexColor = IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR ); SHADOW_STATE { SetInitialShadowState(); // Alpha test: FIXME: shouldn't this be handled in Shader_t::SetInitialShadowState pShaderShadow->EnableAlphaTest( bIsAlphaTested ); if ( params[ALPHATESTREFERENCE]->GetFloatValue() > 0.0f ) { pShaderShadow->AlphaFunc( SHADER_ALPHAFUNC_GEQUAL, params[ALPHATESTREFERENCE]->GetFloatValue() ); } DefaultFog(); pShaderShadow->EnableTexture( SHADER_SAMPLER0, true ); pShaderShadow->EnableTexture( SHADER_SAMPLER10, true ); // FOW pShaderShadow->EnableTexture( SHADER_SAMPLER13, true ); // Deferred light 1 pShaderShadow->EnableTexture( SHADER_SAMPLER14, true ); // Deferred light 2 int iVFmtFlags = VERTEX_POSITION; int iUserDataSize = 0; // texcoord0 : base texcoord int pTexCoordDim[3] = { 2, 2, 3 }; int nTexCoordCount = 1; // This shader supports compressed vertices, so OR in that flag: iVFmtFlags |= VERTEX_FORMAT_COMPRESSED; if ( bHasVertexColor ) { iVFmtFlags |= VERTEX_COLOR; } pShaderShadow->VertexShaderVertexFormat( iVFmtFlags, nTexCoordCount, pTexCoordDim, iUserDataSize ); // The vertex shader uses the vertex id stream if( g_pHardwareConfig->HasFastVertexTextures() ) { SET_FLAGS2( MATERIAL_VAR2_USES_VERTEXID ); SET_FLAGS2( MATERIAL_VAR2_SUPPORTS_TESSELLATION ); } // Vertex Shader DECLARE_STATIC_VERTEX_SHADER( flora_vs30 ); SET_STATIC_VERTEX_SHADER_COMBO( VERTEXCOLOR, bHasVertexColor ); SET_STATIC_VERTEX_SHADER( flora_vs30 ); // Pixel Shader DECLARE_STATIC_PIXEL_SHADER( flora_ps30 ); SET_STATIC_PIXEL_SHADER_COMBO( VERTEXCOLOR, bHasVertexColor ); SET_STATIC_PIXEL_SHADER( flora_ps30 ); // Textures pShaderShadow->EnableTexture( SHADER_SAMPLER0, true ); //pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, true ); // Blending EnableAlphaBlending( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE_MINUS_SRC_ALPHA ); pShaderShadow->EnableAlphaTest( true ); pShaderShadow->AlphaFunc( SHADER_ALPHAFUNC_GREATER, 0.0f ); } DYNAMIC_STATE { // Reset render state pShaderAPI->SetDefaultState(); BindTexture( SHADER_SAMPLER0, BASETEXTURE ); // Base Map 1 //if ( bHasFoW ) { BindTexture( SHADER_SAMPLER10, FOW, -1 ); float vFoWSize[ 4 ]; Vector vMins = pShaderAPI->GetVectorRenderingParameter( VECTOR_RENDERPARM_GLOBAL_FOW_MINS ); Vector vMaxs = pShaderAPI->GetVectorRenderingParameter( VECTOR_RENDERPARM_GLOBAL_FOW_MAXS ); vFoWSize[ 0 ] = vMins.x; vFoWSize[ 1 ] = vMins.y; vFoWSize[ 2 ] = vMaxs.x - vMins.x; vFoWSize[ 3 ] = vMaxs.y - vMins.y; pShaderAPI->SetVertexShaderConstant( 26, vFoWSize ); } BindTexture( SHADER_SAMPLER13, GetDeferredExt()->GetTexture_LightAccum() ); BindTexture( SHADER_SAMPLER14, GetDeferredExt()->GetTexture_LightAccum2() ); int x, y, w, t; pShaderAPI->GetCurrentViewport( x, y, w, t ); float fl1[4] = { 1.0f / w, 1.0f / t, 0, 0 }; pShaderAPI->SetPixelShaderConstant( 3, fl1 ); // Set Vertex Shader Combos DECLARE_DYNAMIC_VERTEX_SHADER( flora_vs30 ); SET_DYNAMIC_VERTEX_SHADER( flora_vs30 ); // Set Pixel Shader Combos DECLARE_DYNAMIC_PIXEL_SHADER( flora_ps30 ); SET_DYNAMIC_PIXEL_SHADER( flora_ps30 ); } Draw(); }
void DrawPassGBuffer( const defParms_gBuffer &info, CBaseVSShader *pShader, IMaterialVar **params, IShaderShadow* pShaderShadow, IShaderDynamicAPI* pShaderAPI, VertexCompressionType_t vertexCompression, CDeferredPerMaterialContextData *pDeferredContext ) { const bool bDeferredShading = DEFCFG_DEFERRED_SHADING == 1; const bool bModel = info.bModel; const bool bIsDecal = IS_FLAG_SET( MATERIAL_VAR_DECAL ); const bool bFastVTex = g_pHardwareConfig->HasFastVertexTextures(); const bool bNoCull = IS_FLAG_SET( MATERIAL_VAR_NOCULL ); const bool bAlbedo = PARM_TEX( info.iAlbedo ); const bool bAlbedo2 = bDeferredShading && PARM_TEX( info.iAlbedo2 ); const bool bAlbedo3 = bDeferredShading && PARM_TEX( info.iAlbedo3 ); const bool bAlbedo4 = bDeferredShading && PARM_TEX( info.iAlbedo4 ); const bool bBumpmap = PARM_TEX( info.iBumpmap ); const bool bBumpmap2 = bBumpmap && PARM_TEX( info.iBumpmap2 ); const bool bBumpmap3 = bBumpmap && PARM_TEX( info.iBumpmap3 ); const bool bBumpmap4 = bBumpmap && PARM_TEX( info.iBumpmap4 ); const bool bPhongmap = PARM_TEX( info.iPhongmap ); const bool bMultiBlend = PARM_SET( info.iMultiblend ); const bool bMultiBlendBump = bMultiBlend && bBumpmap; const bool bBlendmodulate = ( bAlbedo2 || bBumpmap2 || bMultiBlendBump ) && PARM_TEX( info.iBlendmodulate ); const bool bBlendmodulate2 = bBlendmodulate && PARM_TEX( info.iBlendmodulate2 ); const bool bBlendmodulate3 = bBlendmodulate && PARM_TEX( info.iBlendmodulate3 ); const bool bAlphatest = IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) && bAlbedo; const bool bTranslucent = IS_FLAG_SET( MATERIAL_VAR_TRANSLUCENT ) && bAlbedo && bIsDecal; const bool bSSBump = bBumpmap && PARM_SET( info.iSSBump ); Assert( !bIsDecal || bDeferredShading ); Assert( !bTranslucent || bDeferredShading ); SHADOW_STATE { pShaderShadow->SetDefaultState(); pShaderShadow->EnableSRGBWrite( false ); if ( bNoCull ) { pShaderShadow->EnableCulling( false ); } int iVFmtFlags = VERTEX_POSITION | VERTEX_NORMAL; int iUserDataSize = 0; int *pTexCoordDim; int iTexCoordNum; GetTexcoordSettings( ( bModel && bIsDecal && bFastVTex ), bMultiBlend, iTexCoordNum, &pTexCoordDim ); if ( bModel ) { iVFmtFlags |= VERTEX_FORMAT_COMPRESSED; } else { if ( bBumpmap2 || bAlbedo2 ) iVFmtFlags |= VERTEX_COLOR; } if ( bAlphatest || bDeferredShading ) { pShaderShadow->EnableTexture( SHADER_SAMPLER0, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, false ); } if ( bBumpmap ) { pShaderShadow->EnableTexture( SHADER_SAMPLER1, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER1, false ); if ( bModel ) iUserDataSize = 4; else { iVFmtFlags |= VERTEX_TANGENT_SPACE; } } if ( bPhongmap ) { pShaderShadow->EnableTexture( SHADER_SAMPLER2, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER2, false ); } if ( bAlbedo2 || bBumpmap2 || bMultiBlendBump ) { pShaderShadow->EnableTexture( SHADER_SAMPLER3, true ); if ( bAlbedo2 ) pShaderShadow->EnableTexture( SHADER_SAMPLER9, true ); if ( bBlendmodulate ) pShaderShadow->EnableTexture( SHADER_SAMPLER4, true ); } if ( bMultiBlendBump ) { pShaderShadow->EnableTexture( SHADER_SAMPLER5, true ); pShaderShadow->EnableTexture( SHADER_SAMPLER6, true ); if ( bDeferredShading ) { pShaderShadow->EnableTexture( SHADER_SAMPLER10, true ); pShaderShadow->EnableTexture( SHADER_SAMPLER11, true ); } if ( bBlendmodulate ) { pShaderShadow->EnableTexture( SHADER_SAMPLER7, true ); pShaderShadow->EnableTexture( SHADER_SAMPLER8, true ); } } pShaderShadow->EnableAlphaWrites( true ); pShaderShadow->VertexShaderVertexFormat( iVFmtFlags, iTexCoordNum, pTexCoordDim, iUserDataSize ); if ( bTranslucent ) { pShader->EnableAlphaBlending( SHADER_BLEND_SRC_ALPHA, SHADER_BLEND_ONE_MINUS_SRC_ALPHA ); } DECLARE_STATIC_VERTEX_SHADER( gbuffer_vs30 ); SET_STATIC_VERTEX_SHADER_COMBO( MODEL, bModel ); SET_STATIC_VERTEX_SHADER_COMBO( MORPHING_VTEX, bModel && bFastVTex ); SET_STATIC_VERTEX_SHADER_COMBO( TANGENTSPACE, bBumpmap ); SET_STATIC_VERTEX_SHADER_COMBO( BUMPMAP2, bBumpmap2 && !bMultiBlend ); SET_STATIC_VERTEX_SHADER_COMBO( BLENDMODULATE, bBlendmodulate ); SET_STATIC_VERTEX_SHADER_COMBO( MULTIBLEND, bMultiBlendBump ); SET_STATIC_VERTEX_SHADER( gbuffer_vs30 ); #if DEFCFG_DEFERRED_SHADING == 1 DECLARE_STATIC_PIXEL_SHADER( gbuffer_defshading_ps30 ); #else DECLARE_STATIC_PIXEL_SHADER( gbuffer_ps30 ); SET_STATIC_PIXEL_SHADER_COMBO( BUMPMAP2, bBumpmap2 && !bMultiBlend ); #endif SET_STATIC_PIXEL_SHADER_COMBO( ALPHATEST, bAlphatest ); SET_STATIC_PIXEL_SHADER_COMBO( BUMPMAP, bBumpmap ? bSSBump ? 2 : 1 : 0 ); SET_STATIC_PIXEL_SHADER_COMBO( NOCULL, bNoCull ); SET_STATIC_PIXEL_SHADER_COMBO( PHONGMAP, bPhongmap ); SET_STATIC_PIXEL_SHADER_COMBO( BLENDMODULATE, bBlendmodulate ); SET_STATIC_PIXEL_SHADER_COMBO( MULTIBLEND, bMultiBlendBump ); #if DEFCFG_DEFERRED_SHADING == 1 SET_STATIC_PIXEL_SHADER_COMBO( TWOTEXTURE, (bAlbedo2 || bBumpmap2) && !bMultiBlend ); SET_STATIC_PIXEL_SHADER_COMBO( DECAL, bIsDecal ); SET_STATIC_PIXEL_SHADER( gbuffer_defshading_ps30 ); #else SET_STATIC_PIXEL_SHADER( gbuffer_ps30 ); #endif } DYNAMIC_STATE { Assert( pDeferredContext != NULL ); if ( pDeferredContext->m_bMaterialVarsChanged || !pDeferredContext->HasCommands( CDeferredPerMaterialContextData::DEFSTAGE_GBUFFER ) ) { tmpBuf.Reset(); if ( bAlphatest ) { PARM_VALIDATE( info.iAlphatestRef ); tmpBuf.SetPixelShaderConstant1( 0, PARM_FLOAT( info.iAlphatestRef ) ); } if ( bAlphatest || bDeferredShading ) { if ( bAlbedo ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER0, info.iAlbedo ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_GREY ); } if ( bBumpmap ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER1, info.iBumpmap ); if ( bPhongmap ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER2, info.iPhongmap ); else { float flPhongExp[2] = { 0 }; flPhongExp[0] = clamp( PARM_FLOAT( info.iPhongExp ), 0, 1 ) * 63.0f; if ( bBumpmap2 || bAlbedo2 ) { PARM_VALIDATE( info.iPhongExp2 ); flPhongExp[1] = clamp( PARM_FLOAT( info.iPhongExp2 ), 0, 1 ) * 63.0f; tmpBuf.SetPixelShaderConstant2( 2, flPhongExp[0], flPhongExp[1] ); } else tmpBuf.SetPixelShaderConstant1( 2, flPhongExp[0] ); } if ( bAlbedo2 || bBumpmap2 || bMultiBlendBump ) { if ( bBumpmap2 ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER3, info.iBumpmap2 ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER3, TEXTURE_NORMALMAP_FLAT ); if ( bAlbedo2 ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER9, info.iAlbedo2 ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER9, TEXTURE_GREY ); if ( bBlendmodulate ) { tmpBuf.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_3, info.iBlendmodulateTransform ); tmpBuf.BindTexture( pShader, SHADER_SAMPLER4, info.iBlendmodulate ); } } if ( bMultiBlendBump ) { if ( bBumpmap3 ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER5, info.iBumpmap3 ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER5, TEXTURE_NORMALMAP_FLAT ); if ( bBumpmap4 ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER6, info.iBumpmap4 ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER6, TEXTURE_NORMALMAP_FLAT ); if ( bAlbedo3 ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER10, info.iAlbedo3 ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER10, TEXTURE_GREY ); if ( bAlbedo4 ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER11, info.iAlbedo4 ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER11, TEXTURE_GREY ); if ( bBlendmodulate ) { tmpBuf.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_5, info.iBlendmodulateTransform2 ); tmpBuf.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_7, info.iBlendmodulateTransform3 ); if ( bBlendmodulate2 ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER7, info.iBlendmodulate2 ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER7, TEXTURE_BLACK ); if ( bBlendmodulate3 ) tmpBuf.BindTexture( pShader, SHADER_SAMPLER8, info.iBlendmodulate3 ); else tmpBuf.BindStandardTexture( SHADER_SAMPLER8, TEXTURE_BLACK ); } } tmpBuf.SetPixelShaderConstant2( 1, IS_FLAG_SET( MATERIAL_VAR_HALFLAMBERT ) ? 1.0f : 0.0f, PARM_SET( info.iLitface ) ? 1.0f : 0.0f ); tmpBuf.End(); pDeferredContext->SetCommands( CDeferredPerMaterialContextData::DEFSTAGE_GBUFFER, tmpBuf.Copy() ); } pShaderAPI->SetDefaultState(); if ( bModel && bFastVTex ) pShader->SetHWMorphVertexShaderState( VERTEX_SHADER_SHADER_SPECIFIC_CONST_10, VERTEX_SHADER_SHADER_SPECIFIC_CONST_11, SHADER_VERTEXTEXTURE_SAMPLER0 ); DECLARE_DYNAMIC_VERTEX_SHADER( gbuffer_vs30 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( COMPRESSED_VERTS, (bModel && (int)vertexCompression) ? 1 : 0 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( SKINNING, (bModel && pShaderAPI->GetCurrentNumBones() > 0) ? 1 : 0 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( MORPHING, (bModel && pShaderAPI->IsHWMorphingEnabled()) ? 1 : 0 ); SET_DYNAMIC_VERTEX_SHADER( gbuffer_vs30 ); #if DEFCFG_DEFERRED_SHADING == 1 DECLARE_DYNAMIC_PIXEL_SHADER( gbuffer_defshading_ps30 ); SET_DYNAMIC_PIXEL_SHADER( gbuffer_defshading_ps30 ); #else DECLARE_DYNAMIC_PIXEL_SHADER( gbuffer_ps30 ); SET_DYNAMIC_PIXEL_SHADER( gbuffer_ps30 ); #endif if ( bModel && bFastVTex ) { bool bUnusedTexCoords[3] = { false, true, !pShaderAPI->IsHWMorphingEnabled() || !bIsDecal }; pShaderAPI->MarkUnusedVertexFields( 0, 3, bUnusedTexCoords ); } float vPos[4] = {0,0,0,0}; pShaderAPI->GetWorldSpaceCameraPosition( vPos ); float zScale[4] = {GetDeferredExt()->GetZScale(),0,0,0}; pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, vPos ); pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_1, GetDeferredExt()->GetForwardBase() ); pShaderAPI->SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, zScale ); pShader->LoadViewMatrixIntoVertexShaderConstant( VERTEX_SHADER_AMBIENT_LIGHT ); pShaderAPI->ExecuteCommandBuffer( pDeferredContext->GetCommands( CDeferredPerMaterialContextData::DEFSTAGE_GBUFFER ) ); } pShader->Draw(); }
void DrawLightmappedGeneric_DX9( CBaseVSShader *pShader, IMaterialVar** params, IShaderDynamicAPI *pShaderAPI, IShaderShadow* pShaderShadow, LightmappedGeneric_DX9_Vars_t &info, CBasePerMaterialContextData **pContextDataPtr, bool bDeferredActive ) { //bool bDeferredActive = GetDeferredExt()->IsDeferredLightingEnabled(); bool bSinglePassFlashlight = true; bool hasFlashlight = !bDeferredActive && pShader->UsingFlashlight( params ); CLightmappedGeneric_DX9_Context *pContextData = reinterpret_cast< CLightmappedGeneric_DX9_Context *> ( *pContextDataPtr ); bool bShaderSrgbRead = ( IsX360() && IS_PARAM_DEFINED( info.m_nShaderSrgbRead360 ) && params[info.m_nShaderSrgbRead360]->GetIntValue() ); const bool bHasFoW = true; //( ( info.m_nFoW != -1 ) && ( params[ info.m_nFoW ]->IsTexture() != 0 ) ); if ( pShaderShadow || ( ! pContextData )|| pContextData->m_bMaterialVarsChanged || pContextData->m_bNeedsCmdRegen || ( hasFlashlight && !IsX360() ) ) { bool hasBaseTexture = params[info.m_nBaseTexture]->IsTexture(); int nAlphaChannelTextureVar = hasBaseTexture ? (int)info.m_nBaseTexture : (int)info.m_nEnvmapMask; BlendType_t nBlendType = pShader->EvaluateBlendRequirements( nAlphaChannelTextureVar, hasBaseTexture ); bool bIsAlphaTested = IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) != 0; bool bFullyOpaqueWithoutAlphaTest = (nBlendType != BT_BLENDADD) && (nBlendType != BT_BLEND) && (!hasFlashlight || IsX360()); //dest alpha is free for special use bool bFullyOpaque = bFullyOpaqueWithoutAlphaTest && !bIsAlphaTested; bool bNeedRegenStaticCmds = (! pContextData ) || pShaderShadow || pContextData->m_bNeedsCmdRegen; if ( ! pContextData ) // make sure allocated { pContextData = new CLightmappedGeneric_DX9_Context; *pContextDataPtr = pContextData; } bool hasBump = ( params[info.m_nBumpmap]->IsTexture() ) && g_pConfig->UseBumpmapping(); bool hasSSBump = hasBump && (info.m_nSelfShadowedBumpFlag != -1) && ( params[info.m_nSelfShadowedBumpFlag]->GetIntValue() ); bool hasBaseTexture2 = hasBaseTexture && params[info.m_nBaseTexture2]->IsTexture(); bool hasLightWarpTexture = params[info.m_nLightWarpTexture]->IsTexture(); bool hasBump2 = hasBump && params[info.m_nBumpmap2]->IsTexture(); bool hasDetailTexture = params[info.m_nDetail]->IsTexture(); bool hasSelfIllum = IS_FLAG_SET( MATERIAL_VAR_SELFILLUM ); bool hasBumpMask = hasBump && hasBump2 && params[info.m_nBumpMask]->IsTexture() && !hasSelfIllum && !hasDetailTexture && !hasBaseTexture2 && (params[info.m_nBaseTextureNoEnvmap]->GetIntValue() == 0); bool bHasBlendModulateTexture = (info.m_nBlendModulateTexture != -1) && (params[info.m_nBlendModulateTexture]->IsTexture() ); bool hasNormalMapAlphaEnvmapMask = g_pConfig->UseSpecular() && IS_FLAG_SET( MATERIAL_VAR_NORMALMAPALPHAENVMAPMASK ); if( g_pConfig->bEditMode ) { hasBump = false; hasBump2 = false; } bool bParallaxMapping = false; if ( g_pHardwareConfig->SupportsPixelShaders_2_b() ) bParallaxMapping = ( info.m_nParallaxMap != -1 ) && ( params[info.m_nParallaxMap]->GetIntValue() != 0 ); if ( hasFlashlight && !IsX360() ) { // !!speed!! do this in the caller so we don't build struct every time CBaseVSShader::DrawFlashlight_dx90_Vars_t vars; vars.m_bBump = hasBump; vars.m_nBumpmapVar = info.m_nBumpmap; vars.m_nBumpmapFrame = info.m_nBumpFrame; vars.m_nBumpTransform = info.m_nBumpTransform; vars.m_nFlashlightTextureVar = info.m_nFlashlightTexture; vars.m_nFlashlightTextureFrameVar = info.m_nFlashlightTextureFrame; vars.m_bLightmappedGeneric = true; vars.m_bWorldVertexTransition = hasBaseTexture2; vars.m_nBaseTexture2Var = info.m_nBaseTexture2; vars.m_nBaseTexture2FrameVar = info.m_nBaseTexture2Frame; vars.m_nBumpmap2Var = info.m_nBumpmap2; vars.m_nBumpmap2Frame = info.m_nBumpFrame2; vars.m_nBump2Transform = info.m_nBumpTransform2; vars.m_nAlphaTestReference = info.m_nAlphaTestReference; vars.m_bSSBump = hasSSBump; vars.m_nDetailVar = info.m_nDetail; vars.m_nDetailScale = info.m_nDetailScale; vars.m_nDetailTextureCombineMode = info.m_nDetailTextureCombineMode; vars.m_nDetailTextureBlendFactor = info.m_nDetailTextureBlendFactor; vars.m_nDetailTint = info.m_nDetailTint; if ( ( info.m_nSeamlessMappingScale != -1 ) ) vars.m_fSeamlessScale = params[info.m_nSeamlessMappingScale]->GetFloatValue(); else vars.m_fSeamlessScale = 0.0; pShader->DrawFlashlight_dx90( params, pShaderAPI, pShaderShadow, vars ); return; } pContextData->m_bFullyOpaque = bFullyOpaque; pContextData->m_bFullyOpaqueWithoutAlphaTest = bFullyOpaqueWithoutAlphaTest; bool bHasOutline = IsBoolSet( info.m_nOutline, params ); pContextData->m_bPixelShaderForceFastPathBecauseOutline = bHasOutline; bool bHasSoftEdges = IsBoolSet( info.m_nSoftEdges, params ); bool hasEnvmapMask = params[info.m_nEnvmapMask]->IsTexture() && !bHasFoW; float fDetailBlendFactor = GetFloatParam( info.m_nDetailTextureBlendFactor, params, 1.0 ); if ( pShaderShadow || bNeedRegenStaticCmds ) { bool hasVertexColor = IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR ); bool hasDiffuseBumpmap = hasBump && (params[info.m_nNoDiffuseBumpLighting]->GetIntValue() == 0); bool hasEnvmap = params[info.m_nEnvmap]->IsTexture(); int envmap_variant; //0 = no envmap, 1 = regular, 2 = darken in shadow mode if( hasEnvmap ) { //only enabled darkened cubemap mode when the scale calls for it. And not supported in ps20 when also using a 2nd bumpmap envmap_variant = ((GetFloatParam( info.m_nEnvMapLightScale, params ) > 0.0f) && (g_pHardwareConfig->SupportsPixelShaders_2_b() || !hasBump2)) ? 2 : 1; } else { envmap_variant = 0; } bool bSeamlessMapping = ( ( info.m_nSeamlessMappingScale != -1 ) && ( params[info.m_nSeamlessMappingScale]->GetFloatValue() != 0.0 ) ); if ( bNeedRegenStaticCmds ) { pContextData->m_bNeedsCmdRegen = false; pContextData->ResetStaticCmds(); CCommandBufferBuilder< CFixedCommandStorageBuffer< 5000 > > staticCmdsBuf; int nLightingPreviewMode = !bHasFoW ? IS_FLAG2_SET( MATERIAL_VAR2_USE_GBUFFER0 ) + 2 * IS_FLAG2_SET( MATERIAL_VAR2_USE_GBUFFER1 ) : 0; if ( ( nLightingPreviewMode == ENABLE_FIXED_LIGHTING_OUTPUTNORMAL_AND_DEPTH ) && IsPC() ) { staticCmdsBuf.SetVertexShaderNearAndFarZ( VERTEX_SHADER_SHADER_SPECIFIC_CONST_6 ); // Needed for SSAO } if( !hasBaseTexture ) { if( hasEnvmap ) { // if we only have an envmap (no basetexture), then we want the albedo to be black. staticCmdsBuf.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_BLACK ); } else { staticCmdsBuf.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_WHITE ); } } staticCmdsBuf.BindStandardTexture( SHADER_SAMPLER1, TEXTURE_LIGHTMAP ); if ( g_pConfig->m_bPaintInGame && !r_twopasspaint.GetBool() ) { staticCmdsBuf.BindStandardTexture( SHADER_SAMPLER9, TEXTURE_PAINT ); } if ( bSeamlessMapping ) { staticCmdsBuf.SetVertexShaderConstant4( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, params[info.m_nSeamlessMappingScale]->GetFloatValue(),0,0,0 ); } staticCmdsBuf.StoreEyePosInPixelShaderConstant( 10 ); staticCmdsBuf.SetPixelShaderFogParams( 11 ); staticCmdsBuf.End(); // now, copy buf pContextData->m_pStaticCmds = new uint8[staticCmdsBuf.Size()]; memcpy( pContextData->m_pStaticCmds, staticCmdsBuf.Base(), staticCmdsBuf.Size() ); } if ( pShaderShadow ) { // Alpha test: FIXME: shouldn't this be handled in Shader_t::SetInitialShadowState pShaderShadow->EnableAlphaTest( bIsAlphaTested ); if ( info.m_nAlphaTestReference != -1 && params[info.m_nAlphaTestReference]->GetFloatValue() > 0.0f ) { pShaderShadow->AlphaFunc( SHADER_ALPHAFUNC_GEQUAL, params[info.m_nAlphaTestReference]->GetFloatValue() ); } pShader->SetDefaultBlendingShadowState( nAlphaChannelTextureVar, hasBaseTexture ); unsigned int flags = VERTEX_POSITION; // base texture pShaderShadow->EnableTexture( SHADER_SAMPLER0, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER0, !bShaderSrgbRead ); if ( g_pConfig->m_bPaintInGame && !r_twopasspaint.GetBool() ) { pShaderShadow->EnableTexture( SHADER_SAMPLER9, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER9, !bShaderSrgbRead ); } if ( hasLightWarpTexture ) { pShaderShadow->EnableTexture( SHADER_SAMPLER6, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER6, false ); } if ( bHasBlendModulateTexture ) { pShaderShadow->EnableTexture( SHADER_SAMPLER3, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER3, false ); } if ( hasBaseTexture2 ) { pShaderShadow->EnableTexture( SHADER_SAMPLER7, true ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER7, !bShaderSrgbRead ); } // if( hasLightmap ) pShaderShadow->EnableTexture( SHADER_SAMPLER1, true ); if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_NONE ) { pShaderShadow->EnableSRGBRead( SHADER_SAMPLER1, true ); } else { pShaderShadow->EnableSRGBRead( SHADER_SAMPLER1, false ); } if( hasEnvmap || ( IsX360() && hasFlashlight ) ) { if( hasEnvmap ) { pShaderShadow->EnableTexture( SHADER_SAMPLER2, true ); if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_NONE ) { pShaderShadow->EnableSRGBRead( SHADER_SAMPLER2, true ); } } flags |= VERTEX_TANGENT_S | VERTEX_TANGENT_T | VERTEX_NORMAL; } #define TCOMBINE_NONE 12 // there is no detail texture int nDetailBlendMode = TCOMBINE_NONE; if ( hasDetailTexture ) { nDetailBlendMode = GetIntParam( info.m_nDetailTextureCombineMode, params ); ITexture *pDetailTexture = params[info.m_nDetail]->GetTextureValue(); if ( pDetailTexture->GetFlags() & TEXTUREFLAGS_SSBUMP ) { if ( hasBump ) nDetailBlendMode = 10; // ssbump else nDetailBlendMode = 11; // ssbump_nobump } pShaderShadow->EnableTexture( SHADER_SAMPLER12, true ); bool bSRGBState = ( nDetailBlendMode == 1 ); pShaderShadow->EnableSRGBRead( SHADER_SAMPLER12, bSRGBState ); } // Hijack detail blend mode 9 for paint (this blend mode was previously skipped/unused in lightmappedgeneric) if ( g_pConfig->m_bPaintInGame && !r_twopasspaint.GetBool() ) { nDetailBlendMode = 9; } if( hasBump || hasNormalMapAlphaEnvmapMask ) { pShaderShadow->EnableTexture( SHADER_SAMPLER4, true ); } if( hasBump2 ) { pShaderShadow->EnableTexture( SHADER_SAMPLER5, true ); } if( hasBumpMask ) { pShaderShadow->EnableTexture( SHADER_SAMPLER8, true ); } if( hasEnvmapMask ) { pShaderShadow->EnableTexture( SHADER_SAMPLER5, true ); } if( bHasFoW ) { pShaderShadow->EnableTexture( SHADER_SAMPLER13, true ); } if( bDeferredActive ) { pShaderShadow->EnableTexture( SHADER_SAMPLER14, true ); pShaderShadow->EnableTexture( SHADER_SAMPLER15, true ); } if( hasFlashlight && IsX360() ) { pShaderShadow->EnableTexture( SHADER_SAMPLER13, true ); pShaderShadow->EnableTexture( SHADER_SAMPLER14, true ); pShaderShadow->SetShadowDepthFiltering( SHADER_SAMPLER14 ); pShaderShadow->EnableTexture( SHADER_SAMPLER15, true ); } if( hasVertexColor || hasBaseTexture2 || hasBump2 ) { flags |= VERTEX_COLOR; } // texcoord0 : base texcoord // texcoord1 : lightmap texcoord // texcoord2 : lightmap texcoord offset int numTexCoords; // if ( pShaderAPI->InEditorMode() ) // if ( pShader->CanUseEditorMaterials() ) // { // numTexCoords = 1; // } // else { numTexCoords = 2; if( hasBump ) { numTexCoords = 3; } } int nLightingPreviewMode = !bHasFoW ? IS_FLAG2_SET( MATERIAL_VAR2_USE_GBUFFER0 ) + 2 * IS_FLAG2_SET( MATERIAL_VAR2_USE_GBUFFER1 ) : 0; pShaderShadow->VertexShaderVertexFormat( flags, numTexCoords, 0, 0 ); // Pre-cache pixel shaders bool hasBaseAlphaEnvmapMask = IS_FLAG_SET( MATERIAL_VAR_BASEALPHAENVMAPMASK ); int bumpmap_variant=(hasSSBump) ? 2 : hasBump; bool bMaskedBlending=( (info.m_nMaskedBlending != -1) && (params[info.m_nMaskedBlending]->GetIntValue() != 0) ); if( bDeferredActive ) { DECLARE_STATIC_VERTEX_SHADER( lightmappedgeneric_deferred_vs30 ); SET_STATIC_VERTEX_SHADER_COMBO( ENVMAP_MASK, hasEnvmapMask ); SET_STATIC_VERTEX_SHADER_COMBO( TANGENTSPACE, params[info.m_nEnvmap]->IsTexture() ); SET_STATIC_VERTEX_SHADER_COMBO( BUMPMAP, hasBump ); SET_STATIC_VERTEX_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap ); SET_STATIC_VERTEX_SHADER_COMBO( VERTEXCOLOR, IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR ) ); SET_STATIC_VERTEX_SHADER_COMBO( VERTEXALPHATEXBLENDFACTOR, hasBaseTexture2 || hasBump2 ); SET_STATIC_VERTEX_SHADER_COMBO( BUMPMASK, hasBumpMask ); SET_STATIC_VERTEX_SHADER_COMBO( LIGHTING_PREVIEW, nLightingPreviewMode ); SET_STATIC_VERTEX_SHADER_COMBO( PARALLAX_MAPPING, bParallaxMapping ); SET_STATIC_VERTEX_SHADER_COMBO( SEAMLESS, bSeamlessMapping ); SET_STATIC_VERTEX_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture ); SET_STATIC_VERTEX_SHADER_COMBO( FANCY_BLENDING, bHasBlendModulateTexture ); SET_STATIC_VERTEX_SHADER_COMBO( SELFILLUM, hasSelfIllum ); SET_STATIC_VERTEX_SHADER_COMBO( FOW, bHasFoW ); SET_STATIC_VERTEX_SHADER( lightmappedgeneric_deferred_vs30 ); DECLARE_STATIC_PIXEL_SHADER( lightmappedgeneric_deferred_ps30 ); SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE2, hasBaseTexture2 ); SET_STATIC_PIXEL_SHADER_COMBO( BUMPMAP, bumpmap_variant ); SET_STATIC_PIXEL_SHADER_COMBO( BUMPMAP2, hasBump2 ); SET_STATIC_PIXEL_SHADER_COMBO( BUMPMASK, hasBumpMask ); SET_STATIC_PIXEL_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap ); SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, envmap_variant ); SET_STATIC_PIXEL_SHADER_COMBO( ENVMAPMASK, hasEnvmapMask ); SET_STATIC_PIXEL_SHADER_COMBO( BASEALPHAENVMAPMASK, hasBaseAlphaEnvmapMask ); SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, hasSelfIllum ); SET_STATIC_PIXEL_SHADER_COMBO( NORMALMAPALPHAENVMAPMASK, hasNormalMapAlphaEnvmapMask ); SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURENOENVMAP, params[info.m_nBaseTextureNoEnvmap]->GetIntValue() ); SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE2NOENVMAP, params[info.m_nBaseTexture2NoEnvmap]->GetIntValue() ); SET_STATIC_PIXEL_SHADER_COMBO( WARPLIGHTING, hasLightWarpTexture ); SET_STATIC_PIXEL_SHADER_COMBO( FANCY_BLENDING, bHasBlendModulateTexture ); SET_STATIC_PIXEL_SHADER_COMBO( MASKEDBLENDING, bMaskedBlending); SET_STATIC_PIXEL_SHADER_COMBO( SEAMLESS, bSeamlessMapping ); SET_STATIC_PIXEL_SHADER_COMBO( OUTLINE, bHasOutline ); SET_STATIC_PIXEL_SHADER_COMBO( SOFTEDGES, bHasSoftEdges ); SET_STATIC_PIXEL_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture ); SET_STATIC_PIXEL_SHADER_COMBO( DETAIL_BLEND_MODE, nDetailBlendMode ); SET_STATIC_PIXEL_SHADER_COMBO( PARALLAX_MAPPING, bParallaxMapping ); SET_STATIC_PIXEL_SHADER_COMBO( SHADER_SRGB_READ, bShaderSrgbRead ); SET_STATIC_PIXEL_SHADER_COMBO( LIGHTING_PREVIEW, nLightingPreviewMode ); SET_STATIC_PIXEL_SHADER( lightmappedgeneric_deferred_ps30 ); } else { DECLARE_STATIC_VERTEX_SHADER( lightmappedgeneric_vs30 ); SET_STATIC_VERTEX_SHADER_COMBO( ENVMAP_MASK, hasEnvmapMask ); SET_STATIC_VERTEX_SHADER_COMBO( TANGENTSPACE, params[info.m_nEnvmap]->IsTexture() ); SET_STATIC_VERTEX_SHADER_COMBO( BUMPMAP, hasBump ); SET_STATIC_VERTEX_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap ); SET_STATIC_VERTEX_SHADER_COMBO( VERTEXCOLOR, IS_FLAG_SET( MATERIAL_VAR_VERTEXCOLOR ) ); SET_STATIC_VERTEX_SHADER_COMBO( VERTEXALPHATEXBLENDFACTOR, hasBaseTexture2 || hasBump2 ); SET_STATIC_VERTEX_SHADER_COMBO( BUMPMASK, hasBumpMask ); SET_STATIC_VERTEX_SHADER_COMBO( LIGHTING_PREVIEW, nLightingPreviewMode ); SET_STATIC_VERTEX_SHADER_COMBO( PARALLAX_MAPPING, bParallaxMapping ); SET_STATIC_VERTEX_SHADER_COMBO( SEAMLESS, bSeamlessMapping ); SET_STATIC_VERTEX_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture ); SET_STATIC_VERTEX_SHADER_COMBO( FANCY_BLENDING, bHasBlendModulateTexture ); SET_STATIC_VERTEX_SHADER_COMBO( SELFILLUM, hasSelfIllum ); SET_STATIC_VERTEX_SHADER_COMBO( FOW, bHasFoW ); SET_STATIC_VERTEX_SHADER( lightmappedgeneric_vs30 ); DECLARE_STATIC_PIXEL_SHADER( lightmappedgeneric_ps30 ); SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE2, hasBaseTexture2 ); SET_STATIC_PIXEL_SHADER_COMBO( BUMPMAP, bumpmap_variant ); SET_STATIC_PIXEL_SHADER_COMBO( BUMPMAP2, hasBump2 ); SET_STATIC_PIXEL_SHADER_COMBO( BUMPMASK, hasBumpMask ); SET_STATIC_PIXEL_SHADER_COMBO( DIFFUSEBUMPMAP, hasDiffuseBumpmap ); SET_STATIC_PIXEL_SHADER_COMBO( CUBEMAP, envmap_variant ); SET_STATIC_PIXEL_SHADER_COMBO( ENVMAPMASK, hasEnvmapMask ); SET_STATIC_PIXEL_SHADER_COMBO( BASEALPHAENVMAPMASK, hasBaseAlphaEnvmapMask ); SET_STATIC_PIXEL_SHADER_COMBO( SELFILLUM, hasSelfIllum ); SET_STATIC_PIXEL_SHADER_COMBO( NORMALMAPALPHAENVMAPMASK, hasNormalMapAlphaEnvmapMask ); SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURENOENVMAP, params[info.m_nBaseTextureNoEnvmap]->GetIntValue() ); SET_STATIC_PIXEL_SHADER_COMBO( BASETEXTURE2NOENVMAP, params[info.m_nBaseTexture2NoEnvmap]->GetIntValue() ); SET_STATIC_PIXEL_SHADER_COMBO( WARPLIGHTING, hasLightWarpTexture ); SET_STATIC_PIXEL_SHADER_COMBO( FANCY_BLENDING, bHasBlendModulateTexture ); SET_STATIC_PIXEL_SHADER_COMBO( MASKEDBLENDING, bMaskedBlending); SET_STATIC_PIXEL_SHADER_COMBO( SEAMLESS, bSeamlessMapping ); SET_STATIC_PIXEL_SHADER_COMBO( OUTLINE, bHasOutline ); SET_STATIC_PIXEL_SHADER_COMBO( SOFTEDGES, bHasSoftEdges ); SET_STATIC_PIXEL_SHADER_COMBO( DETAILTEXTURE, hasDetailTexture ); SET_STATIC_PIXEL_SHADER_COMBO( DETAIL_BLEND_MODE, nDetailBlendMode ); SET_STATIC_PIXEL_SHADER_COMBO( PARALLAX_MAPPING, bParallaxMapping ); SET_STATIC_PIXEL_SHADER_COMBO( SHADER_SRGB_READ, bShaderSrgbRead ); SET_STATIC_PIXEL_SHADER_COMBO( LIGHTING_PREVIEW, nLightingPreviewMode ); SET_STATIC_PIXEL_SHADER( lightmappedgeneric_ps30 ); } // HACK HACK HACK - enable alpha writes all the time so that we have them for // underwater stuff and writing depth to dest alpha // But only do it if we're not using the alpha already for translucency pShaderShadow->EnableAlphaWrites( bFullyOpaque ); pShaderShadow->EnableSRGBWrite( true ); pShader->DefaultFog(); // NOTE: This isn't optimal. If $color2 is ever changed by a material // proxy, this code won't get re-run, but too bad. No time to make this work // Also note that if the lightmap scale factor changes // all shadow state blocks will be re-run, so that's ok float flLScale = pShaderShadow->GetLightMapScaleFactor(); pShader->PI_BeginCommandBuffer(); pShader->PI_SetModulationPixelShaderDynamicState( 21 ); // MAINTOL4DMERGEFIXME // Need to reflect this change which is from this rel changelist since this constant set was moved from the dynamic block to here: // Change 578692 by Alex@alexv_rel on 2008/06/04 18:07:31 // // Fix for portalareawindows in ep2 being rendered black. The color variable was being multipurposed for both the vs and ps differently where the ps doesn't care about alpha, but the vs does. Only applying the alpha2 DoD hack to the pixel shader constant where the alpha was never used in the first place and leaving alpha as is for the vs. // color[3] *= ( IS_PARAM_DEFINED( info.m_nAlpha2 ) && params[ info.m_nAlpha2 ]->GetFloatValue() > 0.0f ) ? params[ info.m_nAlpha2 ]->GetFloatValue() : 1.0f; // pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 12, color ); pShader->PI_SetModulationPixelShaderDynamicState_LinearScale_ScaleInW( 12, flLScale ); pShader->PI_SetModulationVertexShaderDynamicState_LinearScale( flLScale ); pShader->PI_EndCommandBuffer(); } // end shadow state } // end shadow || regen display list if ( pShaderAPI && ( pContextData->m_bMaterialVarsChanged ) ) { // need to regenerate the semistatic cmds pContextData->m_SemiStaticCmdsOut.Reset(); pContextData->m_bMaterialVarsChanged = false; bool bHasBlendMaskTransform= ( (info.m_nBlendMaskTransform != -1) && (info.m_nMaskedBlending != -1) && (params[info.m_nMaskedBlending]->GetIntValue() ) && ( ! (params[info.m_nBumpTransform]->MatrixIsIdentity() ) ) ); // If we don't have a texture transform, we don't have // to set vertex shader constants or run vertex shader instructions // for the texture transform. bool bHasTextureTransform = !( params[info.m_nBaseTextureTransform]->MatrixIsIdentity() && params[info.m_nBumpTransform]->MatrixIsIdentity() && params[info.m_nBumpTransform2]->MatrixIsIdentity() && params[info.m_nEnvmapMaskTransform]->MatrixIsIdentity() ); bHasTextureTransform |= bHasBlendMaskTransform; pContextData->m_bVertexShaderFastPath = !bHasTextureTransform; if( params[info.m_nDetail]->IsTexture() ) { pContextData->m_bVertexShaderFastPath = false; } int nTransformToLoad = info.m_nBlendMaskTransform; if( ( hasBump || hasSSBump ) && hasDetailTexture && !hasSelfIllum && !bHasBlendModulateTexture ) { nTransformToLoad = info.m_nBumpTransform; } pContextData->m_SemiStaticCmdsOut.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_10, nTransformToLoad ); if ( ! pContextData->m_bVertexShaderFastPath ) { bool bSeamlessMapping = ( ( info.m_nSeamlessMappingScale != -1 ) && ( params[info.m_nSeamlessMappingScale]->GetFloatValue() != 0.0 ) ); bool hasEnvmapMask = params[info.m_nEnvmapMask]->IsTexture() && !bHasFoW; if (!bSeamlessMapping ) pContextData->m_SemiStaticCmdsOut.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_0, info.m_nBaseTextureTransform ); // If we have a detail texture, then the bump texcoords are the same as the base texcoords. if( hasBump && !hasDetailTexture ) { pContextData->m_SemiStaticCmdsOut.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, info.m_nBumpTransform ); } if( hasEnvmapMask ) { pContextData->m_SemiStaticCmdsOut.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4, info.m_nEnvmapMaskTransform ); } else if ( hasBump2 ) { pContextData->m_SemiStaticCmdsOut.SetVertexShaderTextureTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_4, info.m_nBumpTransform2 ); } } pContextData->m_SemiStaticCmdsOut.SetEnvMapTintPixelShaderDynamicState( 0, info.m_nEnvmapTint ); if ( hasDetailTexture ) { float detailTintAndBlend[4] = {1, 1, 1, 1}; if ( info.m_nDetailTint != -1 ) { params[info.m_nDetailTint]->GetVecValue( detailTintAndBlend, 3 ); } detailTintAndBlend[3] = fDetailBlendFactor; pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 8, detailTintAndBlend ); } float envmapTintVal[4]; float selfIllumTintVal[4]; params[info.m_nEnvmapTint]->GetVecValue( envmapTintVal, 3 ); params[info.m_nSelfIllumTint]->GetVecValue( selfIllumTintVal, 3 ); float envmapContrast = params[info.m_nEnvmapContrast]->GetFloatValue(); float envmapSaturation = params[info.m_nEnvmapSaturation]->GetFloatValue(); float fresnelReflection = params[info.m_nFresnelReflection]->GetFloatValue(); bool hasEnvmap = params[info.m_nEnvmap]->IsTexture(); int envmap_variant; //0 = no envmap, 1 = regular, 2 = darken in shadow mode if( hasEnvmap ) { //only enabled darkened cubemap mode when the scale calls for it. And not supported in ps20 when also using a 2nd bumpmap envmap_variant = ((GetFloatParam( info.m_nEnvMapLightScale, params ) > 0.0f) && (g_pHardwareConfig->SupportsPixelShaders_2_b() || !hasBump2)) ? 2 : 1; } else { envmap_variant = 0; } pContextData->m_bPixelShaderFastPath = true; bool bUsingContrastOrSaturation = hasEnvmap && ( ( (envmapContrast != 0.0f) && (envmapContrast != 1.0f) ) || (envmapSaturation != 1.0f) ); bool bUsingFresnel = hasEnvmap && (fresnelReflection != 1.0f); bool bUsingSelfIllumTint = IS_FLAG_SET(MATERIAL_VAR_SELFILLUM) && (selfIllumTintVal[0] != 1.0f || selfIllumTintVal[1] != 1.0f || selfIllumTintVal[2] != 1.0f); if ( bUsingContrastOrSaturation || bUsingFresnel || bUsingSelfIllumTint || !g_pConfig->bShowSpecular ) { pContextData->m_bPixelShaderFastPath = false; } if( !pContextData->m_bPixelShaderFastPath ) { pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstants( 2, 3 ); pContextData->m_SemiStaticCmdsOut.OutputConstantData( params[info.m_nEnvmapContrast]->GetVecValue() ); pContextData->m_SemiStaticCmdsOut.OutputConstantData( params[info.m_nEnvmapSaturation]->GetVecValue() ); float flFresnel = params[info.m_nFresnelReflection]->GetFloatValue(); // [ 0, 0, 1-R(0), R(0) ] pContextData->m_SemiStaticCmdsOut.OutputConstantData4( 0., 0., 1.0 - flFresnel, flFresnel ); pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 7, params[info.m_nSelfIllumTint]->GetVecValue() ); } else { if ( bHasOutline ) { float flOutlineParms[8] = { GetFloatParam( info.m_nOutlineStart0, params ), GetFloatParam( info.m_nOutlineStart1, params ), GetFloatParam( info.m_nOutlineEnd0, params ), GetFloatParam( info.m_nOutlineEnd1, params ), 0,0,0, GetFloatParam( info.m_nOutlineAlpha, params ) }; if ( info.m_nOutlineColor != -1 ) { params[info.m_nOutlineColor]->GetVecValue( flOutlineParms + 4, 3 ); } pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant( 2, flOutlineParms, 2 ); } if ( bHasSoftEdges ) { pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant4( 4, GetFloatParam( info.m_nEdgeSoftnessStart, params ), GetFloatParam( info.m_nEdgeSoftnessEnd, params ), 0,0 ); } } // parallax and cubemap light scale mapping parms (c20) if ( bParallaxMapping || (envmap_variant == 2) ) { pContextData->m_SemiStaticCmdsOut.SetPixelShaderConstant4( 20, GetFloatParam( info.m_nHeightScale, params), GetFloatParam( info.m_nEnvMapLightScale, params), 0, 0 ); } // texture binds if( hasBaseTexture ) { pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER0, info.m_nBaseTexture, info.m_nBaseTextureFrame ); } // handle mat_fullbright 2 bool bLightingOnly = mat_fullbright.GetInt() == 2 && !IS_FLAG_SET( MATERIAL_VAR_NO_DEBUG_OVERRIDE ); if( bLightingOnly ) { // BASE TEXTURE if( hasSelfIllum ) { pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_GREY_ALPHA_ZERO ); } else { pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER0, TEXTURE_GREY ); } // BASE TEXTURE 2 if( hasBaseTexture2 ) { pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER7, TEXTURE_GREY ); } // DETAIL TEXTURE if( hasDetailTexture ) { pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER12, TEXTURE_GREY ); } // disable color modulation float color[4] = { 0.0f, 0.0f, 0.0f, 0.0f }; pContextData->m_SemiStaticCmdsOut.SetVertexShaderConstant( VERTEX_SHADER_MODULATION_COLOR, color ); // turn off environment mapping envmapTintVal[0] = 0.0f; envmapTintVal[1] = 0.0f; envmapTintVal[2] = 0.0f; } // always set the transform for detail textures since I'm assuming that you'll // always have a detailscale. if( hasDetailTexture ) { pContextData->m_SemiStaticCmdsOut.SetVertexShaderTextureScaledTransform( VERTEX_SHADER_SHADER_SPECIFIC_CONST_2, info.m_nBaseTextureTransform, info.m_nDetailScale ); } if( hasBaseTexture2 ) { pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER7, info.m_nBaseTexture2, info.m_nBaseTexture2Frame ); } if( hasDetailTexture ) { pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER12, info.m_nDetail, info.m_nDetailFrame ); } if( hasBump || hasNormalMapAlphaEnvmapMask ) { if( !g_pConfig->m_bFastNoBump ) { pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER4, info.m_nBumpmap, info.m_nBumpFrame ); } else { if( hasSSBump ) { pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER4, TEXTURE_SSBUMP_FLAT ); } else { pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER4, TEXTURE_NORMALMAP_FLAT ); } } } if( hasBump2 ) { if( !g_pConfig->m_bFastNoBump ) { pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER5, info.m_nBumpmap2, info.m_nBumpFrame2 ); } else { if( hasSSBump ) { pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER5, TEXTURE_NORMALMAP_FLAT ); } else { pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER5, TEXTURE_SSBUMP_FLAT ); } } } if( hasBumpMask ) { if( !g_pConfig->m_bFastNoBump ) { pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER8, info.m_nBumpMask, -1 ); } else { // this doesn't make sense pContextData->m_SemiStaticCmdsOut.BindStandardTexture( SHADER_SAMPLER8, TEXTURE_NORMALMAP_FLAT ); } } if( hasEnvmapMask ) { pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER5, info.m_nEnvmapMask, info.m_nEnvmapMaskFrame ); } if ( hasLightWarpTexture ) { pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER6, info.m_nLightWarpTexture, -1 ); } if ( bHasBlendModulateTexture ) { pContextData->m_SemiStaticCmdsOut.BindTexture( pShader, SHADER_SAMPLER3, info.m_nBlendModulateTexture, -1 ); } if ( hasFlashlight && IsX360() ) { pContextData->m_SemiStaticCmdsOut.SetVertexShaderFlashlightState( VERTEX_SHADER_SHADER_SPECIFIC_CONST_6 ); CBCmdSetPixelShaderFlashlightState_t state; state.m_LightSampler = SHADER_SAMPLER13; state.m_DepthSampler = SHADER_SAMPLER14; state.m_ShadowNoiseSampler = SHADER_SAMPLER15; state.m_nColorConstant = 28; state.m_nAttenConstant = 13; state.m_nOriginConstant = 14; state.m_nDepthTweakConstant = 19; state.m_nScreenScaleConstant = 31; state.m_nWorldToTextureConstant = -1; state.m_bFlashlightNoLambert = false; state.m_bSinglePassFlashlight = bSinglePassFlashlight; pContextData->m_SemiStaticCmdsOut.SetPixelShaderFlashlightState( state ); } pContextData->m_SemiStaticCmdsOut.End(); } } DYNAMIC_STATE { CCommandBufferBuilder< CFixedCommandStorageBuffer< 1000 > > DynamicCmdsOut; DynamicCmdsOut.Call( pContextData->m_pStaticCmds ); DynamicCmdsOut.Call( pContextData->m_SemiStaticCmdsOut.Base() ); bool hasEnvmap = params[info.m_nEnvmap]->IsTexture(); if( hasEnvmap ) { DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER2, info.m_nEnvmap, info.m_nEnvmapFrame ); } bool bVertexShaderFastPath = pContextData->m_bVertexShaderFastPath; int nFixedLightingMode = pShaderAPI->GetIntRenderingParameter( INT_RENDERPARM_ENABLE_FIXED_LIGHTING ); if( nFixedLightingMode != ENABLE_FIXED_LIGHTING_NONE ) { if ( pContextData->m_bPixelShaderForceFastPathBecauseOutline ) { nFixedLightingMode = ENABLE_FIXED_LIGHTING_NONE; } else { bVertexShaderFastPath = false; } } bool bWorldNormal = ( nFixedLightingMode == ENABLE_FIXED_LIGHTING_OUTPUTNORMAL_AND_DEPTH ); if ( bWorldNormal && IsPC() ) { float vEyeDir[4]; pShaderAPI->GetWorldSpaceCameraDirection( vEyeDir ); float flFarZ = pShaderAPI->GetFarZ(); vEyeDir[0] /= flFarZ; // Divide by farZ for SSAO algorithm vEyeDir[1] /= flFarZ; vEyeDir[2] /= flFarZ; DynamicCmdsOut.SetVertexShaderConstant4( 12, vEyeDir[0], vEyeDir[1], vEyeDir[2], 1.0f ); } MaterialFogMode_t fogType = pShaderAPI->GetSceneFogMode(); if( bDeferredActive ) { DECLARE_DYNAMIC_VERTEX_SHADER( lightmappedgeneric_deferred_vs30 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( FASTPATH, bVertexShaderFastPath ); SET_DYNAMIC_VERTEX_SHADER_CMD( DynamicCmdsOut, lightmappedgeneric_deferred_vs30 ); } else { DECLARE_DYNAMIC_VERTEX_SHADER( lightmappedgeneric_vs30 ); SET_DYNAMIC_VERTEX_SHADER_COMBO( FASTPATH, bVertexShaderFastPath ); SET_DYNAMIC_VERTEX_SHADER_CMD( DynamicCmdsOut, lightmappedgeneric_vs30 ); } bool bPixelShaderFastPath = pContextData->m_bPixelShaderFastPath; if ( nFixedLightingMode != ENABLE_FIXED_LIGHTING_NONE ) { bPixelShaderFastPath = false; } bool bWriteDepthToAlpha; bool bWriteWaterFogToAlpha; if( pContextData->m_bFullyOpaque ) { bWriteDepthToAlpha = pShaderAPI->ShouldWriteDepthToDestAlpha(); bWriteWaterFogToAlpha = (fogType == MATERIAL_FOG_LINEAR_BELOW_FOG_Z); AssertMsg( !(bWriteDepthToAlpha && bWriteWaterFogToAlpha), "Can't write two values to alpha at the same time." ); } else { //can't write a special value to dest alpha if we're actually using as-intended alpha bWriteDepthToAlpha = false; bWriteWaterFogToAlpha = false; } if( bHasFoW ) { if( ( info.m_nFoW != -1 ) && ( params[ info.m_nFoW ]->IsTexture() != 0 ) ) DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER13, info.m_nFoW, -1 ); else DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER13, TEXTURE_WHITE ); float vFoWSize[ 4 ]; Vector vMins = pShaderAPI->GetVectorRenderingParameter( VECTOR_RENDERPARM_GLOBAL_FOW_MINS ); Vector vMaxs = pShaderAPI->GetVectorRenderingParameter( VECTOR_RENDERPARM_GLOBAL_FOW_MAXS ); vFoWSize[ 0 ] = vMins.x; vFoWSize[ 1 ] = vMins.y; vFoWSize[ 2 ] = vMaxs.x - vMins.x; vFoWSize[ 3 ] = vMaxs.y - vMins.y; DynamicCmdsOut.SetVertexShaderConstant( VERTEX_SHADER_SHADER_SPECIFIC_CONST_12, vFoWSize ); } if( bDeferredActive ) { DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER14, GetDeferredExt()->GetTexture_LightAccum(), 0 ); DynamicCmdsOut.BindTexture( pShader, SHADER_SAMPLER15, GetDeferredExt()->GetTexture_LightAccum2(), 0 ); //DynamicCmdsOut.BindStandardTexture( SHADER_SAMPLER14, TEXTURE_WHITE ); int x, y, w, t; pShaderAPI->GetCurrentViewport( x, y, w, t ); float fl1[4] = { 1.0f / w, 1.0f / t, 0, 0 }; DynamicCmdsOut.SetPixelShaderConstant( PSREG_UBERLIGHT_SMOOTH_EDGE_0, fl1 ); } bool bFlashlightShadows = false; bool bUberlight = false; if( hasFlashlight && IsX360() ) { pShaderAPI->GetFlashlightShaderInfo( &bFlashlightShadows, &bUberlight ); } else { // only do ambient light when not using flashlight static ConVarRef mat_ambient_light_r_forced( "mat_ambient_light_r_forced" ); static ConVarRef mat_ambient_light_g_forced( "mat_ambient_light_g_forced" ); static ConVarRef mat_ambient_light_b_forced( "mat_ambient_light_b_forced" ); float vAmbientColor[4] = { mat_ambient_light_r_forced.GetFloat() != -1.0f ? mat_ambient_light_r_forced.GetFloat() : mat_ambient_light_r.GetFloat(), mat_ambient_light_g_forced.GetFloat() != -1.0f ? mat_ambient_light_g_forced.GetFloat() : mat_ambient_light_g.GetFloat(), mat_ambient_light_b_forced.GetFloat() != -1.0f ? mat_ambient_light_b_forced.GetFloat() : mat_ambient_light_b.GetFloat(), 0.0f }; if ( mat_fullbright.GetInt() == 1 ) { vAmbientColor[0] = vAmbientColor[1] = vAmbientColor[2] = 0.0f; } DynamicCmdsOut.SetPixelShaderConstant( 31, vAmbientColor, 1 ); } float envmapContrast = params[info.m_nEnvmapContrast]->GetFloatValue(); if( bDeferredActive ) { DECLARE_DYNAMIC_PIXEL_SHADER( lightmappedgeneric_deferred_ps30); SET_DYNAMIC_PIXEL_SHADER_COMBO( FASTPATH, bPixelShaderFastPath || pContextData->m_bPixelShaderForceFastPathBecauseOutline ); SET_DYNAMIC_PIXEL_SHADER_COMBO( FASTPATHENVMAPCONTRAST, bPixelShaderFastPath && envmapContrast == 1.0f ); // Don't write fog to alpha if we're using translucency SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bWriteDepthToAlpha ); SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, bWriteWaterFogToAlpha ); SET_DYNAMIC_PIXEL_SHADER_COMBO( FLASHLIGHTSHADOWS, /*bFlashlightShadows*/ 0 ); SET_DYNAMIC_PIXEL_SHADER_CMD( DynamicCmdsOut, lightmappedgeneric_deferred_ps30 ); } else { DECLARE_DYNAMIC_PIXEL_SHADER( lightmappedgeneric_ps30 ); SET_DYNAMIC_PIXEL_SHADER_COMBO( FASTPATH, bPixelShaderFastPath || pContextData->m_bPixelShaderForceFastPathBecauseOutline ); SET_DYNAMIC_PIXEL_SHADER_COMBO( FASTPATHENVMAPCONTRAST, bPixelShaderFastPath && envmapContrast == 1.0f ); // Don't write fog to alpha if we're using translucency SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITE_DEPTH_TO_DESTALPHA, bWriteDepthToAlpha ); SET_DYNAMIC_PIXEL_SHADER_COMBO( WRITEWATERFOGTODESTALPHA, bWriteWaterFogToAlpha ); SET_DYNAMIC_PIXEL_SHADER_COMBO( FLASHLIGHTSHADOWS, bFlashlightShadows ); SET_DYNAMIC_PIXEL_SHADER_CMD( DynamicCmdsOut, lightmappedgeneric_ps30 ); } DynamicCmdsOut.End(); pShaderAPI->ExecuteCommandBuffer( DynamicCmdsOut.Base() ); } pShader->Draw(); if( !bDeferredActive && IsPC() && (IS_FLAG_SET( MATERIAL_VAR_ALPHATEST ) != 0) && pContextData->m_bFullyOpaqueWithoutAlphaTest ) { //Alpha testing makes it so we can't write to dest alpha //Writing to depth makes it so later polygons can't write to dest alpha either //This leads to situations with garbage in dest alpha. //Fix it now by converting depth to dest alpha for any pixels that just wrote. pShader->DrawEqualDepthToDestAlpha(); } }
void DrawPassLightPassVolum( const lightPassParms &info, CBaseVSShader *pShader, IMaterialVar **params, IShaderShadow* pShaderShadow, IShaderDynamicAPI* pShaderAPI, VertexCompressionType_t vertexCompression ) { const bool bWorldProjection = PARM_SET( info.iWorldProjection ); const int iLightType = PARM_INT( info.iLightTypeVar ); const bool bPoint = iLightType == DEFLIGHTTYPE_POINT; SHADOW_STATE { pShaderShadow->SetDefaultState(); pShaderShadow->EnableDepthTest( false ); pShaderShadow->EnableDepthWrites( false ); pShaderShadow->EnableAlphaWrites( false ); pShaderShadow->EnableCulling( true ); pShader->EnableAlphaBlending( SHADER_BLEND_ONE, SHADER_BLEND_ONE ); pShaderShadow->EnableTexture( SHADER_SAMPLER0, true ); pShaderShadow->EnableTexture( SHADER_SAMPLER1, true ); for ( int i = 0; i < FREE_LIGHT_SAMPLERS; i++ ) { pShaderShadow->EnableTexture( (Sampler_t)( FIRST_LIGHT_SAMPLER + i ), true ); } pShaderShadow->VertexShaderVertexFormat( VERTEX_POSITION, 1, NULL, 0 ); DECLARE_STATIC_VERTEX_SHADER( defconstruct_vs30 ); SET_STATIC_VERTEX_SHADER_COMBO( USEWORLDTRANSFORM, bWorldProjection ? 1 : 0 ); SET_STATIC_VERTEX_SHADER_COMBO( SENDWORLDPOS, bWorldProjection ? 1 : 0 ); SET_STATIC_VERTEX_SHADER( defconstruct_vs30 ); switch ( iLightType ) { case DEFLIGHTTYPE_POINT: { DECLARE_STATIC_PIXEL_SHADER( volumpass_point_ps30 ); SET_STATIC_PIXEL_SHADER_COMBO( USEWORLDTRANSFORM, bWorldProjection ? 1 : 0 ); SET_STATIC_PIXEL_SHADER( volumpass_point_ps30 ); } break; case DEFLIGHTTYPE_SPOT: { DECLARE_STATIC_PIXEL_SHADER( volumpass_spot_ps30 ); SET_STATIC_PIXEL_SHADER_COMBO( USEWORLDTRANSFORM, bWorldProjection ? 1 : 0 ); SET_STATIC_PIXEL_SHADER( volumpass_spot_ps30 ); } break; } } DYNAMIC_STATE { pShaderAPI->SetDefaultState(); CDeferredExtension *pExt = GetDeferredExt(); const volumeData_t &vData = GetDeferredExt()->GetVolumeData(); Assert( pExt->GetActiveLightData() != NULL ); Assert( pExt->GetActiveLights_NumRows() != NULL ); const int iNumShadowedCookied = vData.bHasCookie ? 1:0; const int iNumShadowed = vData.bHasCookie ? 0:1; Assert( (iNumShadowedCookied + iNumShadowed) == 1 ); Assert( iNumShadowedCookied <= pExt->GetNumActiveLights_ShadowedCookied() ); Assert( iNumShadowed <= pExt->GetNumActiveLights_Shadowed() ); DECLARE_DYNAMIC_VERTEX_SHADER( defconstruct_vs30 ); SET_DYNAMIC_VERTEX_SHADER( defconstruct_vs30 ); switch ( iLightType ) { case DEFLIGHTTYPE_POINT: { DECLARE_DYNAMIC_PIXEL_SHADER( volumpass_point_ps30 ); SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_SHADOWED_COOKIE, iNumShadowedCookied ); SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_SHADOWED, iNumShadowed ); SET_DYNAMIC_PIXEL_SHADER( volumpass_point_ps30 ); } break; case DEFLIGHTTYPE_SPOT: { DECLARE_DYNAMIC_PIXEL_SHADER( volumpass_spot_ps30 ); SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_SHADOWED_COOKIE, iNumShadowedCookied ); SET_DYNAMIC_PIXEL_SHADER_COMBO( NUM_SHADOWED, iNumShadowed ); SET_DYNAMIC_PIXEL_SHADER( volumpass_spot_ps30 ); } break; } pShader->BindTexture( SHADER_SAMPLER0, GetDeferredExt()->GetTexture_VolumePrePass() ); pShader->BindTexture( SHADER_SAMPLER1, GetDeferredExt()->GetTexture_Depth() ); int iSampler = 0; int iShadow = vData.iSamplerOffset; int iCookie = vData.iSamplerOffset; for ( ; iSampler < (iNumShadowedCookied*2);) { ITexture *pDepth = bPoint ? GetDeferredExt()->GetTexture_ShadowDepth_DP(iShadow) : GetDeferredExt()->GetTexture_ShadowDepth_Proj(iShadow); pShader->BindTexture( (Sampler_t)( FIRST_LIGHT_SAMPLER + iSampler ), pDepth ); pShader->BindTexture( (Sampler_t)( FIRST_LIGHT_SAMPLER + iSampler + 1 ), GetDeferredExt()->GetTexture_Cookie(iCookie) ); iSampler += 2; iShadow++; iCookie++; } for ( ; iSampler < (iNumShadowedCookied*2+iNumShadowed); ) { ITexture *pDepth = bPoint ? GetDeferredExt()->GetTexture_ShadowDepth_DP(iShadow) : GetDeferredExt()->GetTexture_ShadowDepth_Proj(iShadow); pShader->BindTexture( (Sampler_t)( FIRST_LIGHT_SAMPLER + iSampler ), pDepth ); iSampler++; iShadow++; } const int frustumReg = bWorldProjection ? 3 : VERTEX_SHADER_SHADER_SPECIFIC_CONST_0; CommitBaseDeferredConstants_Frustum( pShaderAPI, frustumReg, !bWorldProjection ); CommitBaseDeferredConstants_Origin( pShaderAPI, 0 ); pShaderAPI->SetPixelShaderConstant( FIRST_SHARED_LIGHTDATA_CONSTANT, pExt->GetActiveLightData() + vData.iDataOffset, vData.iNumRows ); if ( bWorldProjection ) { CommitHalfScreenTexel( pShaderAPI, 6 ); } } pShader->Draw(); }