Implementing Deferred lighting into Source 2013

Warning:This page is nowhere near finished, and WILL NOT WORK until its fully completed!

This is a draft page. It is a work in progress open to editing by anyone.
Remember to check for any notes left by the tagger at this article's talk page.

…

Having Deferred lighting in your mod comes with quite a lot of upsides as with it, you can have volumetric lighting, realtime shadows and lighting from the sun and from other light sources, while still keeping the performance steady which is something that Source's regular dynamic light entities would be incapable of (aka projected textures).

Implementing into your Source 2013SP mod

Now we are going to use Lambda Wars's implementation for it as its an enhanced/upgraded version of Alien Swarm Deferred's, but beware implementing deferred lighting in your mod is extremely complex requiring you to modify client and server side code, and even add new shaders to your game. Among other things source's default shaders are also needed to be modified.

Clientside

Todo: Modify this code so that it will work with Source 2013, right now this is raw code from LW's source code.

Now before we begin you will have to download the following files from Lambda Wars github, And put them into a folder named deferred then put that into the clients directory.

deferred ,This folder contents are needed which are:
- cascade_t.cpp
- cascade_t.h
- DefCookieProjectable.cpp
- DefCookieProjectable.h
- DefCookieTexture.cpp
- DefCookieTexture.h
- IDefCookie.h
- IDeferredExtClient.cpp
- cdeferred_manager_client.cpp
- cdeferred_manager_client.h
- clight_editor.cpp
- clight_editor.h
- clight_manager.cpp
- clight_manager.h
- def_light_t.cpp
- def_light_t.h
- deferred_client_common.cpp
- deferred_client_common.h
- deferred_rt.cpp
- deferred_rt.h
- flashlighteffect_deferred.cpp
- flashlighteffect_deferred.h
- viewrender_deferred.cpp
- viewrender_deferred.h
- vgui
  - projectable_factory.cpp
  - projectable_factory.h
  - vgui_deferred.h
  - vgui_editor_controls.cpp
  - vgui_editor_controls.h
  - vgui_editor_props.cpp
  - vgui_editor_props.h
  - vgui_editor_root.cpp
  - vgui_marquee.cpp
  - vgui_marquee.h
  - vgui_particles.cpp
  - vgui_particles.h
  - vgui_particles.cpp
  - vgui_projectable.cpp
  - vgui_projectable.h

Now we are going to add our new files to our client project inside "Source Files" of client_hl2.vpc like so.

$Folder	"Deferred"
		{
			$Folder "Shared"
			{
				$File	"$SRCDIR\game\shared\deferred\CDefLight.cpp"
				$File	"$SRCDIR\game\shared\deferred\CDefLight.h"
				$File	"$SRCDIR\game\shared\deferred\CDefLightContainer.cpp"
				$File	"$SRCDIR\game\shared\deferred\CDefLightContainer.h"
				$File	"$SRCDIR\game\shared\deferred\CDefLightGlobal.cpp"
				$File	"$SRCDIR\game\shared\deferred\CDefLightGlobal.h"
				$File	"$SRCDIR\game\shared\deferred\deferred_shared_common.cpp"
				$File	"$SRCDIR\game\shared\deferred\deferred_shared_common.h"
				$File	"$SRCDIR\game\shared\deferred\ssemath_ext.h"
			}
		
			$Folder "Client"
			{
				$Folder "VGUI"
				{
					$File	"deferred\vgui\projectable_factory.cpp"
					$File	"deferred\vgui\projectable_factory.h"
					$File	"deferred\vgui\vgui_deferred.h"
					$File	"deferred\vgui\vgui_editor_controls.cpp"
					$File	"deferred\vgui\vgui_editor_controls.h"
					$File	"deferred\vgui\vgui_editor_props.cpp"
					$File	"deferred\vgui\vgui_editor_props.h"
					$File	"deferred\vgui\vgui_editor_root.cpp"
					$File	"deferred\vgui\vgui_marquee.cpp"
					$File	"deferred\vgui\vgui_marquee.h"
					$File	"deferred\vgui\vgui_particles.cpp"
					$File	"deferred\vgui\vgui_particles.h"
					$File	"deferred\vgui\vgui_projectable.cpp"
					$File	"deferred\vgui\vgui_projectable.h"
				}
			
				$File	"deferred\cascade_t.h"
				$File	"deferred\cascade_t.cpp"
				$File	"deferred\DefCookieProjectable.cpp"
				$File	"deferred\DefCookieProjectable.h"
				$File	"deferred\DefCookieTexture.cpp"
				$File	"deferred\DefCookieTexture.h"
				$File	"deferred\IDefCookie.h"
				$File	"deferred\IDeferredExtClient.cpp"
				$File	"deferred\cdeferred_manager_client.cpp"
				$File	"deferred\cdeferred_manager_client.h"
				$File	"deferred\clight_editor.cpp"
				$File	"deferred\clight_editor.h"
				$File	"deferred\clight_manager.cpp"
				$File	"deferred\clight_manager.h"
				$File	"deferred\def_light_t.cpp"
				$File	"deferred\def_light_t.h"
				$File	"deferred\deferred_client_common.cpp"
				$File	"deferred\deferred_client_common.h"
				$File	"deferred\deferred_rt.cpp"
				$File	"deferred\deferred_rt.h"
				$File	"deferred\flashlighteffect_deferred.cpp"
				$File	"deferred\flashlighteffect_deferred.h"
				$File	"deferred\viewrender_deferred.cpp"
				$File	"deferred\viewrender_deferred.h"
			}
		}

Firstly we are going to modify cdll_client_int.cpp. Now put the following code at the top of the file around lines 175 but it must be before #include "tier0/memdbgon.h".

 #ifdef DEFERRED_ENABLED // @Deferred - Biohazard
 #include "deferred/deferred_shared_common.h"
 #endif

Now aound lines 1816 in void CHLClient::ResetStringTablePointers() place the following code.

 #ifdef DEFERRED_ENABLED // @Deferred - Biohazard
 g_pStringTable_LightCookies = NULL;
 #endif

Now around lines 2058 put the following code inside void CHLClient::InstallStringTableCallback( const char *tableName ). And after that we should be done with cdll_client_int.cpp.

#ifdef DEFERRED_ENABLED // @Deferred - Biohazard
	else if ( !Q_strcasecmp( tableName, COOKIE_STRINGTBL_NAME ) )
	{
		g_pStringTable_LightCookies = networkstringtable->FindTable( tableName );

		g_pStringTable_LightCookies->SetStringChangedCallback( NULL, OnCookieTableChanged );
	}
#endif // DEFERRED_ENABLED

Now open viewrender.h and around lines 19 paste the following code.

#ifdef DEFERRED_ENABLED // @Deferred - Biohazard
#include "../../materialsystem/stdshaders/deferred_global_common.h"
#endif

And around lines 39 paste this too.

#ifdef DEFERRED_ENABLED // @Deferred - Biohazard
	struct def_light_t;
#endif

Now around lines 96, but the following code into enum view_id_t.

        // @Deferred - Biohazard
	VIEW_DEFERRED_GBUFFER = 8,
	VIEW_DEFERRED_SHADOW = 9,

And around lines 263, but the following code into class CRendering3dView : public CBase3dView.

#ifdef DEFERRED_ENABLED // @Deferred - Biohazard
	void			PushComposite();
	void			PopComposite();

	static void PushGBuffer( bool bInitial, float zScale = 1.0f, bool bClearDepth = true );
	static void PopGBuffer();
#endif

And around lines 505, paste the following code, and we should be done with viewrender.h.

#ifdef DEFERRED_ENABLED // @Deferred - Biohazard
	void			ProcessDeferredGlobals( const CViewSetup &view );

	void			ViewDrawGBuffer( const CViewSetup &view, bool &bDrew3dSkybox, SkyboxVisibility_t &nSkyboxVisible,
									 bool bDrawViewModel );

	void BeginRadiosity( const CViewSetup &view );
	void UpdateRadiosityPosition();
	void PerformRadiosityGlobal( const int iRadiosityCascade, const CViewSetup &view );
	void EndRadiosity( const CViewSetup &view );
	void DebugRadiosity( const CViewSetup &view );

	IMesh *GetRadiosityScreenGrid( const int iCascade );
	IMesh *CreateRadiosityScreenGrid( const Vector2D &vecViewportBase, const float flWorldStepSize );

	void			PerformLighting( const CViewSetup &view );

	void			ResetCascadeDelay();
	void			RenderCascadedShadows( const CViewSetup &view, const bool bEnableRadiosity );

public:
	virtual void	DrawLightShadowView( const CViewSetup &view, int iDesiredShadowmap, def_light_t *l );

protected:
	float m_flRenderDelay[SHADOW_NUM_CASCADES];

	Vector m_vecRadiosityOrigin[2];
	IMesh *m_pMesh_RadiosityScreenGrid[2];
	CUtlVector< IMesh* > m_hRadiosityDebugMeshList[2];
#endif

Now open viewrender.cpp and around lines 81 paste the following code.

#ifdef DEFERRED_ENABLED
#include "deferred/deferred_shared_common.h"
#include "tier1/callqueue.h"
#endif // DEFERRED_ENABLED

And now around lines 98 replace static convar with a regular convar like so.

ConVar r_visocclusion( "r_visocclusion", "0", FCVAR_CHEAT );

Now around lines 155 replace static convars with a regular convars like so.

ConVar r_ForceWaterLeaf( "r_ForceWaterLeaf", "1", 0, "Enable for optimization to water - considers view in leaf under water for purposes of culling" );
static ConVar mat_drawwater( "mat_drawwater", "1", FCVAR_CHEAT );
ConVar mat_clipz( "mat_clipz", "1" );

And again aorund lines 175 turn the static convar into a regular one.

ConVar r_eyewaterepsilon( "r_eyewaterepsilon", "7.0f", FCVAR_CHEAT );

And around lines 199 replace static int with regular int like so.

int g_CurrentViewID = VIEW_NONE;

And around lines 383 put the following code.

#ifdef DEFERRED_ENABLED // @Deferred - Biohazard
void FlushWorldLists()
{
	g_WorldListCache.Flush();
}
#endif

And around lines 397 replace Setup with the fallowing code.

bool			Setup( const CViewSetup &view, int *pClearFlags, SkyboxVisibility_t *pSkyboxVisible, bool bGBuffer = false );

And around lines 399 add the following code inside class CSkyboxView : public CRendering3dView.

#if DEFERRED_ENABLED // @Deferred - Biohazard
	bool		m_bGBufferPass;
#endif

And around lines 694 paste the following code.

// Deferred views
#ifdef DEFERRED_ENABLED // @Deferred - Biohazard
class CBaseWorldBlendViewDeferred : public CBaseWorldView
{
	DECLARE_CLASS( CBaseWorldBlendViewDeferred, CBaseWorldView );
public:
	CBaseWorldBlendViewDeferred(CViewRender *pMainView) : CBaseWorldView( pMainView )
	{
	}

