valve/source-sdk-2013
0
0
Fork 0
mirror of https://github.com/ValveSoftware/source-sdk-2013.git synced 2025-04-06 18:12:14 +00:00
Code Issues Projects Releases Packages Wiki Activity

- began adding post processing effects back from 2006 build

Browse source
This commit is contained in:
Biohazard 2013-09-23 19:51:42 +02:00
parent 792b2c4bdd
commit 4b0699c10d
12 changed files with 659 additions and 227 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
sp/src/game/client/detailobjectsystem.cpp
View file

@ -26,6 +26,8 @@
#include <algorithm>
#include "tier0/valve_minmax_on.h"
#include "gstring/gstring_postprocess.h" // GSTRINGMIGRATION
#if defined(DOD_DLL) || defined(CSTRIKE_DLL)
#define USE_DETAIL_SHAPES
#endif
@ -925,6 +927,12 @@ void CDetailModel::GetColorModulation( float *color )
}
}
// GSTRINGMIGRATION
const float flNightvisionAmt = GetNightvisionMinLighting();
for ( int i = 0; i < 3; i++ )
color[i] = Lerp( flNightvisionAmt, color[i], 1.0f );
// END GSTRINGMIGRATION
// Gamma correct....
engine->LinearToGamma( color, color );
}

4
sp/src/game/client/fx_explosion.cpp
View file

@ -19,6 +19,8 @@
#include "fx_line.h"
#include "fx_water.h"
#include "gstring\gstring_postprocess.h" // GSTRINGMIGRATION
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
@ -192,6 +194,8 @@ void C_BaseExplosionEffect::Create( const Vector &position, float force, float s
CreateDebris();
//FIXME: CreateDynamicLight();
CreateMisc();
QueueExplosionBlur( position ); // GSTRINGMIGRATION
}
//-----------------------------------------------------------------------------

6
sp/src/game/client/hl2/hud_damageindicator.cpp
View file