	void			DrawSetup( float waterHeight, int flags, float waterZAdjust, int iForceViewLeaf = -1, bool bShadowDepth = false );
	void			DrawExecute( float waterHeight, view_id_t viewID, float waterZAdjust, bool bShadowDepth = false );

	// BUGBUG this causes all sorts of problems
	virtual bool	ShouldCacheLists(){ return false; };

protected:
	void			DrawOpaqueRenderablesDeferred( bool bNoDecals );
};

class CGBufferBlendView : public CBaseWorldBlendViewDeferred
{
	DECLARE_CLASS( CGBufferBlendView, CBaseWorldBlendViewDeferred );
public:
	CGBufferBlendView(CViewRender *pMainView) : CBaseWorldBlendViewDeferred( pMainView )
	{
	}

	void			Setup( const CViewSetup &view, bool bDrewSkybox );
	void			Draw();

	virtual void	PushView( float waterHeight );
	virtual void	PopView();

private: 
	VisibleFogVolumeInfo_t m_fogInfo;
	bool m_bDrewSkybox;
};

abstract_class CBaseShadowBlendView : public CBaseWorldBlendViewDeferred
{
	DECLARE_CLASS( CBaseShadowBlendView, CBaseWorldBlendViewDeferred );
public:
	CBaseShadowBlendView(CViewRender *pMainView) : CBaseWorldBlendViewDeferred( pMainView )
	{
		m_bOutputRadiosity = false;
	};

	void			Setup( const CViewSetup &view,
						ITexture *pDepthTexture,
						ITexture *pDummyTexture );
	void			SetupRadiosityTargets(
						ITexture *pAlbedoTexture,
						ITexture *pNormalTexture );

	void SetRadiosityOutputEnabled( bool bEnabled );

	void			Draw();
	virtual bool	AdjustView( float waterHeight );
	virtual void	PushView( float waterHeight );
	virtual void	PopView();

	virtual void	CalcShadowView() = 0;
	virtual void	CommitData(){};

	virtual int		GetShadowMode() = 0;

private:

	ITexture *m_pDepthTexture;
	ITexture *m_pDummyTexture;
	ITexture *m_pRadAlbedoTexture;
	ITexture *m_pRadNormalTexture;
	ViewCustomVisibility_t shadowVis;

	bool m_bOutputRadiosity;
};

class COrthoShadowBlendView : public CBaseShadowBlendView
{
	DECLARE_CLASS( COrthoShadowBlendView, CBaseShadowBlendView );
public:
	COrthoShadowBlendView(CViewRender *pMainView, const int &index)
		: CBaseShadowBlendView( pMainView )
	{
			iCascadeIndex = index;
	}

	virtual void	CalcShadowView();
	virtual void	CommitData();

	virtual int		GetShadowMode(){
		return DEFERRED_SHADOW_MODE_ORTHO;
	};

private:
	int iCascadeIndex;
};

class CDualParaboloidShadowBlendView : public CBaseShadowBlendView
{
	DECLARE_CLASS( CDualParaboloidShadowBlendView, CBaseShadowBlendView );
public:
	CDualParaboloidShadowBlendView(CViewRender *pMainView,
		def_light_t *pLight,
		const bool &bSecondary)
		: CBaseShadowBlendView( pMainView )
	{
			m_pLight = pLight;
			m_bSecondary = bSecondary;
	}
	virtual bool	AdjustView( float waterHeight );
	virtual void	PushView( float waterHeight );
	virtual void	PopView();

	virtual void	CalcShadowView();

	virtual int		GetShadowMode(){
		return DEFERRED_SHADOW_MODE_DPSM;
	};

private:
	bool m_bSecondary;
	def_light_t *m_pLight;
};

class CSpotLightShadowBlendView : public CBaseShadowBlendView
{
	DECLARE_CLASS( CSpotLightShadowBlendView, CBaseShadowBlendView );
public:
	CSpotLightShadowBlendView(CViewRender *pMainView,
		def_light_t *pLight, int index )
		: CBaseShadowBlendView( pMainView )
	{
			m_pLight = pLight;
			m_iIndex = index;
	}

	virtual void	CalcShadowView();
	virtual void	CommitData();

	virtual int		GetShadowMode(){
		return DEFERRED_SHADOW_MODE_PROJECTED;
	};

private:
	def_light_t *m_pLight;
	int m_iIndex;
};
#endif

And now around lines 963 paste the following code.

#ifdef DEFERRED_ENABLED // @Deferred - Biohazard
static CViewRender g_ViewRender;
IViewRender *GetViewRenderInstance()
{
	return &g_ViewRender;
}
#endif

And now around lines 973 put the fallowing code inside CViewRender::CViewRender().

#ifdef DEFERRED_ENABLED // @Deferred - Biohazard
	m_pMesh_RadiosityScreenGrid[0] = NULL;
	m_pMesh_RadiosityScreenGrid[1] = NULL;
#endif // DEFERRED_ENABLED

Now around lines 1465 paste the following code into void CViewRender::ViewDrawScene( bool bDrew3dSkybox, SkyboxVisibility_t nSkyboxVisible, const CViewSetup &view, int nClearFlags, view_id_t viewID, bool bDrawViewModel, int baseDrawFlags, ViewCustomVisibility_t *pCustomVisibility ).

#ifdef DEFERRED_ENABLED // @Deferred - Biohazard
	const bool bDeferredActive = GetDeferredManager()->IsDeferredRenderingEnabled();

	if( bDeferredActive )
	{
		ViewDrawGBuffer( view, bDrew3dSkybox, nSkyboxVisible, bDrawViewModel );

		PerformLighting( view );


	}
#endif

And around lines 1502 put the following code.

#ifdef DEFERRED_ENABLED // @Deferred - Biohazard
	if( bDeferredActive )
	{
		GetLightingManager()->RenderVolumetrics( view );
	}
#endif

And around lines 1950 add the following lines of code.

#ifdef DEFERRED_ENABLED // @Deferred - Biohazard
static lightData_Global_t GetActiveGlobalLightState()
{
	lightData_Global_t data;
	CLightingEditor *pEditor = GetLightingEditor();

	if ( pEditor->IsEditorLightingActive() && pEditor->GetKVGlobalLight() != NULL )
	{
		data = pEditor->GetGlobalState();
	}
	else if ( GetGlobalLight() != NULL )
	{
		data = GetGlobalLight()->GetState();
	}

	return data;
}

struct defData_setGlobals
{
public:
	Vector orig, fwd;
	float zDists[2];
	VMatrix frustumDeltas;
#if DEFCFG_BILATERAL_DEPTH_TEST
	VMatrix worldCameraDepthTex;
#endif

	static void Fire( defData_setGlobals d )
	{
		IDeferredExtension *pDef = GetDeferredExt();
		pDef->CommitOrigin( d.orig );
		pDef->CommitViewForward( d.fwd );
		pDef->CommitZDists( d.zDists[0], d.zDists[1] );
		pDef->CommitFrustumDeltas( d.frustumDeltas );
#if DEFCFG_BILATERAL_DEPTH_TEST
		pDef->CommitWorldToCameraDepthTex( d.worldCameraDepthTex );
#endif
	};
};


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CViewRender::ProcessDeferredGlobals( const CViewSetup &view )
{
	VMatrix matPerspective, matView, matViewProj, screen2world;
	matView.Identity();
	matView.SetupMatrixOrgAngles( vec3_origin, view.angles );

	MatrixSourceToDeviceSpace( matView );

	matView = matView.Transpose3x3();
	Vector viewPosition;

	Vector3DMultiply( matView, view.origin, viewPosition );
	matView.SetTranslation( -viewPosition );
	MatrixBuildPerspectiveX( matPerspective, view.fov, view.m_flAspectRatio,
		view.zNear, view.zFar );
	MatrixMultiply( matPerspective, matView, matViewProj );

	MatrixInverseGeneral( matViewProj, screen2world );

	GetLightingManager()->SetRenderConstants( screen2world, view );

	Vector frustum_c0, frustum_cc, frustum_1c;
	float projDistance = 1.0f;
	Vector3DMultiplyPositionProjective( screen2world, Vector(0,projDistance,projDistance), frustum_c0 );
	Vector3DMultiplyPositionProjective( screen2world, Vector(0,0,projDistance), frustum_cc );
	Vector3DMultiplyPositionProjective( screen2world, Vector(projDistance,0,projDistance), frustum_1c );

	frustum_c0 -= view.origin;
	frustum_cc -= view.origin;
	frustum_1c -= view.origin;

	Vector frustum_up = frustum_c0 - frustum_cc;
	Vector frustum_right = frustum_1c - frustum_cc;

	frustum_cc /= view.zFar;
	frustum_right /= view.zFar;
	frustum_up /= view.zFar;

	defData_setGlobals data;
	data.orig = view.origin;
	AngleVectors( view.angles, &data.fwd );
	data.zDists[0] = view.zNear;
	data.zDists[1] = view.zFar;

	data.frustumDeltas.Identity();
	data.frustumDeltas.SetBasisVectors( frustum_cc, frustum_right, frustum_up );
	data.frustumDeltas = data.frustumDeltas.Transpose3x3();

#if DEFCFG_BILATERAL_DEPTH_TEST
	VMatrix matWorldToCameraDepthTex;
	MatrixBuildScale( matWorldToCameraDepthTex, 0.5f, -0.5f, 1.0f );
	matWorldToCameraDepthTex[0][3] = matWorldToCameraDepthTex[1][3] = 0.5f;
	MatrixMultiply( matWorldToCameraDepthTex, matViewProj, matWorldToCameraDepthTex );

	data.worldCameraDepthTex = matWorldToCameraDepthTex.Transpose();
#endif

	QUEUE_FIRE( defData_setGlobals, Fire, data );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CViewRender::ViewDrawGBuffer( const CViewSetup &view, bool &bDrew3dSkybox, SkyboxVisibility_t &nSkyboxVisible,
	bool bDrawViewModel )
{
	MDLCACHE_CRITICAL_SECTION();

	int oldViewID = g_CurrentViewID;
	g_CurrentViewID = VIEW_DEFERRED_GBUFFER;

	int nClearFlags = VIEW_CLEAR_DEPTH;
	CSkyboxView *pSkyView = new CSkyboxView( this );
	if ( ( bDrew3dSkybox = pSkyView->Setup( view, &nClearFlags, &nSkyboxVisible, true ) ) != false )
		AddViewToScene( pSkyView );

	SafeRelease( pSkyView );

	// Start view
	unsigned int visFlags;
	SetupVis( view, visFlags, NULL );

	CRefPtr<CGBufferBlendView> pGBufferView = new CGBufferBlendView( this );
	pGBufferView->Setup( view, bDrew3dSkybox );
	AddViewToScene( pGBufferView );

	DrawViewModels( view, bDrawViewModel/*, true*/ );
	 
	g_CurrentViewID = oldViewID;
}

static int GetSourceRadBufferIndex( const int index )
{
	Assert( index == 0 || index == 1 );

	const bool bFar = index == 1;
	const int iNumSteps = bFar ? deferred_radiosity_propagate_count_far.GetInt() : deferred_radiosity_propagate_count.GetInt()
		+ bFar ? deferred_radiosity_blur_count_far.GetInt() : deferred_radiosity_blur_count.GetInt();
	return ( iNumSteps % 2 == 0 ) ? 0 : 1;
}

void CViewRender::BeginRadiosity( const CViewSetup &view )
{
	Vector fwd;
	AngleVectors( view.angles, &fwd );

	float flAmtVertical = abs( DotProduct( fwd, Vector( 0, 0, 1 ) ) );
	flAmtVertical = RemapValClamped( flAmtVertical, 0, 1, 1, 0.5f );

	for ( int iCascade = 0; iCascade < 2; iCascade++ )
	{
		const bool bFar = iCascade == 1;
		const Vector gridSize( RADIOSITY_BUFFER_SAMPLES_XY, RADIOSITY_BUFFER_SAMPLES_XY,
								RADIOSITY_BUFFER_SAMPLES_Z );
		const Vector gridSizeHalf = gridSize / 2;
		const float gridStepSize = bFar ? RADIOSITY_BUFFER_GRID_STEP_SIZE_FAR
			: RADIOSITY_BUFFER_GRID_STEP_SIZE_CLOSE;
		const float flGridDistance = bFar ? RADIOSITY_BUFFER_GRID_STEP_DISTANCEMULT_FAR
			: RADIOSITY_BUFFER_GRID_STEP_DISTANCEMULT_CLOSE;

		Vector vecFwd;
		AngleVectors( view.angles, &vecFwd );

		m_vecRadiosityOrigin[iCascade] = view.origin
			+ vecFwd * gridStepSize * RADIOSITY_BUFFER_SAMPLES_XY * flGridDistance * flAmtVertical;

		for ( int i = 0; i < 3; i++ )
			m_vecRadiosityOrigin[iCascade][i] -= fmod( m_vecRadiosityOrigin[iCascade][i], gridStepSize );

		m_vecRadiosityOrigin[iCascade] -= gridSizeHalf * gridStepSize;

		const int iSourceBuffer = GetSourceRadBufferIndex( iCascade );
		static int iLastSourceBuffer[2] = { iSourceBuffer, GetSourceRadBufferIndex( 1 ) };

		const int clearSizeY = RADIOSITY_BUFFER_RES_Y / 2;
		const int clearOffset = (iCascade == 1) ? clearSizeY : 0;

		CMatRenderContextPtr pRenderContext( materials );

		pRenderContext->PushRenderTargetAndViewport( GetDefRT_RadiosityBuffer( iSourceBuffer ), NULL,
			0, clearOffset, RADIOSITY_BUFFER_RES_X, clearSizeY );
		pRenderContext->ClearColor3ub( 0, 0, 0 );
		pRenderContext->ClearBuffers( true, false );
		pRenderContext->PopRenderTargetAndViewport();

		if ( iLastSourceBuffer[iCascade] != iSourceBuffer )
		{
			iLastSourceBuffer[iCascade] = iSourceBuffer;

			pRenderContext->PushRenderTargetAndViewport( GetDefRT_RadiosityBuffer( 1 - iSourceBuffer ), NULL,
				0, clearOffset, RADIOSITY_BUFFER_RES_X, clearSizeY );
			pRenderContext->ClearColor3ub( 0, 0, 0 );
			pRenderContext->ClearBuffers( true, false );
			pRenderContext->PopRenderTargetAndViewport();

			pRenderContext->PushRenderTargetAndViewport( GetDefRT_RadiosityNormal( 1 - iSourceBuffer ), NULL,
				0, clearOffset, RADIOSITY_BUFFER_RES_X, clearSizeY );
			pRenderContext->ClearColor3ub( 127, 127, 127 );
			pRenderContext->ClearBuffers( true, false );
			pRenderContext->PopRenderTargetAndViewport();
		}

		pRenderContext->PushRenderTargetAndViewport( GetDefRT_RadiosityNormal( iSourceBuffer ), NULL,
			0, clearOffset, RADIOSITY_BUFFER_RES_X, clearSizeY );
		pRenderContext->ClearColor3ub( 127, 127, 127 );
		pRenderContext->ClearBuffers( true, false );
		pRenderContext->PopRenderTargetAndViewport();
	}

	UpdateRadiosityPosition();
}

void CViewRender::UpdateRadiosityPosition()
{
	struct defData_setupRadiosity
	{
	public:
		radiosityData_t data;

		static void Fire( defData_setupRadiosity d )
		{
			GetDeferredExt()->CommitRadiosityData( d.data );
		};
	};

	defData_setupRadiosity radSetup;
	radSetup.data.vecOrigin[0] = m_vecRadiosityOrigin[0];
	radSetup.data.vecOrigin[1] = m_vecRadiosityOrigin[1];

	QUEUE_FIRE( defData_setupRadiosity, Fire, radSetup );
}

void CViewRender::PerformRadiosityGlobal( const int iRadiosityCascade, const CViewSetup &view )
{
	const int iSourceBuffer = GetSourceRadBufferIndex( iRadiosityCascade );
	const int iOffsetY = (iRadiosityCascade == 1) ? RADIOSITY_BUFFER_RES_Y/2 : 0;

	CMatRenderContextPtr pRenderContext( materials );
	pRenderContext->SetIntRenderingParameter( INT_RENDERPARM_DEFERRED_RADIOSITY_CASCADE, iRadiosityCascade );

	pRenderContext->PushRenderTargetAndViewport( GetDefRT_RadiosityBuffer( iSourceBuffer ), NULL,
		0, iOffsetY, RADIOSITY_BUFFER_VIEWPORT_SX, RADIOSITY_BUFFER_VIEWPORT_SY );
	pRenderContext->SetRenderTargetEx( 1, GetDefRT_RadiosityNormal( iSourceBuffer ) );

	pRenderContext->Bind( GetDeferredManager()->GetDeferredMaterial( DEF_MAT_LIGHT_RADIOSITY_GLOBAL ) );
	GetRadiosityScreenGrid( iRadiosityCascade )->Draw();

	pRenderContext->PopRenderTargetAndViewport();
}

void CViewRender::EndRadiosity( const CViewSetup &view )
{
	const int iNumPropagateSteps[2] = { deferred_radiosity_propagate_count.GetInt(),
		deferred_radiosity_propagate_count_far.GetInt() };
	const int iNumBlurSteps[2] = { deferred_radiosity_blur_count.GetInt(),
		deferred_radiosity_blur_count_far.GetInt() };

	IMaterial *pPropagateMat[2] = {
		GetDeferredManager()->GetDeferredMaterial( DEF_MAT_LIGHT_RADIOSITY_PROPAGATE_0 ),
		GetDeferredManager()->GetDeferredMaterial( DEF_MAT_LIGHT_RADIOSITY_PROPAGATE_1 ),
	};

	IMaterial *pBlurMat[2] = {
		GetDeferredManager()->GetDeferredMaterial( DEF_MAT_LIGHT_RADIOSITY_BLUR_0 ),
		GetDeferredManager()->GetDeferredMaterial( DEF_MAT_LIGHT_RADIOSITY_BLUR_1 ),
	};

	for ( int iCascade = 0; iCascade < 2; iCascade++ )
	{
		bool bSecondDestBuffer = GetSourceRadBufferIndex( iCascade ) == 0;
		const int iOffsetY = (iCascade==1) ? RADIOSITY_BUFFER_RES_Y / 2 : 0;

		for ( int i = 0; i < iNumPropagateSteps[iCascade]; i++ )
		{
			const int index = bSecondDestBuffer ? 1 : 0;
			CMatRenderContextPtr pRenderContext( materials );
			pRenderContext->PushRenderTargetAndViewport( GetDefRT_RadiosityBuffer( index ), NULL,
				0, iOffsetY, RADIOSITY_BUFFER_VIEWPORT_SX, RADIOSITY_BUFFER_VIEWPORT_SY );
			pRenderContext->SetRenderTargetEx( 1, GetDefRT_RadiosityNormal( index ) );

			pRenderContext->Bind( pPropagateMat[ 1 - index ] );

			GetRadiosityScreenGrid( iCascade )->Draw();

			pRenderContext->PopRenderTargetAndViewport();
			bSecondDestBuffer = !bSecondDestBuffer;
		}

		for ( int i = 0; i < iNumBlurSteps[iCascade]; i++ )
		{
			const int index = bSecondDestBuffer ? 1 : 0;
			CMatRenderContextPtr pRenderContext( materials );
			pRenderContext->PushRenderTargetAndViewport( GetDefRT_RadiosityBuffer( index ), NULL,
				0, iOffsetY, RADIOSITY_BUFFER_VIEWPORT_SX, RADIOSITY_BUFFER_VIEWPORT_SY );
			pRenderContext->SetRenderTargetEx( 1, GetDefRT_RadiosityNormal( index ) );

			pRenderContext->Bind( pBlurMat[ 1 - index ] );

			GetRadiosityScreenGrid( iCascade )->Draw();

			pRenderContext->PopRenderTargetAndViewport();
			bSecondDestBuffer = !bSecondDestBuffer;
		}
	}

#if ( DEFCFG_DEFERRED_SHADING == 0 )
	DrawLightPassFullscreen( GetDeferredManager()->GetDeferredMaterial( DEF_MAT_LIGHT_RADIOSITY_BLEND ),
		view.width, view.height );
#endif
}


IMesh *CViewRender::GetRadiosityScreenGrid( const int iCascade )
{
	if ( m_pMesh_RadiosityScreenGrid[iCascade] == NULL )
	{
		Assert( m_pMesh_RadiosityScreenGrid[iCascade] == NULL );

		const bool bFar = iCascade == 1;

		m_pMesh_RadiosityScreenGrid[iCascade] = CreateRadiosityScreenGrid(
			Vector2D( 0, (bFar?0.5f:0) ),
			bFar ? RADIOSITY_BUFFER_GRID_STEP_SIZE_FAR : RADIOSITY_BUFFER_GRID_STEP_SIZE_CLOSE );
	}

	Assert( m_pMesh_RadiosityScreenGrid[iCascade] != NULL );

	return m_pMesh_RadiosityScreenGrid[iCascade];
}

IMesh *CViewRender::CreateRadiosityScreenGrid( const Vector2D &vecViewportBase,
	const float flWorldStepSize )
{
	VertexFormat_t format = VERTEX_POSITION
		| VERTEX_TEXCOORD_SIZE( 0, 4 )
		| VERTEX_TEXCOORD_SIZE( 1, 4 )
		| VERTEX_TANGENT_S;

	const float flTexelGridMargin = 1.5f / RADIOSITY_BUFFER_SAMPLES_XY;
	const float flTexelHalf[2] = { 0.5f / RADIOSITY_BUFFER_VIEWPORT_SX,
		0.5f / RADIOSITY_BUFFER_VIEWPORT_SY };

	const float flLocalCoordSingle = 1.0f / RADIOSITY_BUFFER_GRIDS_PER_AXIS;
	const float flLocalCoords[4][2] = {
		0, 0,
		flLocalCoordSingle, 0,
		flLocalCoordSingle, flLocalCoordSingle,
		0, flLocalCoordSingle,
	};

	CMatRenderContextPtr pRenderContext( materials );
	IMesh *pRet = pRenderContext->CreateStaticMesh(
		format, TEXTURE_GROUP_OTHER );
	
	CMeshBuilder meshBuilder;
	meshBuilder.Begin( pRet, MATERIAL_QUADS,
		RADIOSITY_BUFFER_GRIDS_PER_AXIS * RADIOSITY_BUFFER_GRIDS_PER_AXIS );

	float flGridOrigins[RADIOSITY_BUFFER_SAMPLES_Z][2];
	for ( int i = 0; i < RADIOSITY_BUFFER_SAMPLES_Z; i++ )
	{
		int x = i % RADIOSITY_BUFFER_GRIDS_PER_AXIS;
		int y = i / RADIOSITY_BUFFER_GRIDS_PER_AXIS;

		flGridOrigins[i][0] = x * flLocalCoordSingle + flTexelHalf[0];
		flGridOrigins[i][1] = y * flLocalCoordSingle + flTexelHalf[1];
	}

	const float flGridSize = flWorldStepSize * RADIOSITY_BUFFER_SAMPLES_XY;
	const float flLocalGridSize[4][2] = {
		0, 0,
		flGridSize, 0,
		flGridSize, flGridSize,
		0, flGridSize,
	};
	const float flLocalGridLimits[4][2] = {
		-flTexelGridMargin, -flTexelGridMargin,
		1 + flTexelGridMargin, -flTexelGridMargin,
		1 + flTexelGridMargin, 1 + flTexelGridMargin,
		-flTexelGridMargin, 1 + flTexelGridMargin,
	};

	for ( int x = 0; x < RADIOSITY_BUFFER_GRIDS_PER_AXIS; x++ )
	{
		for ( int y = 0; y < RADIOSITY_BUFFER_GRIDS_PER_AXIS; y++ )
		{
			const int iIndexLocal = x + y * RADIOSITY_BUFFER_GRIDS_PER_AXIS;
			const int iIndicesOne[2] = { MIN( RADIOSITY_BUFFER_SAMPLES_Z - 1, iIndexLocal + 1 ), MAX( 0, iIndexLocal - 1 ) };

			for ( int q = 0; q < 4; q++ )
			{
				meshBuilder.Position3f(
					(x * flLocalCoordSingle + flLocalCoords[q][0]) * 2 - flLocalCoordSingle * RADIOSITY_BUFFER_GRIDS_PER_AXIS,
					flLocalCoordSingle * RADIOSITY_BUFFER_GRIDS_PER_AXIS - (y * flLocalCoordSingle + flLocalCoords[q][1]) * 2,
					0 );

				meshBuilder.TexCoord4f( 0,
					(flGridOrigins[iIndexLocal][0] + flLocalCoords[q][0]) * RADIOSITY_UVRATIO_X + vecViewportBase.x,
					(flGridOrigins[iIndexLocal][1] + flLocalCoords[q][1]) * RADIOSITY_UVRATIO_Y + vecViewportBase.y,
					flLocalGridLimits[q][0],
					flLocalGridLimits[q][1] );

				meshBuilder.TexCoord4f( 1,
					(flGridOrigins[iIndicesOne[0]][0] + flLocalCoords[q][0]) * RADIOSITY_UVRATIO_X + vecViewportBase.x,
					(flGridOrigins[iIndicesOne[0]][1] + flLocalCoords[q][1]) * RADIOSITY_UVRATIO_Y + vecViewportBase.y,
					(flGridOrigins[iIndicesOne[1]][0] + flLocalCoords[q][0]) * RADIOSITY_UVRATIO_X + vecViewportBase.x,
					(flGridOrigins[iIndicesOne[1]][1] + flLocalCoords[q][1]) * RADIOSITY_UVRATIO_Y + vecViewportBase.y );

				meshBuilder.TangentS3f( flLocalGridSize[q][0],
					flLocalGridSize[q][1],
					iIndexLocal * flWorldStepSize );

				meshBuilder.AdvanceVertex();
			}
		}
	}

	meshBuilder.End();

	return pRet;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CViewRender::PerformLighting( const CViewSetup &view )
{
	bool bResetLightAccum = false;
	const bool bRadiosityEnabled = DEFCFG_ENABLE_RADIOSITY != 0 && deferred_radiosity_enable.GetBool();

	if ( bRadiosityEnabled )
		BeginRadiosity( view );

	if ( GetGlobalLight() != NULL )
	{
		struct defData_setGlobalLightState
		{
		public:
			lightData_Global_t state;

			static void Fire( defData_setGlobalLightState d )
			{
				GetDeferredExt()->CommitLightData_Global( d.state );
			};
		};

		defData_setGlobalLightState lightDataState;
		lightDataState.state = GetActiveGlobalLightState();

		if ( !GetLightingEditor()->IsEditorLightingActive() &&
			deferred_override_globalLight_enable.GetBool() )
		{
			lightDataState.state.bShadow = deferred_override_globalLight_shadow_enable.GetBool();
			UTIL_StringToVector( lightDataState.state.diff.AsVector3D().Base(), deferred_override_globalLight_diffuse.GetString() );
			UTIL_StringToVector( lightDataState.state.ambh.AsVector3D().Base(), deferred_override_globalLight_ambient_high.GetString() );
			UTIL_StringToVector( lightDataState.state.ambl.AsVector3D().Base(), deferred_override_globalLight_ambient_low.GetString() );

			lightDataState.state.bEnabled = ( lightDataState.state.diff.LengthSqr() > 0.01f ||
				lightDataState.state.ambh.LengthSqr() > 0.01f ||
				lightDataState.state.ambl.LengthSqr() > 0.01f );
		}

		QUEUE_FIRE( defData_setGlobalLightState, Fire, lightDataState );

		if ( lightDataState.state.bEnabled )
		{
			bool bShadowedGlobal = lightDataState.state.bShadow;

			if ( bShadowedGlobal )
			{
				Vector origins[2] = { view.origin, view.origin + lightDataState.state.vecLight.AsVector3D() * 1024 };
				render->ViewSetupVis( false, 2, origins );

				RenderCascadedShadows( view, bRadiosityEnabled );
			}
		}
		else
			bResetLightAccum = true;
	}
	else
		bResetLightAccum = true;

	CViewSetup lightingView = view;

	if ( building_cubemaps.GetBool() )
		engine->GetScreenSize( lightingView.width, lightingView.height );

	CMatRenderContextPtr pRenderContext( materials );
	pRenderContext->PushRenderTargetAndViewport( GetDefRT_Lightaccum() );

	if ( bResetLightAccum )
	{
		pRenderContext->ClearColor4ub( 0, 0, 0, 0 );
		pRenderContext->ClearBuffers( true, false );
	}
	else
		DrawLightPassFullscreen( GetDeferredManager()->GetDeferredMaterial( DEF_MAT_LIGHT_GLOBAL ), lightingView.width, lightingView.height );

	pRenderContext->PopRenderTargetAndViewport();
	pRenderContext->PushRenderTargetAndViewport( GetDefRT_Lightaccum2() );

	pRenderContext->ClearColor4ub( 0, 0, 0, 0 );
	pRenderContext->ClearBuffers( true, false );

	pRenderContext.SafeRelease();

	GetLightingManager()->RenderLights( lightingView, this );

	if ( bRadiosityEnabled )
		EndRadiosity( view );

	pRenderContext.GetFrom( materials );
	pRenderContext->PopRenderTargetAndViewport();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CViewRender::ResetCascadeDelay()
{
	for ( int i = 0; i < SHADOW_NUM_CASCADES; i++ )
		m_flRenderDelay[i] = 0;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CViewRender::RenderCascadedShadows( const CViewSetup &view, const bool bEnableRadiosity )
{
	for ( int i = 0; i < SHADOW_NUM_CASCADES; i++ )
	{
		const cascade_t &cascade = GetCascadeInfo(i);
		const bool bDoRadiosity = bEnableRadiosity && cascade.bOutputRadiosityData;
		const int iRadTarget = cascade.iRadiosityCascadeTarget;

		float delta = m_flRenderDelay[i] - gpGlobals->curtime;
		if ( delta > 0.0f && delta < 1.0f )
		{
			if ( bDoRadiosity )
				PerformRadiosityGlobal( iRadTarget, view );
			continue;
		}

		m_flRenderDelay[i] = gpGlobals->curtime + cascade.flUpdateDelay;

#if CSM_USE_COMPOSITED_TARGET == 0
		int textureIndex = i;
#else
		int textureIndex = 0;
#endif

		CRefPtr<COrthoShadowBlendView> pOrthoDepth = new COrthoShadowBlendView( this, i );
		pOrthoDepth->Setup( view, GetShadowDepthRT_Ortho( textureIndex ), GetShadowColorRT_Ortho( textureIndex ) );
		if ( bDoRadiosity )
		{
			pOrthoDepth->SetRadiosityOutputEnabled( true );
			pOrthoDepth->SetupRadiosityTargets( GetRadiosityAlbedoRT_Ortho( textureIndex ),
				GetRadiosityNormalRT_Ortho( textureIndex ) );
		}
		AddViewToScene( pOrthoDepth );

		if ( bDoRadiosity )
			PerformRadiosityGlobal( iRadTarget, view );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CViewRender::DrawLightShadowView( const CViewSetup &view, int iDesiredShadowmap, def_light_t *l )
{
	CViewSetup setup;
	setup.origin = l->pos;
	setup.angles = l->ang;
	setup.m_bOrtho = false;
	setup.m_flAspectRatio = 1;
	setup.x = setup.y = 0;

	Vector origins[2] = { view.origin, l->pos };
	render->ViewSetupVis( false, 2, origins );

	switch ( l->iLighttype )
	{
	default:
		Assert( 0 );
		break;
	case DEFLIGHTTYPE_POINT:
		{
			CRefPtr<CDualParaboloidShadowBlendView> pDPView0 = new CDualParaboloidShadowBlendView( this, l, false );
			pDPView0->Setup( setup, GetShadowDepthRT_DP( iDesiredShadowmap ), GetShadowColorRT_DP( iDesiredShadowmap ) );
			AddViewToScene( pDPView0 );

			CRefPtr<CDualParaboloidShadowBlendView> pDPView1 = new CDualParaboloidShadowBlendView( this, l, true );
			pDPView1->Setup( setup, GetShadowDepthRT_DP( iDesiredShadowmap ), GetShadowColorRT_DP( iDesiredShadowmap ) );
			AddViewToScene( pDPView1 );
		}
		break;
	case DEFLIGHTTYPE_SPOT:
		{
			CRefPtr<CSpotLightShadowBlendView> pProjView = new CSpotLightShadowBlendView( this, l, iDesiredShadowmap );
			
			pProjView->Setup( setup, GetShadowDepthRT_Proj( iDesiredShadowmap ), GetShadowColorRT_Proj( iDesiredShadowmap ) );
			AddViewToScene( pProjView );
		}
		break;
	}
}
#endif

And around lines 2056 inside void CViewRender::RenderView( const CViewSetup &view, int nClearFlags, int whatToDraw ) put the following code.

#ifdef DEFERRED_ENABLED // @Deferred - Biohazard
	const bool bDeferredActive = GetDeferredManager()->IsDeferredRenderingEnabled();
#endif

Now around lines 2060 replace m_CurrentView = view; with the following code.

#ifdef DEFERRED_ENABLED // @Deferred - Biohazard
	CViewSetup worldView = view;

	if( bDeferredActive )
	{
		CLightingEditor *pLightEditor = GetLightingEditor();

		if ( pLightEditor->IsEditorActive() && !building_cubemaps.GetBool() )
			pLightEditor->GetEditorView( &worldView.origin, &worldView.angles );
		else
			pLightEditor->SetEditorView( &worldView.origin, &worldView.angles );

		
	}

	m_CurrentView = worldView;
#else
	const CViewSetup &worldView = view;
	m_CurrentView = view;
#endif

And around lines 2147 paste the following code.

#ifdef DEFERRED_ENABLED // @Deferred - Biohazard
		if( bDeferredActive )
		{
			ProcessDeferredGlobals( worldView );
			GetLightingManager()->LightSetup( worldView );
		}
#endif

And around lines 2208 paste this code as well. Inside void CViewRender::RenderView( const CViewSetup &view, int nClearFlags, int whatToDraw ).

#ifdef DEFERRED_ENABLED // @Deferred - Biohazard
		if( bDeferredActive )
		{
			// must happen before teardown
			CLightingEditor *pLightEditor = GetLightingEditor();
			pLightEditor->OnRender();

			GetLightingManager()->LightTearDown();
		}
#endif

Around line 4119 paste the following code.

#ifdef DEFERRED_ENABLED // @Deferred - Biohazard
void CRendering3dView::PushComposite()// @Deferred - Biohazard
{
	CMatRenderContextPtr pRenderContext( materials );
	pRenderContext->SetIntRenderingParameter( INT_RENDERPARM_DEFERRED_RENDER_STAGE,
		DEFERRED_RENDER_STAGE_COMPOSITION );
}

void CRendering3dView::PopComposite()// @Deferred - Biohazard
{
	CMatRenderContextPtr pRenderContext( materials );
	pRenderContext->SetIntRenderingParameter( INT_RENDERPARM_DEFERRED_RENDER_STAGE,
		DEFERRED_RENDER_STAGE_INVALID );
}

void CRendering3dView::PushGBuffer( bool bInitial, float zScale, bool bClearDepth ) // @Deferred - Biohazard
{
	ITexture *pNormals = GetDefRT_Normals();
	ITexture *pDepth = GetDefRT_Depth();

	CMatRenderContextPtr pRenderContext( materials );

	pRenderContext->ClearColor4ub( 0, 0, 0, 0 );

	if ( bInitial )
	{
		pRenderContext->PushRenderTargetAndViewport( pDepth );
		pRenderContext->ClearBuffers( true, false );
		pRenderContext->PopRenderTargetAndViewport();
	}

#if DEFCFG_DEFERRED_SHADING == 1 // @Deferred - Biohazard
	pRenderContext->PushRenderTargetAndViewport( GetDefRT_Albedo() );
#else
	pRenderContext->PushRenderTargetAndViewport( pNormals );
#endif

	if ( bClearDepth )
		pRenderContext->ClearBuffers( false, true );

	pRenderContext->SetRenderTargetEx( 1, pDepth );

#if DEFCFG_DEFERRED_SHADING == 1/ / @Deferred - Biohazard
	pRenderContext->SetRenderTargetEx( 2, pNormals );
	pRenderContext->SetRenderTargetEx( 3, GetDefRT_Specular() );
#endif

	pRenderContext->SetIntRenderingParameter( INT_RENDERPARM_DEFERRED_RENDER_STAGE,
		DEFERRED_RENDER_STAGE_GBUFFER );

	struct defData_setZScale
	{
	public:
		float zScale;

		static void Fire( defData_setZScale d )
		{
			GetDeferredExt()->CommitZScale( d.zScale );
		};
	};

	defData_setZScale data;
	data.zScale = zScale;
	QUEUE_FIRE( defData_setZScale, Fire, data );
}

void CRendering3dView::PopGBuffer() // @Deferred - Biohazard
{
	CMatRenderContextPtr pRenderContext( materials );
	pRenderContext->SetIntRenderingParameter( INT_RENDERPARM_DEFERRED_RENDER_STAGE,
		DEFERRED_RENDER_STAGE_INVALID );

	pRenderContext->PopRenderTargetAndViewport();
}
#endif

Around lines 5320 paste the following code at the top of void CSkyboxView::DrawInternal( view_id_t iSkyBoxViewID, bool bInvokePreAndPostRender, ITexture *pRenderTarget, ITexture *pDepthTarget ).

#ifdef DEFERRED_ENABLED // @Deferred - Biohazard
	if ( m_bGBufferPass )
	{
		m_DrawFlags |= DF_SKIP_WORLD_DECALS_AND_OVERLAYS;

#if DEFCFG_DEFERRED_SHADING
		m_DrawFlags |= DF_DRAWSKYBOX;
#endif
	}
#endif

Around lines 5357 paste if ( !m_bGBufferPass ) before Enable3dSkyboxFog(); like this.

	if ( !m_bGBufferPass )
		Enable3dSkyboxFog();

At around line 5409 paste the following code.

#ifdef DEFERRED_ENABLED // @Deferred - Biohazard
	if ( m_bGBufferPass )
		PushGBuffer( true, skyScale );
	else
		PushComposite();
#endif

Now around 5427 replace BuildRenderableRenderLists with the following.

BuildRenderableRenderLists( m_bGBufferPass ? VIEW_SHADOW_DEPTH_TEXTURE : iSkyBoxViewID );

And around lines 5438 replace DrawTranslucentRenderables and DrawNoZBufferTranslucentRenderables with the following code.

	if ( !m_bGBufferPass )
	{
		// Iterate over all leaves and render objects in those leaves
		DrawTranslucentRenderables( true, false );
		DrawNoZBufferTranslucentRenderables();
	}

Around 5486 replace m_pMainView,CGlowOverlay::UpdateSkyOverlays,PixelVisibility_EndCurrentView() with the following.

	if ( !m_bGBufferPass )
	{
		m_pMainView->DisableFog();

		CGlowOverlay::UpdateSkyOverlays( zFar, m_bCacheFullSceneState );

		PixelVisibility_EndCurrentView();
	}

And around lines 5501 paste the following code.

#ifdef DEFERRED_ENABLED // @Deferred - Biohazard
	if ( m_bGBufferPass )
		PopGBuffer();
	else
		PopComposite();
#endif

Now around lines 5513 replace bool CSkyboxView::Setup with the following code.

bool CSkyboxView::Setup( const CViewSetup &view, int *pClearFlags, SkyboxVisibility_t *pSkyboxVisible, bool bGBuffer )

Around lines 5515 put the following at the top of the bool CSkyboxView::Setup function.

m_bGBufferPass = bGBuffer;

Around lines 5547 replace if( r_skybox.GetBool() ) with the following code.

if( !m_bGBufferPass && r_skybox.GetBool() )

Around lines 6328 paste the following code inside the void CSimpleWorldView::Draw() function.

PushComposite();

NOw around lines 6351 paste the following code inside the void CSimpleWorldView::Draw() function.

PopComposite();

Around lines 6411 replace void CBaseWaterView::CSoftwareIntersectionView::Draw() function with the following code.

void CBaseWaterView::CSoftwareIntersectionView::Draw()
{
	PushComposite();
	DrawSetup( GetOuter()->m_waterHeight, m_DrawFlags, GetOuter()->m_waterZAdjust );
	DrawExecute( GetOuter()->m_waterHeight, CurrentViewID(), GetOuter()->m_waterZAdjust );
	PopComposite();
}

Now around lines 6511 replace DrawSetup,EnableWorldFog(); and DrawExecute with the following code.

	PushComposite();

	DrawSetup( m_waterHeight, m_DrawFlags, m_waterZAdjust );
	EnableWorldFog();
	DrawExecute( m_waterHeight, CurrentViewID(), m_waterZAdjust );

	PopComposite();

Around lines 6502 replace DrawSetup , EnableWorldFog(); and DrawExecute with the following.

	PushComposite();

	DrawSetup( m_waterHeight, m_DrawFlags, m_waterZAdjust );
	EnableWorldFog();
	DrawExecute( m_waterHeight, CurrentViewID(), m_waterZAdjust );

	PopComposite();

Now around lines 6562 put the following code at the top of the void CAboveWaterView::CReflectionView::Draw() function.

	PushComposite();

And again at lines 6585 put the following code before SetupCurrentView( origin, angles, ( view_id_t )nSaveViewID );.

	PopComposite();

Now around lines 6613 inside the void CAboveWaterView::CRefractionView::Draw() function at the top place the following code.

	PushComposite();

And again inside the same function place the following code before SetupCurrentView( origin, angles, ( view_id_t )nSaveViewID );.

	PopComposite();

Around lines 6614 put the following code at the top of the void CAboveWaterView::CIntersectionView::Draw() function.

	PushComposite();

Now put this code at the end of that same function.

	PopComposite();

Now around lines 6745 inside the void CUnderWaterView::Draw() function put the following code before DrawSetup( m_waterHeight, m_DrawFlags, m_waterZAdjust );.

	PushComposite();

And inside the same function put this code after m_ClearFlags = 0;.

	PopComposite();

Now around lines 6788 inside void CUnderWaterView::CRefractionView::Draw() function place the following code just before DrawSetup.

	PushComposite();

And inside the same function place the following code after DrawExecute.

	PopComposite();

And lastly put this at the end of the file. After this we should be done with viewrender.cpp.

// Deferred views implementations
#ifdef DEFERRED_ENABLED  // @Deferred - Biohazard

//-----------------------------------------------------------------------------
// Draws the world + entities
//-----------------------------------------------------------------------------
void CBaseWorldBlendViewDeferred::DrawSetup( float waterHeight, int nSetupFlags, float waterZAdjust, int iForceViewLeaf, bool bShadowDepth )
{
	int savedViewID = g_CurrentViewID;
	g_CurrentViewID = bShadowDepth ? VIEW_DEFERRED_SHADOW : VIEW_MAIN;

	bool bViewChanged = AdjustView( waterHeight );

	if ( bViewChanged )
	{
		render->Push3DView( *this, 0, NULL, GetFrustum() );
	}

	render->BeginUpdateLightmaps();

	bool bDrawEntities = ( nSetupFlags & DF_DRAW_ENTITITES ) != 0;
	bool bDrawReflection = ( nSetupFlags & DF_RENDER_REFLECTION ) != 0;
	BuildWorldRenderLists( bDrawEntities, iForceViewLeaf, ShouldCacheLists(), false, bDrawReflection ? &waterHeight : NULL );

	PruneWorldListInfo();

	if ( bDrawEntities )
	{
		bool bOptimized = bShadowDepth || savedViewID == VIEW_DEFERRED_GBUFFER;
		BuildRenderableRenderLists( bOptimized ? VIEW_SHADOW_DEPTH_TEXTURE : savedViewID );
	}

	render->EndUpdateLightmaps();

	if ( bViewChanged )
	{
		render->PopView( GetFrustum() );
	}

	g_CurrentViewID = savedViewID;
}


void CBaseWorldBlendViewDeferred::DrawExecute( float waterHeight, view_id_t viewID, float waterZAdjust, bool bShadowDepth )
{
	// @MULTICORE (toml 8/16/2006): rethink how, where, and when this is done...
	//g_pClientShadowMgr->ComputeShadowTextures( *this, m_pWorldListInfo->m_LeafCount, m_pWorldListInfo->m_pLeafDataList );

	// Make sure sound doesn't stutter
	engine->Sound_ExtraUpdate();

	int savedViewID = g_CurrentViewID;
	g_CurrentViewID = viewID;

	// Update our render view flags.
	int iDrawFlagsBackup = m_DrawFlags;
	m_DrawFlags |= m_pMainView->GetBaseDrawFlags();

	PushView( waterHeight );

	CMatRenderContextPtr pRenderContext( materials );

#if defined( _X360 )
	pRenderContext->PushVertexShaderGPRAllocation( 32 );
#endif

	ITexture *pSaveFrameBufferCopyTexture = pRenderContext->GetFrameBufferCopyTexture( 0 );
	pRenderContext->SetFrameBufferCopyTexture( GetPowerOfTwoFrameBufferTexture() );
	pRenderContext.SafeRelease();


	Begin360ZPass();
	m_DrawFlags |= DF_SKIP_WORLD_DECALS_AND_OVERLAYS;
	DrawWorld( waterZAdjust );
	m_DrawFlags &= ~DF_SKIP_WORLD_DECALS_AND_OVERLAYS;
	if ( m_DrawFlags & DF_DRAW_ENTITITES )
	{
		DrawOpaqueRenderablesDeferred( m_bDrawWorldNormal );
	}
	End360ZPass();		// DrawOpaqueRenderables currently already calls End360ZPass. No harm in calling it again to make sure we're always ending it

	// Only draw decals on opaque surfaces after now. Benefit is two-fold: Early Z benefits on PC, and
	// we're pulling out stuff that uses the dynamic VB from the 360 Z pass
	// (which can lead to rendering corruption if we overflow the dyn. VB ring buffer).
	if ( !bShadowDepth )
	{
		m_DrawFlags |= DF_SKIP_WORLD;
		DrawWorld( waterZAdjust );
		m_DrawFlags &= ~DF_SKIP_WORLD;
	}
		
	//if ( !m_bDrawWorldNormal )
	{
		if ( m_DrawFlags & DF_DRAW_ENTITITES )
		{
			DrawTranslucentRenderables( false, false );
			if ( !bShadowDepth )
				DrawNoZBufferTranslucentRenderables();
		}
		else
		{
			// Draw translucent world brushes only, no entities
			DrawTranslucentWorldInLeaves( false );
		}
	}

	pRenderContext.GetFrom( materials );
	pRenderContext->SetFrameBufferCopyTexture( pSaveFrameBufferCopyTexture );
	PopView();

	m_DrawFlags = iDrawFlagsBackup;

	g_CurrentViewID = savedViewID;

#if defined( _X360 )
	pRenderContext->PopVertexShaderGPRAllocation();
#endif
}

static void	DrawOpaqueRenderables_ModelRenderablesDeferred( int nCount, ModelRenderSystemData_t* pModelRenderables )
{
	g_pModelRenderSystem->DrawModels( pModelRenderables, nCount, MODEL_RENDER_MODE_NORMAL );
}

static void	DrawOpaqueRenderables_NPCsDeferred( int nCount, CClientRenderablesList::CEntry **ppEntities, bool bNoDecals )
{
	DrawOpaqueRenderables_Range( nCount, ppEntities, bNoDecals );
}

static void DrawOpaqueRenderables_DrawStaticPropsDeferred( int nCount, CClientRenderablesList::CEntry **ppEntities )
{
	if ( nCount == 0 )
		return;

	float one[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
	render->SetColorModulation(	one );
	render->SetBlend( 1.0f );
	
	const int MAX_STATICS_PER_BATCH = 512;
	IClientRenderable *pStatics[ MAX_STATICS_PER_BATCH ];
	RenderableInstance_t pInstances[ MAX_STATICS_PER_BATCH ];
	
	int numScheduled = 0, numAvailable = MAX_STATICS_PER_BATCH;

	for( int i = 0; i < nCount; ++i )
	{
		CClientRenderablesList::CEntry *itEntity = ppEntities[i];
		if ( itEntity->m_pRenderable )
			NULL;
		else
			continue;

		pInstances[ numScheduled ] = itEntity->m_InstanceData;
		pStatics[ numScheduled ++ ] = itEntity->m_pRenderable;
		if ( -- numAvailable > 0 )
			continue; // place a hint for compiler to predict more common case in the loop
		
		staticpropmgr->DrawStaticProps( pStatics, pInstances, numScheduled, false, vcollide_wireframe.GetBool() );
		numScheduled = 0;
		numAvailable = MAX_STATICS_PER_BATCH;
	}
	
	if ( numScheduled )
		staticpropmgr->DrawStaticProps( pStatics, pInstances, numScheduled, false, vcollide_wireframe.GetBool() );
}

void CBaseWorldBlendViewDeferred::DrawOpaqueRenderablesDeferred( bool bNoDecals )
{
	VPROF("CViewRender::DrawOpaqueRenderables" );

	if( !r_drawopaquerenderables.GetBool() )
		return;

	if( !m_pMainView->ShouldDrawEntities() )
		return;

	render->SetBlend( 1 );

	//
	// Prepare to iterate over all leaves that were visible, and draw opaque things in them.	
	//
	RopeManager()->ResetRenderCache();
	g_pParticleSystemMgr->ResetRenderCache();

	// Categorize models by type
	int nOpaqueRenderableCount = m_pRenderablesList->m_RenderGroupCounts[RENDER_GROUP_OPAQUE];
	CUtlVector< CClientRenderablesList::CEntry* > brushModels( (CClientRenderablesList::CEntry **)stackalloc( nOpaqueRenderableCount * sizeof( CClientRenderablesList::CEntry* ) ), nOpaqueRenderableCount );
	CUtlVector< CClientRenderablesList::CEntry* > staticProps( (CClientRenderablesList::CEntry **)stackalloc( nOpaqueRenderableCount * sizeof( CClientRenderablesList::CEntry* ) ), nOpaqueRenderableCount );
	CUtlVector< CClientRenderablesList::CEntry* > otherRenderables( (CClientRenderablesList::CEntry **)stackalloc( nOpaqueRenderableCount * sizeof( CClientRenderablesList::CEntry* ) ), nOpaqueRenderableCount );
	CClientRenderablesList::CEntry *pOpaqueList = m_pRenderablesList->m_RenderGroups[RENDER_GROUP_OPAQUE];
	for ( int i = 0; i < nOpaqueRenderableCount; ++i )
	{
		switch( pOpaqueList[i].m_nModelType )
		{
		case RENDERABLE_MODEL_BRUSH:		brushModels.AddToTail( &pOpaqueList[i] ); break; 
		case RENDERABLE_MODEL_STATIC_PROP:	staticProps.AddToTail( &pOpaqueList[i] ); break; 
		default:							otherRenderables.AddToTail( &pOpaqueList[i] ); break; 
		}
	}

	//
	// First do the brush models
	//
	DrawOpaqueRenderables_DrawBrushModels( brushModels.Count(), brushModels.Base(), bNoDecals );

	// Move all static props to modelrendersystem
	bool bUseFastPath = ( cl_modelfastpath.GetInt() != 0 );

	//
	// Sort everything that's not a static prop
	//
	int nStaticPropCount = staticProps.Count();
	int numOpaqueEnts = otherRenderables.Count();
	CUtlVector< CClientRenderablesList::CEntry* > arrRenderEntsNpcsFirst( (CClientRenderablesList::CEntry **)stackalloc( numOpaqueEnts * sizeof( CClientRenderablesList::CEntry ) ), numOpaqueEnts );
	CUtlVector< ModelRenderSystemData_t > arrModelRenderables( (ModelRenderSystemData_t *)stackalloc( ( numOpaqueEnts + nStaticPropCount ) * sizeof( ModelRenderSystemData_t ) ), numOpaqueEnts + nStaticPropCount );

	// Queue up RENDER_GROUP_OPAQUE_ENTITY entities to be rendered later.
	CClientRenderablesList::CEntry *itEntity;
	if( r_drawothermodels.GetBool() )
	{
		MDLCACHE_CRITICAL_SECTION();
		for ( int i = 0; i < numOpaqueEnts; ++i )
		{
			itEntity = otherRenderables[i];
			if ( !itEntity->m_pRenderable )
				continue;

			IClientUnknown *pUnknown = itEntity->m_pRenderable->GetIClientUnknown();
			IClientModelRenderable *pModelRenderable = pUnknown->GetClientModelRenderable();
			C_BaseEntity *pEntity = pUnknown->GetBaseEntity();

			// FIXME: Strangely, some static props are in the non-static prop bucket
			// which is what the last case in this if statement is for
			if ( bUseFastPath && pModelRenderable )
			{
				ModelRenderSystemData_t data;
				data.m_pRenderable = itEntity->m_pRenderable;
				data.m_pModelRenderable = pModelRenderable;
				data.m_InstanceData = itEntity->m_InstanceData;
				arrModelRenderables.AddToTail( data );
				otherRenderables.FastRemove( i );
				--i; --numOpaqueEnts;
				continue;
			}

			if ( !pEntity )
				continue;

			if ( pEntity->IsNPC() || pEntity->IsUnit() )
			{
				arrRenderEntsNpcsFirst.AddToTail( itEntity );
				otherRenderables.FastRemove( i );
				--i; --numOpaqueEnts;
				continue;
			}
		}
	}

	// Queue up the static props to be rendered later.
	for ( int i = 0; i < nStaticPropCount; ++i )
	{
		itEntity = staticProps[i];
		if ( !itEntity->m_pRenderable )
			continue;

		IClientUnknown *pUnknown = itEntity->m_pRenderable->GetIClientUnknown();
		IClientModelRenderable *pModelRenderable = pUnknown->GetClientModelRenderable();
		if ( !bUseFastPath || !pModelRenderable )
			continue;

		ModelRenderSystemData_t data;
		data.m_pRenderable = itEntity->m_pRenderable;
		data.m_pModelRenderable = pModelRenderable;
		data.m_InstanceData = itEntity->m_InstanceData;
		arrModelRenderables.AddToTail( data );

		staticProps.FastRemove( i );
		--i; --nStaticPropCount;
	}

	//
	// Draw model renderables now (ie. models that use the fast path)
	//					 
	DrawOpaqueRenderables_ModelRenderablesDeferred( arrModelRenderables.Count(), arrModelRenderables.Base() );

	// Turn off z pass here. Don't want non-fastpath models with potentially large dynamic VB requirements overwrite
	// stuff in the dynamic VB ringbuffer. We're calling End360ZPass again in DrawExecute, but that's not a problem.
	// Begin360ZPass/End360ZPass don't have to be matched exactly.
	End360ZPass();

	//
	// Draw static props + opaque entities that aren't using the fast path.
	//
	DrawOpaqueRenderables_Range( otherRenderables.Count(), otherRenderables.Base(), bNoDecals );
	DrawOpaqueRenderables_DrawStaticPropsDeferred( staticProps.Count(), staticProps.Base() );

	//
	// Draw NPCs now
	//
	DrawOpaqueRenderables_NPCsDeferred( arrRenderEntsNpcsFirst.Count(), arrRenderEntsNpcsFirst.Base(), bNoDecals );

	//
	// Ropes and particles
	//
	RopeManager()->DrawRenderCache( false );
	g_pParticleSystemMgr->DrawRenderCache( false );
}

void CGBufferBlendView::Setup( const CViewSetup &view, bool bDrewSkybox )
{
	m_fogInfo.m_bEyeInFogVolume = false;
	m_bDrewSkybox = bDrewSkybox;

	BaseClass::Setup( view );
	m_bDrawWorldNormal = true;

	m_ClearFlags = 0;
	m_DrawFlags = DF_DRAW_ENTITITES;

	m_DrawFlags |= DF_RENDER_UNDERWATER | DF_RENDER_ABOVEWATER;

#if DEFCFG_DEFERRED_SHADING
	if ( !bDrewSkybox )
		m_DrawFlags |= DF_DRAWSKYBOX;
#endif
}

void CGBufferBlendView::Draw()
{
	VPROF( "CViewRender::ViewDrawScene_NoWater" );

	CMatRenderContextPtr pRenderContext( materials );
	PIXEVENT( pRenderContext, "CSimpleWorldViewDeferred::Draw" );

#if defined( _X360 )
	pRenderContext->PushVertexShaderGPRAllocation( 32 ); //lean toward pixel shader threads
#endif

	SetupCurrentView( origin, angles, VIEW_DEFERRED_GBUFFER );

	DrawSetup( 0, m_DrawFlags, 0 );

	const bool bOptimizedGbuffer = DEFCFG_DEFERRED_SHADING == 0;
	DrawExecute( 0, CurrentViewID(), 0, bOptimizedGbuffer );

	pRenderContext.GetFrom( materials );
	pRenderContext->ClearColor4ub( 0, 0, 0, 255 );

#if defined( _X360 )
	pRenderContext->PopVertexShaderGPRAllocation();
#endif
}

void CGBufferBlendView::PushView( float waterHeight )
{
	PushGBuffer( !m_bDrewSkybox );
}

void CGBufferBlendView::PopView()
{
	PopGBuffer();
}

void CBaseShadowBlendView::Setup( const CViewSetup &view, ITexture *pDepthTexture, ITexture *pDummyTexture )
{
	m_pDepthTexture = pDepthTexture;
	m_pDummyTexture = pDummyTexture;

	BaseClass::Setup( view );

	m_bDrawWorldNormal =  true;

	m_DrawFlags = DF_DRAW_ENTITITES | DF_RENDER_UNDERWATER | DF_RENDER_ABOVEWATER;
	m_ClearFlags = 0;

	CalcShadowView();

	m_pCustomVisibility = &shadowVis;
	shadowVis.AddVisOrigin( origin );
}

void CBaseShadowBlendView::SetupRadiosityTargets( ITexture *pAlbedoTexture, ITexture *pNormalTexture )
{
	m_pRadAlbedoTexture = pAlbedoTexture;
	m_pRadNormalTexture = pNormalTexture;
}

void CBaseShadowBlendView::Draw()
{
	int oldViewID = g_CurrentViewID;
	SetupCurrentView( origin, angles, VIEW_DEFERRED_SHADOW );

	CMatRenderContextPtr pRenderContext( materials );
	pRenderContext->SetIntRenderingParameter( INT_RENDERPARM_DEFERRED_RENDER_STAGE,
		DEFERRED_RENDER_STAGE_SHADOWPASS );
	pRenderContext->SetIntRenderingParameter( INT_RENDERPARM_DEFERRED_SHADOW_MODE,
		GetShadowMode() );
	pRenderContext->SetIntRenderingParameter( INT_RENDERPARM_DEFERRED_SHADOW_RADIOSITY,
		m_bOutputRadiosity ? 1 : 0 );
	pRenderContext.SafeRelease();
	
	DrawSetup( 0, m_DrawFlags, 0, -1, true );

	DrawExecute( 0, CurrentViewID(), 0, true );

	pRenderContext.GetFrom( materials );
		pRenderContext->SetIntRenderingParameter( INT_RENDERPARM_DEFERRED_SHADOW_RADIOSITY,
		0 );
	pRenderContext->SetIntRenderingParameter( INT_RENDERPARM_DEFERRED_RENDER_STAGE,
		DEFERRED_RENDER_STAGE_INVALID );

	g_CurrentViewID = oldViewID;
}

bool CBaseShadowBlendView::AdjustView( float waterHeight )
{
	CommitData();

	return true;
}

void CBaseShadowBlendView::PushView( float waterHeight )
{
	render->Push3DView( *this, 0, m_pDummyTexture, GetFrustum(), m_pDepthTexture );

	CMatRenderContextPtr pRenderContext( materials );
	pRenderContext->PushRenderTargetAndViewport( m_pDummyTexture, m_pDepthTexture, x, y, width, height );

#if defined( DEBUG ) || defined( SHADOWMAPPING_USE_COLOR )
	pRenderContext->ClearColor4ub( 255, 255, 255, 255 );
	pRenderContext->ClearBuffers( true, true );
#else
	pRenderContext->ClearBuffers( false, true );
#endif

	if ( m_bOutputRadiosity )
	{
		Assert( !IsErrorTexture( m_pRadAlbedoTexture ) );
		Assert( !IsErrorTexture( m_pRadNormalTexture ) );

		pRenderContext->SetRenderTargetEx( 1, m_pRadAlbedoTexture );
		pRenderContext->SetRenderTargetEx( 2, m_pRadNormalTexture );
	}
}

void CBaseShadowBlendView::PopView()
{
	CMatRenderContextPtr pRenderContext( materials );
	pRenderContext->PopRenderTargetAndViewport();

	render->PopView( GetFrustum() );
}

void CBaseShadowBlendView::SetRadiosityOutputEnabled( bool bEnabled )
{
	m_bOutputRadiosity = bEnabled;
}

//#define ORTHO_TESTVALUES_DEBUG

void COrthoShadowBlendView::CalcShadowView()
{
	const cascade_t &m_data = GetCascadeInfo( iCascadeIndex );
	Vector mainFwd;
	AngleVectors( angles, &mainFwd );

	lightData_Global_t state = GetActiveGlobalLightState();
	QAngle lightAng;
	VectorAngles( -state.vecLight.AsVector3D(), lightAng );

	Vector viewFwd, viewRight, viewUp;
	AngleVectors( lightAng, &viewFwd, &viewRight, &viewUp );

#ifdef ORTHO_TESTVALUES_DEBUG
	float flProjectionSize = m_data.flProjectionSize;
	if( iCascadeIndex == 1 )
	{
		static ConVar def_test_ortho1("def_test_ortho1", "0");
		if( def_test_ortho1.GetInt() != 0 )
			flProjectionSize = def_test_ortho1.GetFloat();
	}
	else
	{
		static ConVar def_test_ortho0("def_test_ortho0", "0");
		if( def_test_ortho0.GetInt() != 0 )
			flProjectionSize = def_test_ortho0.GetFloat();
	}

	int iResolution = m_data.iResolution;
	if( iCascadeIndex == 1 )
	{
		static ConVar def_test_add_res1("def_test_add_res1", "0");
		if( def_test_add_res1.GetInt() != 0 )
			iResolution = def_test_add_res1.GetInt();
	}
	else
	{
		static ConVar def_test_add_res0("def_test_add_res0", "0");
		if( def_test_add_res0.GetInt() != 0 )
			iResolution = def_test_add_res0.GetInt();
	}

	const float halfOrthoSize = flProjectionSize * 0.5f;
#else
	const float halfOrthoSize = m_data.flProjectionSize * 0.5f;
#endif // ORTHO_TESTVALUES_DEBUG

	origin += -viewFwd * m_data.flOriginOffset +
		viewUp * halfOrthoSize -
		viewRight * halfOrthoSize +
		mainFwd * halfOrthoSize;

	angles = lightAng;

	x = 0;
	y = 0;
#ifndef ORTHO_TESTVALUES_DEBUG
	height = m_data.iResolution;
	width = m_data.iResolution;
#else
	height = width = iResolution;
#endif // ORTHO_TESTVALUES_DEBUG

	m_bOrtho = true;
	m_OrthoLeft = 0;
#ifndef ORTHO_TESTVALUES_DEBUG
	m_OrthoTop = -m_data.flProjectionSize;
	m_OrthoRight = m_data.flProjectionSize;
#else
	m_OrthoTop = -flProjectionSize;
	m_OrthoRight = flProjectionSize;
#endif // ORTHO_TESTVALUES_DEBUG
	m_OrthoBottom = 0;

	zNear = zNearViewmodel = 0;
	zFar = zFarViewmodel = m_data.flFarZ;
	m_flAspectRatio = 0;

#ifndef ORTHO_TESTVALUES_DEBUG
	float mapping_world = m_data.flProjectionSize / m_data.iResolution;
#else
	float mapping_world = flProjectionSize / iResolution;
#endif // ORTHO_TESTVALUES_DEBUG
	origin -= fmod( DotProduct( viewRight, origin ), mapping_world ) * viewRight;
	origin -= fmod( DotProduct( viewUp, origin ), mapping_world ) * viewUp;

	origin -= fmod( DotProduct( viewFwd, origin ), GetDepthMapDepthResolution( zFar - zNear ) ) * viewFwd;

#if CSM_USE_COMPOSITED_TARGET
	x = m_data.iViewport_x;
	y = m_data.iViewport_y;

#ifdef ORTHO_TESTVALUES_DEBUG
	if( iCascadeIndex == 1 )
	{
		static ConVar def_test_add_x1("def_test_add_x1", "0");
		static ConVar def_test_add_y1("def_test_add_y1", "0");
		x += def_test_add_x1.GetInt();
		y += def_test_add_y1.GetInt();
	}
	else
	{
		static ConVar def_test_add_x0("def_test_add_x0", "0");
		static ConVar def_test_add_y0("def_test_add_y0", "0");
		x += def_test_add_x0.GetInt();
		y += def_test_add_y0.GetInt();
	}
#endif // ORTHO_TESTVALUES_DEBUG
#endif
}

void COrthoShadowBlendView::CommitData()
{
	struct sendShadowDataOrtho
	{
		shadowData_ortho_t data;
		int index;
		static void Fire( sendShadowDataOrtho d )
		{
			IDeferredExtension *pDef = GetDeferredExt();
			pDef->CommitShadowData_Ortho( d.index, d.data );
		};
	};

	const cascade_t &data = GetCascadeInfo( iCascadeIndex );

	Vector fwd, right, down;
	AngleVectors( angles, &fwd, &right, &down );
	down *= -1.0f;

	Vector vecScale( m_OrthoRight, abs( m_OrthoTop ), zFar - zNear );

	sendShadowDataOrtho shadowData;
	shadowData.index = iCascadeIndex;

#if CSM_USE_COMPOSITED_TARGET
	shadowData.data.iRes_x = CSM_COMP_RES_X;
	shadowData.data.iRes_y = CSM_COMP_RES_Y;
#else
	shadowData.data.iRes_x = width;
	shadowData.data.iRes_y = height;
#endif

	shadowData.data.vecSlopeSettings.Init(
		data.flSlopeScaleMin, data.flSlopeScaleMax, data.flNormalScaleMax, 1.0f / zFar
		);
	shadowData.data.vecOrigin.Init( origin );

	Vector4D matrix_scale_offset( 0.5f, -0.5f, 0.5f, 0.5f );

#if CSM_USE_COMPOSITED_TARGET
	shadowData.data.vecUVTransform.Init( x / (float)CSM_COMP_RES_X,
		y / (float)CSM_COMP_RES_Y,
		width / (float) CSM_COMP_RES_X,
		height / (float) CSM_COMP_RES_Y );
#endif

	VMatrix a,b,c,d,screenToTexture;
	render->GetMatricesForView( *this, &a, &b, &c, &d );
	MatrixBuildScale( screenToTexture, matrix_scale_offset.x,
		matrix_scale_offset.y,
		1.0f );

	screenToTexture[0][3] = matrix_scale_offset.z;
	screenToTexture[1][3] = matrix_scale_offset.w;

	MatrixMultiply( screenToTexture, c, shadowData.data.matWorldToTexture );

	QUEUE_FIRE( sendShadowDataOrtho, Fire, shadowData );

	CMatRenderContextPtr pRenderContext( materials );
	pRenderContext->SetIntRenderingParameter( INT_RENDERPARM_DEFERRED_SHADOW_INDEX, iCascadeIndex );
}


bool CDualParaboloidShadowBlendView::AdjustView( float waterHeight )
{
	BaseClass::AdjustView( waterHeight );

	// HACK: when pushing our actual view the renderer fails building the worldlist right!
	// So we can't. Shit.
	return false;
}

void CDualParaboloidShadowBlendView::PushView( float waterHeight )
{
	BaseClass::PushView( waterHeight );
}

void CDualParaboloidShadowBlendView::PopView()
{
	BaseClass::PopView();
}

void CDualParaboloidShadowBlendView::CalcShadowView()
{
	float flRadius = m_pLight->flRadius;

	m_bOrtho = true;
	m_OrthoTop = m_OrthoLeft = -flRadius;
	m_OrthoBottom = m_OrthoRight = flRadius;

	int dpsmRes = GetShadowResolution_Point();

	width = dpsmRes;
	height = dpsmRes;

	zNear = zNearViewmodel = 0;
	zFar = zFarViewmodel = flRadius;

	if ( m_bSecondary )
	{
		y = dpsmRes;

		Vector fwd, up;
		AngleVectors( angles, &fwd, NULL, &up );
		VectorAngles( -fwd, up, angles );
	}
}


void CSpotLightShadowBlendView::CalcShadowView()
{
	float flRadius = m_pLight->flRadius;

	int spotRes = GetShadowResolution_Spot();

	width = spotRes;
	height = spotRes;

	zNear = zNearViewmodel = DEFLIGHT_SPOT_ZNEAR;
	zFar = zFarViewmodel = flRadius;

	fov = fovViewmodel = m_pLight->GetFOV();
}

void CSpotLightShadowBlendView::CommitData()
{
	struct sendShadowDataProj
	{
		shadowData_proj_t data;
		int index;
		static void Fire( sendShadowDataProj d )
		{
			IDeferredExtension *pDef = GetDeferredExt();
			pDef->CommitShadowData_Proj( d.index, d.data );
		};
	};

	Vector fwd;
	AngleVectors( angles, &fwd );

	sendShadowDataProj data;
	data.index = m_iIndex;
	data.data.vecForward.Init( fwd );
	data.data.vecOrigin.Init( origin );
	// slope min, slope max, normal max, depth
	//data.data.vecSlopeSettings.Init( 0.005f, 0.02f, 3, zFar );
	data.data.vecSlopeSettings.Init( 0.001f, 0.005f, 3, 0 );

	QUEUE_FIRE( sendShadowDataProj, Fire, data );

	CMatRenderContextPtr pRenderContext( materials );
	pRenderContext->SetIntRenderingParameter( INT_RENDERPARM_DEFERRED_SHADOW_INDEX, m_iIndex );
}
#endif

Serverside

Todo:

Shared

Todo:

Shaders

Todo:

This article or section needs to be cleaned up to conform to a higher standard of quality because:

Actually properly research what is needed for this implementation. Until someone actually decides to the hard work this section should be dedicated to the stuff that is most definietly needed for this implementation to work. And when thats done this notice should be deleted.

Lamba War's source code Reference project : Source 2013MP deferred this project uses the older Alien swarm deferred's version but it still should give us some idea what needs to be changed.

Cpp files and header files needed to be modified or added

Client
- cdll_client_int.cpp ,modification needed
- viewrender.h ,modification needed
- viewrender.cpp ,modification needed
- flashlighteffect.h ,modification needed
- flashlighteffect.cpp ,modification needed
- c_entityflame.cpp ,modification needed although it's not necessary it's still a quality of life feature
- deferred ,This folder contents are needed which are:
  - cascade_t.cpp
  - cascade_t.h
  - DefCookieProjectable.cpp
  - DefCookieProjectable.h
  - DefCookieTexture.cpp
  - DefCookieTexture.h
  - IDefCookie.h
  - IDeferredExtClient.cpp
  - cdeferred_manager_client.cpp
  - cdeferred_manager_client.h
  - clight_editor.cpp
  - clight_editor.h
  - clight_manager.cpp
  - clight_manager.h
  - def_light_t.cpp
  - def_light_t.h
  - deferred_client_common.cpp
  - deferred_client_common.h
  - deferred_rt.cpp
  - deferred_rt.h
  - flashlighteffect_deferred.cpp
  - flashlighteffect_deferred.h
  - viewrender_deferred.cpp
  - viewrender_deferred.h
  - vgui ,This folder is also needed
    - projectable_factory.cpp
    - projectable_factory.h
    - vgui_deferred.h
    - vgui_editor_controls.cpp
    - vgui_editor_controls.h
    - vgui_editor_props.cpp
    - vgui_editor_props.h
    - vgui_editor_root.cpp
    - vgui_marquee.cpp
    - vgui_marquee.h
    - vgui_particles.cpp
    - vgui_particles.h
    - vgui_particles.cpp
    - vgui_projectable.cpp
    - vgui_projectable.h
Server
- gameinterface.cpp ,modification needed
- lights.cpp ,modification needed
- EntityFlame.h ,modification needed although it's not necessary it's still a quality of life feature
- deferred ,This folder contents are needed which are:
  - cdeferred_manager_server.cpp
  - deferred_server_common.h
  - cdeferred_manager_server.h
Shared
- deferred ,This folder contents are needed which are:
  - CDefLight.cpp
  - CDefLight.h
  - CDefLightContainer.cpp
  - CDefLightContainer.h
  - CDefLightGlobal.cpp
  - CDefLightGlobal.h
  - deferred_shared_common.cpp
  - deferred_shared_common.h
  - ssemath_ext.h
Public
- renderparm.h ,modification needed

Shaders

common_deferred_fxc.h
deferred_context.h
deferred_global_common.h
deferred_includes.h
deferred_utility.h
defpass_composite.h
defpass_gbuffer.h
defpass_shadow.h
IDeferredExt.h
lighting_helper.h
lighting_pass_basic.h
lighting_pass_volum.h
lightshafts_helper.h
vertexlitgeneric_dx9_helper.h
lightmappedgeneric_deferred_ps30.h
lightmappedgeneric_dx9_helper.h
debug_lightingctrl.cpp
debug_radiosity_grid.cpp
deferred_decalModulate.cpp
deferred_model.cpp
deferred_brush.cpp
defpass_composite.cpp
deferred_utility.cpp
defpass_gbuffer.cpp
defpass_shadow.cpp
GlobalLitGeneric.cpp
IDeferredExt.cpp
lighting_global.cpp
lighting_pass_basic.cpp
lighting_pass_volum.cpp
lighting_volume.cpp
lighting_world.cpp
radiosity_blend.cpp
radiosity_global.cpp
radiosity_propagate.cpp
volume_prepass.cpp
volume_blend.cpp
unlitgeneric_dx9.cpp
vertexlitgeneric_dx9.cpp
vertexlitgeneric_dx9_helper.cpp
lightmappedgeneric_dx9.cpp
lightmappedgeneric_dx9_helper.cpp
lightmappedgeneric_dx9_deferred_helper.cpp
phong_dx9_helper.cpp
gbuffer_vs30.fxc
gbuffer_ps30.fxc
gbuffer_defshading_ps30.fxc
shadowpass_vs30.fxc
shadowpass_ps30.fxc
composite_vs30.fxc
composite_ps30.fxc
defconstruct_vs30.fxc
decalmodulate_vs20.fxc
decalmodulate_ps2x.fxc
lightingpass_global_ps30.fxc
lightingpass_point_ps30.fxc
lightingpass_spot_ps30.fxc
screenspace_shading_ps30.fxc
screenspace_combine_ps30.fxc
volume_blend_ps30.fxc
volume_prepass_vs30.fxc
volume_prepass_ps30.fxc
volumpass_point_ps30.fxc
volumpass_spot_ps30.fxc
radiosity_gen_global_ps30.fxc
radiosity_gen_vs30.fxc
radiosity_propagate_ps30.fxc
radiosity_propagate_vs30.fxc
radiosity_blend_ps30.fxc
screenspace_vs20.fxc
gaussianblur_6_ps30.fxc
debug_shadow_ortho_ps30.fxc
debug_lighting_ctrl_ps30.fxc
debug_radiosity_grid_ps30.fxc
debug_radiosity_grid_vs30.fxc
globallitgeneric_ps30.fxc
globallitgeneric_vs30.fxc
phong_deferred_ps30.fxc
lightmappedgeneric_deferred_vs30.fxc
lightmappedgeneric_deferred_ps30.fxc
vertexlit_and_unlit_generic_bump_deferred_ps30.fxc

For help, see the VDC Editing Help and Wikipedia cleanup process. Also, remember to check for any notes left by the tagger at this article's talk page.

External links

Lambda war's source code

Implementing Deferred lighting into Source 2013

Implementing into your Source 2013SP mod

Clientside

Serverside

Shared

Shaders

Cpp files and header files needed to be modified or added

Shaders

External links

Navigation menu

Personal tools

Namespaces

Variants

Views

More

Search

Navigation

Support

Steam Community

Tools