@ -389,6 +389,12 @@ void CHudDamageIndicator::MsgFunc_Damage( bf_read &msg )
highDamage = DAMAGE_HIGH;
}
int maskBlood = ( bitsDamage & ( DMG_CRUSH | DMG_BULLET | DMG_SLASH | DMG_VEHICLE |
DMG_BLAST | DMG_CLUB | DMG_ENERGYBEAM | DMG_PHYSGUN | DMG_AIRBOAT | DMG_DIRECT | DMG_BUCKSHOT ) );
if ( bitsDamage == 0 || maskBlood != 0 )
AddBloodParticle( pPlayer->GetHealth(), damageTaken );
if ( damageTaken > 0 || armor > 0 )
{
// see which quandrant the effect is in

13
sp/src/game/client/view.cpp
View file

@ -45,6 +45,8 @@
#include "headtrack/isourcevirtualreality.h"
#include "client_virtualreality.h"
#include "gstring\gstring_postprocess.h" // GSTRINGMIGRATION
#if defined( REPLAY_ENABLED )
#include "replay/ireplaysystem.h"
#include "replay/ienginereplay.h"
@ -292,7 +294,7 @@ extern ConVar default_fov;
//-----------------------------------------------------------------------------
// Purpose: Initializes all view systems
//-----------------------------------------------------------------------------
void CViewRender::Init( void )
void CViewRender::Init( void ) // GSTRINGMIGRATION
{
memset( &m_PitchDrift, 0, sizeof( m_PitchDrift ) );
@ -333,6 +335,7 @@ void CViewRender::Init( void )
m_flLastFOV = default_fov.GetFloat();
#endif
materials->AddRestoreFunc( &OnGstringPPModeChange );
}
//-----------------------------------------------------------------------------
@ -357,6 +360,12 @@ void CViewRender::LevelInit( void )
// Init all IScreenSpaceEffects
g_pScreenSpaceEffects->InitScreenSpaceEffects( );
// GSTRINGMIGRATION
// reset values in material
SetGodraysColor();
SetGodraysIntensity();
// END GSTRINGMIGRATION
}
//-----------------------------------------------------------------------------
@ -372,6 +381,8 @@ void CViewRender::LevelShutdown( void )
//-----------------------------------------------------------------------------
void CViewRender::Shutdown( void )
{
materials->RemoveRestoreFunc( &OnGstringPPModeChange );
m_TranslucentSingleColor.Shutdown( );
m_ModulateSingleColor.Shutdown( );
m_ScreenOverlayMaterial.Shutdown();

486
sp/src/game/client/viewrender.cpp
View file

@ -78,6 +78,9 @@
#include "C_Env_Projected_Texture.h"
// GSTRINGMIGRATION
#include "gstring/gstring_postprocess.h"
#include "gstring/cscreenoverlay_multi.h"
#include "gstring/gstring_cvars.h"
#include "shadereditor/shadereditorsystem.h"
// END GSTRINGMIGRATION
@ -1897,49 +1900,199 @@ void CViewRender::FreezeFrame( float flFreezeTime )
const char *COM_GetModDirectory();
// GSTRINGMIGRATION
static void DrawVGUILayer( CHud::HUDRENDERSTAGE_t stage, const CViewSetup &view )
{
const bool bMainPass = stage == CHud::HUDRENDERSTAGE_DEFAULT_HUD;
//static void DrawVGUILayer( CHud::HUDRENDERSTAGE_t stage, const CViewSetup &view )
//{
// const bool bMainPass = stage == CHud::HUDRENDERSTAGE_DEFAULT_HUD;
//
// VPROF_BUDGET( "VGui_DrawHud", VPROF_BUDGETGROUP_OTHER_VGUI );
//
// gHUD.SetRenderingStage( stage );
// // paint the vgui screen
// if ( bMainPass )
// VGui_PreRender();
//
// // Make sure the client .dll root panel is at the proper point before doing the "SolveTraverse" calls
// vgui::VPANEL root = enginevgui->GetPanel( PANEL_CLIENTDLL );
// if ( root != 0 )
// {
// vgui::ipanel()->SetPos( root, view.x, view.y );
// vgui::ipanel()->SetSize( root, view.width, view.height );
// }
// // Same for client .dll tools
// root = enginevgui->GetPanel( PANEL_CLIENTDLL_TOOLS );
// if ( root != 0 )
// {
// vgui::ipanel()->SetPos( root, view.x, view.y );
// vgui::ipanel()->SetSize( root, view.width, view.height );
// }
//
// // The crosshair, etc. needs to get at the current setup stuff
// AllowCurrentViewAccess( true );
//
// // Draw the in-game stuff based on the actual viewport being used
// render->VGui_Paint( PAINT_INGAMEPANELS );
//
// AllowCurrentViewAccess( false );
//
// if ( bMainPass )
// {
// VGui_PostRender();
//
// g_pClientMode->PostRenderVGui();
// materials->Flush();
// }
//}
VPROF_BUDGET( "VGui_DrawHud", VPROF_BUDGETGROUP_OTHER_VGUI );
gHUD.SetRenderingStage( stage );
// paint the vgui screen
//if ( bMainPass )
// VGui_PreRender();
//// Make sure the client .dll root panel is at the proper point before doing the "SolveTraverse" calls
//vgui::VPANEL root = enginevgui->GetPanel( PANEL_CLIENTDLL );
//if ( root != 0 )
//{
// vgui::ipanel()->SetPos( root, view.x, view.y );
// vgui::ipanel()->SetSize( root, view.width, view.height );
//}
//// Same for client .dll tools
//root = enginevgui->GetPanel( PANEL_CLIENTDLL_TOOLS );
//if ( root != 0 )
//{
// vgui::ipanel()->SetPos( root, view.x, view.y );
// vgui::ipanel()->SetSize( root, view.width, view.height );
//}
//// The crosshair, etc. needs to get at the current setup stuff
//AllowCurrentViewAccess( true );
//// Draw the in-game stuff based on the actual viewport being used
//render->VGui_Paint( PAINT_INGAMEPANELS );
//AllowCurrentViewAccess( false );
//if ( bMainPass )
//{
// VGui_PostRender();
// g_pClientMode->PostRenderVGui();
// materials->Flush();
//}
CMatRenderContextPtr renderContext( materials );
VPROF_BUDGET( "VGui_DrawHud", VPROF_BUDGETGROUP_OTHER_VGUI );
int viewWidth = view.m_nUnscaledWidth;
int viewHeight = view.m_nUnscaledHeight;
int viewActualWidth = view.m_nUnscaledWidth;
int viewActualHeight = view.m_nUnscaledHeight;
int viewX = view.m_nUnscaledX;
int viewY = view.m_nUnscaledY;
int viewFramebufferX = 0;
int viewFramebufferY = 0;
int viewFramebufferWidth = viewWidth;
int viewFramebufferHeight = viewHeight;
bool bClear = false;
bool bPaintMainMenu = false;
ITexture *pTexture = NULL;
//if( UseVR() )
//{
// if( g_ClientVirtualReality.ShouldRenderHUDInWorld() )
// {
// pTexture = materials->FindTexture( "_rt_gui", NULL, false );
// if( pTexture )
// {
// bPaintMainMenu = true;
// bClear = true;
// viewX = 0;
// viewY = 0;
// viewActualWidth = pTexture->GetActualWidth();
// viewActualHeight = pTexture->GetActualHeight();
// vgui::surface()->GetScreenSize( viewWidth, viewHeight );
// viewFramebufferX = view.m_eStereoEye == STEREO_EYE_RIGHT ? viewFramebufferWidth : 0;
// viewFramebufferY = 0;
// }
// }
// else
// {
// viewFramebufferX = view.m_eStereoEye == STEREO_EYE_RIGHT ? viewWidth : 0;
// viewFramebufferY = 0;
// }
//}
// Get the render context out of materials to avoid some debug stuff.
// WARNING THIS REQUIRES THE .SafeRelease below or it'll never release the ref
//pRenderContext = materials->GetRenderContext();
// clear depth in the backbuffer before we push the render target
if( bClear )
{
renderContext->ClearBuffers( false, true, true );
}
// constrain where VGUI can render to the view
renderContext->PushRenderTargetAndViewport( pTexture, NULL, viewX, viewY, viewActualWidth, viewActualHeight );
// If drawing off-screen, force alpha for that pass
if (pTexture)
{
renderContext->OverrideAlphaWriteEnable( true, true );
}
// let vgui know where to render stuff for the forced-to-framebuffer panels
if( UseVR() )
{
vgui::surface()->SetFullscreenViewport( viewFramebufferX, viewFramebufferY, viewFramebufferWidth, viewFramebufferHeight );
}
// clear the render target if we need to
if( bClear )
{
renderContext->ClearColor4ub( 0, 0, 0, 0 );
renderContext->ClearBuffers( true, false );
}
//renderContext.SafeRelease();
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "VGui_DrawHud", __FUNCTION__ );
// paint the vgui screen
if ( bMainPass )
{
VGui_PreRender();
}
// Make sure the client .dll root panel is at the proper point before doing the "SolveTraverse" calls
vgui::VPANEL root = enginevgui->GetPanel( PANEL_CLIENTDLL );
if ( root != 0 )
{
vgui::ipanel()->SetPos( root, viewX, viewY );
vgui::ipanel()->SetSize( root, viewWidth, viewHeight );
}
// Same for client .dll tools
root = enginevgui->GetPanel( PANEL_CLIENTDLL_TOOLS );
if ( root != 0 )
{
vgui::ipanel()->SetPos( root, viewX, viewY );
vgui::ipanel()->SetSize( root, viewWidth, viewHeight );
}
// The crosshair, etc. needs to get at the current setup stuff
AllowCurrentViewAccess( true );
// Draw the in-game stuff based on the actual viewport being used
render->VGui_Paint( PAINT_INGAMEPANELS );
// maybe paint the main menu and cursor too if we're in stereo hud mode
if( bPaintMainMenu )
render->VGui_Paint( PAINT_UIPANELS | PAINT_CURSOR );
AllowCurrentViewAccess( false );
if ( bMainPass )
{
VGui_PostRender();
g_pClientMode->PostRenderVGui();
}
//pRenderContext = materials->GetRenderContext();
if (pTexture)
{
renderContext->OverrideAlphaWriteEnable( false, true );
}
renderContext->PopRenderTargetAndViewport();
//if ( UseVR() )
//{
// // figure out if we really want to draw the HUD based on freeze cam
// C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
// bool bInFreezeCam = ( pPlayer && pPlayer->GetObserverMode() == OBS_MODE_FREEZECAM );
// // draw the HUD after the view model so its "I'm closer" depth queues work right.
// if( !bInFreezeCam && g_ClientVirtualReality.ShouldRenderHUDInWorld() )
// {
// // Now we've rendered the HUD to its texture, actually get it on the screen.
// // Since we're drawing it as a 3D object, we need correctly set up frustum, etc.
// int ClearFlags = 0;
// SetupMain3DView( view, ClearFlags );
// // TODO - a bit of a shonky test - basically trying to catch the main menu, the briefing screen, the loadout screen, etc.
// bool bTranslucent = !g_pMatSystemSurface->IsCursorVisible();
// g_ClientVirtualReality.RenderHUDQuad( g_pClientMode->ShouldBlackoutAroundHUD(), bTranslucent );
// CleanupMain3DView( view );
// }
//}
//renderContext->Flush();
}
// END GSTRINGMIGRATION
//-----------------------------------------------------------------------------
// Purpose: This renders the entire 3D view and the in-game hud/viewmodel
@ -1976,7 +2129,17 @@ void CViewRender::RenderView( const CViewSetup &view, int nClearFlags, int whatT
CMatRenderContextPtr pRenderContext( materials );
ITexture *saveRenderTarget = pRenderContext->GetRenderTarget();
pRenderContext.SafeRelease(); // don't want to hold for long periods in case in a locking active share thread mode
const bool bBuildingCubemaps = building_cubemaps.GetBool(); // GSTRINGMIGRATION
const bool bShouldUpdateSkymask = !bBuildingCubemaps && ShouldDrawGodrays();
// GSTRINGMIGRATION
pRenderContext->SetFloatRenderingParameter( FLOAT_RENDERPARM_MINIMUMLIGHTING,
bBuildingCubemaps ?
0.0f : GetNightvisionMinLighting() );
// END GSTRINGMIGRATION
pRenderContext.SafeRelease(); // don't want to hold for long periods in case in a locking active share thread mode // GSTRINGMIGRATION
if ( !m_rbTakeFreezeFrame[ view.m_eStereoEye ] && m_flFreezeFrameUntil > gpGlobals->curtime )
{
@ -2025,7 +2188,8 @@ void CViewRender::RenderView( const CViewSetup &view, int nClearFlags, int whatT
AddViewToScene( pSkyView );
// GSTRINGMIGRATION
g_ShaderEditorSystem->UpdateSkymask();
if ( bShouldUpdateSkymask )
g_ShaderEditorSystem->UpdateSkymask();
// END GSTRINGMIGRATION
}
SafeRelease( pSkyView );
@ -2060,24 +2224,35 @@ void CViewRender::RenderView( const CViewSetup &view, int nClearFlags, int whatT
// Finish scene
render->SceneEnd();
// GSTRINGMIGRATION
// Draw lightsources if enabled
render->DrawLights();
//render->DrawLights();
RenderPlayerSprites();
//RenderPlayerSprites();
// Image-space motion blur
if ( !building_cubemaps.GetBool() && view.m_bDoBloomAndToneMapping ) // We probably should use a different view. variable here
//if ( !building_cubemaps.GetBool() && view.m_bDoBloomAndToneMapping ) // We probably should use a different view. variable here
//{
// if ( ( mat_motion_blur_enabled.GetInt() ) && ( g_pMaterialSystemHardwareConfig->GetDXSupportLevel() >= 90 ) )
// {
// pRenderContext.GetFrom( materials );
// {
// PIXEVENT( pRenderContext, "DoImageSpaceMotionBlur" );
// DoImageSpaceMotionBlur( view, view.x, view.y, view.width, view.height );
// }
// pRenderContext.SafeRelease();
// }
//}
if ( !bBuildingCubemaps )
{
if ( ( mat_motion_blur_enabled.GetInt() ) && ( g_pMaterialSystemHardwareConfig->GetDXSupportLevel() >= 90 ) )
{
pRenderContext.GetFrom( materials );
{
PIXEVENT( pRenderContext, "DoImageSpaceMotionBlur" );
DoImageSpaceMotionBlur( view, view.x, view.y, view.width, view.height );
}
pRenderContext.SafeRelease();
}
UpdateScreenEffectTexture();
PerformScenePostProcessHack();
DrawMotionBlur();
}
// END GSTRINGMIGRATION
GetClientModeNormal()->DoPostScreenSpaceEffects( &view );
@ -2085,7 +2260,8 @@ void CViewRender::RenderView( const CViewSetup &view, int nClearFlags, int whatT
DrawViewModels( view, whatToDraw & RENDERVIEW_DRAWVIEWMODEL );
// GSTRINGMIGRATION
g_ShaderEditorSystem->UpdateSkymask( bDrew3dSkybox );
if ( bShouldUpdateSkymask )
g_ShaderEditorSystem->UpdateSkymask( bDrew3dSkybox );
// END GSTRINGMIGRATION
DrawUnderwaterOverlay();
@ -2103,7 +2279,24 @@ void CViewRender::RenderView( const CViewSetup &view, int nClearFlags, int whatT
// Overlay screen fade on entire screen
IMaterial* pMaterial = blend ? m_ModulateSingleColor : m_TranslucentSingleColor;
render->ViewDrawFade( color, pMaterial );
PerformScreenOverlay( view.x, view.y, view.width, view.height );
//PerformScreenOverlay( view.x, view.y, view.width, view.height ); // GSTRINGMIGRATION
// GSTRINGMIGRATION
if ( whatToDraw & RENDERVIEW_DRAWHUD && !bBuildingCubemaps )
{
render->Push2DView( view, 0, saveRenderTarget, GetFrustum() );
DrawVGUILayer( CHud::HUDRENDERSTAGE_PRE_HDR, view );
render->PopView( GetFrustum() );
UpdateScreenEffectTexture( 0, view.x, view.y, view.width, view.height );
}
if ( !bBuildingCubemaps )
{
DrawScreenGaussianBlur();
DrawDreamBlur();
}
// END GSTRINGMIGRATION
// Prevent sound stutter if going slow
engine->Sound_ExtraUpdate();
@ -2126,6 +2319,21 @@ void CViewRender::RenderView( const CViewSetup &view, int nClearFlags, int whatT
}
// GSTRINGMIGRATION
if ( !bBuildingCubemaps )
{
DrawOverlaysForMode( CScreenoverlayMulti::RENDERMODE_POST_HDR,
view.x, view.y, view.width, view.height );
DrawExplosionBlur();
DrawGodrays();
if ( view.m_bDoBloomAndToneMapping )
DrawBloomFlare();
DrawNightvision();
}
g_ShaderEditorSystem->CustomPostRender();
// END GSTRINGMIGRATION
@ -2148,6 +2356,25 @@ void CViewRender::RenderView( const CViewSetup &view, int nClearFlags, int whatT
pRenderContext.SafeRelease();
}
// GSTRINGMIGRATION
if ( whatToDraw & RENDERVIEW_DRAWHUD && !bBuildingCubemaps )
{
render->Push2DView( view, 0, saveRenderTarget, GetFrustum() );
DrawVGUILayer( CHud::HUDRENDERSTAGE_PRE_BARS, view );
render->PopView( GetFrustum() );
UpdateScreenEffectTexture( 0, view.x, view.y, view.width, view.height );
}
if ( !bBuildingCubemaps )
{
DrawOverlaysForMode( CScreenoverlayMulti::RENDERMODE_POST_POSTPROCESSING,
view.x, view.y, view.width, view.height );
if ( whatToDraw & RENDERVIEW_DRAWHUD )
DrawBarsAndGrain( view.x, view.y, view.width, view.height );
}
// END GSTRINGMIGRATION
CleanupMain3DView( view );
if ( m_rbTakeFreezeFrame[ view.m_eStereoEye ] )
@ -2226,150 +2453,17 @@ void CViewRender::RenderView( const CViewSetup &view, int nClearFlags, int whatT
Render2DEffectsPreHUD( view );
// GSTRINGMIGRATION
if ( whatToDraw & RENDERVIEW_DRAWHUD )
{
VPROF_BUDGET( "VGui_DrawHud", VPROF_BUDGETGROUP_OTHER_VGUI );
int viewWidth = view.m_nUnscaledWidth;
int viewHeight = view.m_nUnscaledHeight;
int viewActualWidth = view.m_nUnscaledWidth;
int viewActualHeight = view.m_nUnscaledHeight;
int viewX = view.m_nUnscaledX;
int viewY = view.m_nUnscaledY;
int viewFramebufferX = 0;
int viewFramebufferY = 0;
int viewFramebufferWidth = viewWidth;
int viewFramebufferHeight = viewHeight;
bool bClear = false;
bool bPaintMainMenu = false;
ITexture *pTexture = NULL;
if( UseVR() )
{
if( g_ClientVirtualReality.ShouldRenderHUDInWorld() )
{
pTexture = materials->FindTexture( "_rt_gui", NULL, false );
if( pTexture )
{
bPaintMainMenu = true;
bClear = true;
viewX = 0;
viewY = 0;
viewActualWidth = pTexture->GetActualWidth();
viewActualHeight = pTexture->GetActualHeight();
vgui::surface()->GetScreenSize( viewWidth, viewHeight );
viewFramebufferX = view.m_eStereoEye == STEREO_EYE_RIGHT ? viewFramebufferWidth : 0;
viewFramebufferY = 0;
}
}
else
{
viewFramebufferX = view.m_eStereoEye == STEREO_EYE_RIGHT ? viewWidth : 0;
viewFramebufferY = 0;
}
}
// Get the render context out of materials to avoid some debug stuff.
// WARNING THIS REQUIRES THE .SafeRelease below or it'll never release the ref
pRenderContext = materials->GetRenderContext();
// clear depth in the backbuffer before we push the render target
if( bClear )
{
pRenderContext->ClearBuffers( false, true, true );
}
// constrain where VGUI can render to the view
pRenderContext->PushRenderTargetAndViewport( pTexture, NULL, viewX, viewY, viewActualWidth, viewActualHeight );
// If drawing off-screen, force alpha for that pass
if (pTexture)
{
pRenderContext->OverrideAlphaWriteEnable( true, true );
}
// let vgui know where to render stuff for the forced-to-framebuffer panels
if( UseVR() )
{
vgui::surface()->SetFullscreenViewport( viewFramebufferX, viewFramebufferY, viewFramebufferWidth, viewFramebufferHeight );
}
// clear the render target if we need to
if( bClear )
{
pRenderContext->ClearColor4ub( 0, 0, 0, 0 );
pRenderContext->ClearBuffers( true, false );
}
pRenderContext.SafeRelease();
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "VGui_DrawHud", __FUNCTION__ );
// paint the vgui screen
VGui_PreRender();
// Make sure the client .dll root panel is at the proper point before doing the "SolveTraverse" calls
vgui::VPANEL root = enginevgui->GetPanel( PANEL_CLIENTDLL );
if ( root != 0 )
{
vgui::ipanel()->SetSize( root, viewWidth, viewHeight );
}
// Same for client .dll tools
root = enginevgui->GetPanel( PANEL_CLIENTDLL_TOOLS );
if ( root != 0 )
{
vgui::ipanel()->SetSize( root, viewWidth, viewHeight );
}
// The crosshair, etc. needs to get at the current setup stuff
AllowCurrentViewAccess( true );
// Draw the in-game stuff based on the actual viewport being used
render->VGui_Paint( PAINT_INGAMEPANELS );
// maybe paint the main menu and cursor too if we're in stereo hud mode
if( bPaintMainMenu )
render->VGui_Paint( PAINT_UIPANELS | PAINT_CURSOR );
AllowCurrentViewAccess( false );
VGui_PostRender();
g_pClientMode->PostRenderVGui();
pRenderContext = materials->GetRenderContext();
if (pTexture)
{
pRenderContext->OverrideAlphaWriteEnable( false, true );
}
pRenderContext->PopRenderTargetAndViewport();
if ( UseVR() )
{
// figure out if we really want to draw the HUD based on freeze cam
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
bool bInFreezeCam = ( pPlayer && pPlayer->GetObserverMode() == OBS_MODE_FREEZECAM );
// draw the HUD after the view model so its "I'm closer" depth queues work right.
if( !bInFreezeCam && g_ClientVirtualReality.ShouldRenderHUDInWorld() )
{
// Now we've rendered the HUD to its texture, actually get it on the screen.
// Since we're drawing it as a 3D object, we need correctly set up frustum, etc.
int ClearFlags = 0;
SetupMain3DView( view, ClearFlags );
// TODO - a bit of a shonky test - basically trying to catch the main menu, the briefing screen, the loadout screen, etc.
bool bTranslucent = !g_pMatSystemSurface->IsCursorVisible();
g_ClientVirtualReality.RenderHUDQuad( g_pClientMode->ShouldBlackoutAroundHUD(), bTranslucent );
CleanupMain3DView( view );
}
}
pRenderContext->Flush();
pRenderContext.SafeRelease();
}
DrawVGUILayer( CHud::HUDRENDERSTAGE_DEFAULT_HUD, view );
// END GSTRINGMIGRATION
CDebugViewRender::Draw2DDebuggingInfo( view );
Render2DEffectsPostHUD( view );
DrawDesaturation(); // GSTRINGMIGRATION
g_bRenderingView = false;
// We can no longer use the 'current view' stuff set up in ViewDrawScene

2
sp/src/game/server/enginecallback.h
View file

@ -53,6 +53,8 @@ extern CSteamGameServerAPIContext *steamgameserverapicontext; //available on gam
//-----------------------------------------------------------------------------
void PrecacheMaterial( const char *pMaterialName );
int PrecacheMaterialGetIndex( const char *pszMatName ); // GSTRINGMIGRATION
//-----------------------------------------------------------------------------
// Converts a previously precached material into an index
//-----------------------------------------------------------------------------

7
sp/src/game/server/gameinterface.cpp
View file

@ -2230,6 +2230,13 @@ void PrecacheMaterial( const char *pMaterialName )
g_pStringTableMaterials->AddString( CBaseEntity::IsServer(), pMaterialName );
}
// GSTRINGMIGRATION
int PrecacheMaterialGetIndex( const char *pszMatName )
{
Assert( pszMatName && pszMatName[0] );
return g_pStringTableMaterials->AddString( CBaseEntity::IsServer(), pszMatName );
}
// END GSTRINGMIGRATION
//-----------------------------------------------------------------------------
// Converts a previously precached material into an index

237
sp/src/game/shared/gstring/cscreenoverlay_multi.cpp Normal file
View file

@ -0,0 +1,237 @@
#include "cbase.h"
#include "Gstring/cscreenoverlay_multi.h"
#ifdef GAME_DLL
#define OVERLAYFLAGS_ENABLED 0x01
#else
#include "cdll_client_int.h"
#include "view_scene.h"
#endif
static CUtlVector< CScreenoverlayMulti* > g_hScreenoverlayList;
static int OverlaySort( CScreenoverlayMulti *const *p1, CScreenoverlayMulti *const *p2 )
{
if ( (*p1)->GetOverlayRenderMode() != (*p2)->GetOverlayRenderMode() )
return ( (*p1)->GetOverlayRenderMode() < (*p2)->GetOverlayRenderMode() ) ? -1 : 1;
return ( (*p1)->GetRenderIndex() < (*p2)->GetRenderIndex() ) ? -1 : 1;
}
static void AddOverlay( CScreenoverlayMulti *o )
{
Assert( !g_hScreenoverlayList.HasElement( o ) );
g_hScreenoverlayList.AddToTail( o );
g_hScreenoverlayList.Sort( OverlaySort );
}
static void RemoveOverlay( CScreenoverlayMulti *o )
{
Assert( g_hScreenoverlayList.HasElement( o ) );
g_hScreenoverlayList.FindAndRemove( o );
}
#ifdef CLIENT_DLL
void DrawOverlaysForMode( CScreenoverlayMulti::RENDERMODE mode, int x, int y, int w, int h )
{
for ( int i = 0; i < g_hScreenoverlayList.Count(); i++ )
{
CScreenoverlayMulti *o = g_hScreenoverlayList[ i ];
if ( mode != o->GetOverlayRenderMode() )
continue;
if ( !o->IsEnabled() )
continue;
o->RenderOverlay( x, y, w, h );
}
}
#endif
#ifdef GAME_DLL
static void ValidateEntityData()
{
for ( int a = 0; a < g_hScreenoverlayList.Count(); a++ )
{
CScreenoverlayMulti *overlay_0 = g_hScreenoverlayList[a];
for ( int b = 0; b < g_hScreenoverlayList.Count(); b++ )
{
if ( a == b )
continue;
CScreenoverlayMulti *overlay_1 = g_hScreenoverlayList[b];
if ( overlay_0->GetOverlayRenderMode() != overlay_1->GetOverlayRenderMode() )
continue;
if ( overlay_0->GetRenderIndex() != overlay_1->GetRenderIndex() )
continue;
Warning( "WARNING: two env_screenoverlay_multi entities are using the same render mode and index!\n" );
const char *name_0 = STRING( overlay_0->GetEntityName() );
const char *name_1 = STRING( overlay_1->GetEntityName() );
Warning( " mode: %i, index: %i, entity name A: %s, name B: %s\n",
overlay_0->GetOverlayRenderMode(), overlay_0->GetRenderIndex(),
(name_0 ? name_0 : "NONAME"), (name_1 ? name_1 : "NONAME") );
}
}
};
#endif
#ifdef GAME_DLL
BEGIN_DATADESC( CScreenoverlayMulti )
DEFINE_KEYFIELD( m_strOverlayMaterial, FIELD_STRING, "overlayname" ),
DEFINE_KEYFIELD( m_iRenderMode, FIELD_INTEGER, "rendermode" ),
DEFINE_KEYFIELD( m_iRenderIndex, FIELD_INTEGER, "renderindex" ),
DEFINE_FIELD( m_iMaterialIndex, FIELD_INTEGER ),
DEFINE_FIELD( m_bEnabled, FIELD_BOOLEAN ),
DEFINE_INPUTFUNC( FIELD_VOID, "enable", InputEnable ),
DEFINE_INPUTFUNC( FIELD_VOID, "disable", InputDisable ),
DEFINE_INPUTFUNC( FIELD_VOID, "toggle", InputToggle ),
END_DATADESC()
#endif
IMPLEMENT_NETWORKCLASS_DT( CScreenoverlayMulti, CScreenoverlayMulti_DT )
#ifdef GAME_DLL
SendPropInt( SENDINFO( m_iMaterialIndex ) ),
SendPropInt( SENDINFO( m_iRenderMode ) ),
SendPropInt( SENDINFO( m_iRenderIndex ) ),
SendPropBool( SENDINFO( m_bEnabled ) ),
#else
RecvPropInt( RECVINFO( m_iMaterialIndex ) ),
RecvPropInt( RECVINFO( m_iRenderMode ) ),
RecvPropInt( RECVINFO( m_iRenderIndex ) ),
RecvPropBool( RECVINFO( m_bEnabled ) ),
#endif
END_NETWORK_TABLE();
LINK_ENTITY_TO_CLASS( env_screenoverlay_multi, CScreenoverlayMulti );
CScreenoverlayMulti::CScreenoverlayMulti()
{
#ifdef GAME_DLL
AddOverlay( this );
#endif
}
CScreenoverlayMulti::~CScreenoverlayMulti()
{
#ifdef GAME_DLL
RemoveOverlay( this );
#endif
}
int CScreenoverlayMulti::GetOverlayRenderMode()
{
return m_iRenderMode;
}
int CScreenoverlayMulti::GetRenderIndex()
{
return m_iRenderIndex;
}
bool CScreenoverlayMulti::IsEnabled()
{
return m_bEnabled;
}
#ifdef GAME_DLL
void CScreenoverlayMulti::Spawn()
{
BaseClass::Spawn();
SetEnabled( HasSpawnFlags( OVERLAYFLAGS_ENABLED ) );
}
void CScreenoverlayMulti::Activate()
{
m_iMaterialIndex = -1;
BaseClass::Activate();
Assert( m_strOverlayMaterial.ToCStr() && m_strOverlayMaterial.ToCStr()[0] != '\0' );
m_iMaterialIndex = PrecacheMaterialGetIndex( m_strOverlayMaterial.ToCStr() );
Assert( m_iMaterialIndex >= 0 );
ValidateEntityData();
}
int CScreenoverlayMulti::UpdateTransmitState()
{
return SetTransmitState( FL_EDICT_ALWAYS );
}
void CScreenoverlayMulti::SetEnabled( bool bEnabled )
{
m_bEnabled = bEnabled;
}
void CScreenoverlayMulti::InputEnable( inputdata_t &inputdata )
{
SetEnabled( true );
}
void CScreenoverlayMulti::InputDisable( inputdata_t &inputdata )
{
SetEnabled( false );
}
void CScreenoverlayMulti::InputToggle( inputdata_t &inputdata )
{
SetEnabled( !IsEnabled() );
}
#else
void CScreenoverlayMulti::OnDataChanged( DataUpdateType_t t )
{
BaseClass::OnDataChanged( t );
if ( t == DATA_UPDATE_CREATED )
{
Assert( m_iMaterialIndex >= 0 );
const char *pszMat = GetMaterialNameFromIndex( m_iMaterialIndex );
Assert( pszMat != NULL );
if ( pszMat != NULL )
{
m_matOverlay.Init( pszMat, TEXTURE_GROUP_CLIENT_EFFECTS );
}
AddOverlay( this );
}
}
void CScreenoverlayMulti::RenderOverlay( int x, int y, int w, int h )
{
DrawScreenEffectMaterial( m_matOverlay, x, y, w, h );
}
void CScreenoverlayMulti::UpdateOnRemove()
{
BaseClass::UpdateOnRemove();
RemoveOverlay( this );
}
#endif

76
sp/src/game/shared/gstring/cscreenoverlay_multi.h Normal file
View file

@ -0,0 +1,76 @@
#ifndef C_SCREEN_OVERLAY_MULTI_H
#define C_SCREEN_OVERLAY_MULTI_H
#include "cbase.h"
class CScreenoverlayMulti : public CBaseEntity
{
DECLARE_CLASS( CScreenoverlayMulti, CBaseEntity );
DECLARE_NETWORKCLASS();
#ifdef GAME_DLL
DECLARE_DATADESC();
#endif
public:
enum RENDERMODE
{
RENDERMODE_PRE_POSTPROCESSING = 0,
RENDERMODE_POST_HDR,
RENDERMODE_POST_POSTPROCESSING,
};
CScreenoverlayMulti();
~CScreenoverlayMulti();
#ifdef GAME_DLL
virtual void Spawn();
virtual void Activate();
virtual int UpdateTransmitState();
void SetEnabled( bool bEnabled );
void InputEnable( inputdata_t &inputdata );
void InputDisable( inputdata_t &inputdata );
void InputToggle( inputdata_t &inputdata );
virtual int ObjectCaps( void ){
return BaseClass::ObjectCaps() & ~FCAP_ACROSS_TRANSITION;
};
#else
virtual void OnDataChanged( DataUpdateType_t t );
virtual void UpdateOnRemove();
void RenderOverlay( int x, int y, int w, int h );
#endif
int GetOverlayRenderMode();
int GetRenderIndex();
bool IsEnabled();
private:
#ifdef GAME_DLL
string_t m_strOverlayMaterial;
#else
CMaterialReference m_matOverlay;
#endif
CNetworkVar( int, m_iMaterialIndex );
CNetworkVar( int, m_iRenderMode );
CNetworkVar( int, m_iRenderIndex );
CNetworkVar( bool, m_bEnabled );
};
#ifdef CLIENT_DLL
void DrawOverlaysForMode( CScreenoverlayMulti::RENDERMODE mode, int x, int y, int w, int h );
#endif
#endif

3
sp/src/game/shared/shared_gstring.vpc
View file

@ -14,6 +14,9 @@ $Project
$File "$SRCDIR\game\shared\gstring\clensflare_base.cpp"
$File "$SRCDIR\game\shared\gstring\clensflare_base.h"
$File "$SRCDIR\game\shared\gstring\cscreenoverlay_multi.cpp"
$File "$SRCDIR\game\shared\gstring\cscreenoverlay_multi.h"
}
}
}

38
sp/src/materialsystem/stdshaders/lightmappedgeneric_dx9.cpp
View file

@ -104,6 +104,8 @@ END_SHADER_PARAMS
info.m_nNoDiffuseBumpLighting = NODIFFUSEBUMPLIGHTING;
info.m_nBumpmap2 = BUMPMAP2;
info.m_nBumpFrame2 = BUMPFRAME2;
info.m_nBumpTransform2 = BUMPTRANSFORM2;
info.m_nBumpMask = BUMPMASK;
info.m_nBaseTexture2 = BASETEXTURE2;
info.m_nBaseTexture2Frame = FRAME2;
info.m_nBaseTextureNoEnvmap = BASETEXTURENOENVMAP;
@ -115,7 +117,13 @@ END_SHADER_PARAMS
info.m_nBlendModulateTexture = BLENDMODULATETEXTURE;
info.m_nMaskedBlending = MASKEDBLENDING;
info.m_nBlendMaskTransform = BLENDMASKTRANSFORM;
info.m_nSelfShadowedBumpFlag = SSBUMP;
info.m_nSeamlessMappingScale = SEAMLESS_SCALE;
info.m_nAlphaTestReference = ALPHATESTREFERENCE;
info.m_nSoftEdges = SOFTEDGES;
info.m_nEdgeSoftnessStart = EDGESOFTNESSSTART;
info.m_nEdgeSoftnessEnd = EDGESOFTNESSEND;
info.m_nOutline = OUTLINE;
info.m_nOutlineColor = OUTLINECOLOR;
info.m_nOutlineAlpha = OUTLINEALPHA;
@ -123,36 +131,6 @@ END_SHADER_PARAMS
info.m_nOutlineStart1 = OUTLINESTART1;
info.m_nOutlineEnd0 = OUTLINEEND0;
info.m_nOutlineEnd1 = OUTLINEEND1;
info.m_nSoftEdges = SOFTEDGES;
info.m_nEdgeSoftnessStart = EDGESOFTNESSSTART;
info.m_nEdgeSoftnessEnd = EDGESOFTNESSEND;
info.m_nAlphaTestReference = ALPHATESTREFERENCE;
info.m_nSelfShadowedBumpFlag = SSBUMP;
info.m_nSeamlessMappingScale = SEAMLESS_SCALE;
info.m_nBumpmap = BUMPMAP;
info.m_nBumpFrame = BUMPFRAME;
info.m_nBumpTransform = BUMPTRANSFORM;
info.m_nEnvmapContrast = ENVMAPCONTRAST;
info.m_nEnvmapSaturation = ENVMAPSATURATION;
info.m_nFresnelReflection = FRESNELREFLECTION;
info.m_nNoDiffuseBumpLighting = NODIFFUSEBUMPLIGHTING;
info.m_nBumpmap2 = BUMPMAP2;
info.m_nBumpFrame2 = BUMPFRAME2;
info.m_nBaseTexture2 = BASETEXTURE2;
info.m_nBaseTexture2Frame = FRAME2;
info.m_nBumpTransform2 = BUMPTRANSFORM2;
info.m_nBumpMask = BUMPMASK;
info.m_nBaseTextureNoEnvmap = BASETEXTURENOENVMAP;
info.m_nBaseTexture2NoEnvmap = BASETEXTURE2NOENVMAP;
info.m_nDetailAlphaMaskBaseTexture = DETAIL_ALPHA_MASK_BASE_TEXTURE;
info.m_nFlashlightTexture = FLASHLIGHTTEXTURE;
info.m_nFlashlightTextureFrame = FLASHLIGHTTEXTUREFRAME;
info.m_nLightWarpTexture = LIGHTWARPTEXTURE;
info.m_nBlendModulateTexture = BLENDMODULATETEXTURE;
info.m_nBlendMaskTransform = BLENDMASKTRANSFORM;
}
SHADER_FALLBACK

6
sp/src/public/renderparm.h
View file

@ -72,4 +72,10 @@ enum RenderParamTexture_t
#define ENABLE_FIXED_LIGHTING_OUTPUTMRTS_FOR_DEFERRED_LIGHTING 2
#define ENABLE_FIXED_LIGHTING_OUTPUTNORMAL_AND_DEPTH 3
enum RenderParamFloat_t
{
FLOAT_RENDERPARM_MINIMUMLIGHTING = 0,
};
#endif // RENDERPARM_H