csgo/cstrike15_src/unittests/rendersystemtest/worldrenderertest.cpp

//=========== (C) Copyright 1999 Valve, L.L.C. All rights reserved. ===========
//
// The copyright to the contents herein is the property of Valve, L.L.C.
// The contents may be used and/or copied only with the written permission of
// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
// the agreement/contract under which the contents have been supplied.
//
// $Header: $
// $NoKeywords: $
//
// Render system unit test
//=============================================================================

#include "rendersystemtest.h"
#include "inputsystem/iinputsystem.h"
#include "materialsystem2/imaterialsystem2.h"
#include "worldrenderer/iworldrenderermgr.h"
#include "meshsystem/imeshsystem.h"
#include "filesystem.h"
#include "vstdlib/jobthread.h"
#include "particles/particles.h"
#include "dynamicdrawhelper.h"
#include "tier0/vprof.h"
#include "keyvalues.h"
#include "scenesystem/iscenesystem.h"
#include "icommandline.h"
#include "inputsystem/iinputstacksystem.h"

struct usercmd_t
{
	float m_flForwardMove;
	float m_flRightMove;
	float m_flYawMove;
	float m_flPitchMove;
	uint32 m_nKeys;
};

struct BoxVertex_t
{
	Vector m_vPos;
};

#define FKEY_FORWARD		0x00000001
#define FKEY_BACK			0x00000002
#define FKEY_LEFT			0x00000004
#define FKEY_RIGHT			0x00000008
#define FKEY_TURNLEFT		0x00000010
#define FKEY_TURNRIGHT		0x00000020
#define FKEY_TURNUP			0x00000040
#define FKEY_TURNDOWN		0x00000080
#define FKEY_SHOOTDECAL		0x00000100
#define FKEY_SHOOTPSYSTEM	0x00000200
#define FKEY_SHOOTSSYSTEM	0x00000400
#define FKEY_LIGHTELV		0x00000800
#define FKEY_LIGHTANG_POS	0x00001000
#define FKEY_LIGHTANG_NEG	0x00002000
#define FKEY_FAST			0x00004000
#define FKEY_ENABLE_VIS		0x00008000
#define FKEY_DISABLE_VIS	0x00010000
#define FKEY_DROP_FRUSTUM	0x00020000
#define FKEY_TOGGLE_AERIAL	0x00040000
#define FKEY_TOGGLE_BOUNCE	0x00080000
#define FKEY_TOGGLE_DIRECT	0x00100000
#define FKEY_TOGGLE_LIGHTING_ONLY	0x00200000
#define FKEY_SSAO			0x00400000
#define FKEY_BLUR_LIGHTING	0x00800000
#define FKEY_BLUR_SHADOWS	0x01000000
#define FKEY_FLASHLIGHT		0x02000000
#define FKEY_SHOOTDECAL2	0x04000000
#define FKEY_SHOOTWALLMONSTER 0x08000000

#define NUM_SHADOW_SPLITS 3
#define NUM_MULTI_SHADOWS 20
#define NUM_HIGH_RES_SHADOWS 4
#define SQRT_NUM_HIGH_RES_SHADOWS 2
#define NUM_LOW_RES_SHADOWS 16
#define SQRT_NUM_LOW_RES_SHADOWS 4
#define MAX_LIGHT_DISTANCE 2000.0f

#define MAX_MESH_SYSTEM_MODELS 5
char *g_pRenderableList[ MAX_MESH_SYSTEM_MODELS ] = 
{
	"models/w_minigun_reference.dmx",
	"models/pm_heavy_reference.dmx",
	"models/w_bonesaw_reference.dmx",
	"models/w_guitar_reference.dmx",
	"models/w_harpahorn.dmx",
};
int g_nCurrentModel = 0;

struct DecalVertex_t
{
	Vector m_vPos;
	Vector m_vDecalOrigin;
	Vector m_vDecalRight;
	Vector4D m_vDecalUpAndInfluence;
};

struct SphereVertex_t
{
	Vector m_vPos;
};

struct QuadVertex_t
{
	Vector m_vPos;
	Vector m_vEyeRay;
};

struct ViewRelatedConstants_t
{
	VMatrix m_mViewProjection;
	Vector4D m_vEyePt;
	Vector4D m_vEyeDir;
	Vector4D m_flFarPlane;
};

struct LightingConstants_t
{
	Vector4D m_vLightDir;
	Vector4D m_vLightColor;
	VMatrix m_mShadowMatrices[NUM_SHADOW_SPLITS];
};

struct DeferredLightingConstants_t
{
	Vector4D m_vLightDir;
	Vector4D m_vLightColor;
	Vector4D m_vInvScreenExtents;
	Vector4D m_vEyePt;
	VMatrix  m_mInvViewProj;
	VMatrix  m_mShadowMatrix[NUM_SHADOW_SPLITS];
};

struct AerialPerspectiveConstants_t
{
	Vector4D m_vLightDir;
	Vector4D m_vLightColor;
	Vector4D m_vInvScreenExtents;
	Vector4D m_vBm;
	Vector4D m_flG;
	Vector4D m_vNearAndFar;
	Vector4D m_vEyePt;
	
	VMatrix m_mInvViewProj;
};

struct DecalScreenData_t
{
	Vector4D m_vInvScreenExtents;
	VMatrix  m_mInvViewProj;
	Vector4D m_vEyePt;
	Vector4D m_vEyeDir;
};

struct BlurParams_t
{
	Vector4D m_flBlurFalloff;
	Vector4D m_flSharpness;
	Vector4D m_flFarPlane;
};

#define NUM_SSAO_SAMPLES 16
struct SampleSphereData_t
{
	VMatrix  m_mViewProj;
	Vector4D m_vRandSampleScale;
	Vector4D m_vSampleRadiusNBias;
	Vector4D m_vSphereSamples[ NUM_SSAO_SAMPLES ];
};

struct LightBufferData_t
{
	Vector4D m_vInvScreenExtents;
};

struct SkyVSCB_t
{
	VMatrix m_mViewProj;
	Vector4D m_vSkyScale;
};

struct SkyPSCB_t
{
	Vector4D m_vLightDir;
	Vector4D m_vEyePt;
	Vector4D m_vLightColor;
	Vector4D m_vBm;
	Vector4D m_flG;
};

struct PerParticleData_t
{
	Vector4D m_vPosRadius;
	Vector4D m_vColor;
};

struct SimulateWorkUnitWorldRender_t
{
	CParticleCollection *m_pParticles;
	int m_nNumSystems;
	float m_flTimeStep;
};

const int g_nNothingRenderedStencilRef = 0;
const int g_nCanSeeSkyStencilRef = 1;
const int g_nCannotSeeSkyStencilRef = 2;

// Globalizing these so we can render nodes in parallel
class CWorldRendererTest;
CWorldRendererTest *g_pWorldRendererTest = NULL;

enum RenderViewFlags_t
{
	VIEW_PLAYER_CAMERA		= 0x00000001,
	VIEW_LIGHT_SHADOW		= 0x00000002,
	VIEW_REFLECTION			= 0x00000004,
	VIEW_MONITOR			= 0x00000008,
	VIEW_POST_PROCESS		= 0x00000010,
	VIEW_LIGHTING			= 0x00000020,
	VIEW_DECALS				= 0x00000040
};

enum RenderTargetType_t
{
	DS_SHADOW_DEPTH0 = 0x0,
	DS_SHADOW_DEPTH1,
	DS_SHADOW_DEPTH2,
	DS_SHADOW_DEPTH_MULTIPLE,
	RT_SHADOW_MULTIPLE_0,
	RT_SHADOW_MULTIPLE_1,
	RT_SHADOW_BLUR_TEMP,

	DS_DEPTH_HIGHRES,
	RT_VIEW_DEPTH_HIGHRES,
	RT_VIEW_NORMAL_HIGHRES,
	RT_VIEW_SPEC_HIGHRES,
	RT_LIGHTING_HIGHRES, // Alpha contains occlusion
	RT_SPECULAR_HIGHRES,

	DS_DEPTH_LOWRES,
	RT_VIEW_DEPTH_LOWRES,
	RT_VIEW_NORMAL_LOWRES,
	RT_LIGHTING_LOWRES,

	RT_LIGHTING_TEMP_LOWRES,

	MAX_RENDER_TARGET_TYPES
};

char *g_pRenderTargetName[] = 
{
	{"DS_SHADOW_DEPTH0"},
	{"DS_SHADOW_DEPTH1"},
	{"DS_SHADOW_DEPTH2"},
	{"DS_SHADOW_DEPTH_MULTIPLE"},
	{"RT_SHADOW_MULTIPLE_1"},
	{"RT_SHADOW_MULTIPLE_2"},
	{"RT_SHADOW_BLUR_TEMP"},

	{"DS_DEPTH_HIGHRES"},
	{"RT_VIEW_DEPTH_HIGHRES"},
	{"RT_VIEW_NORMAL_HIGHRES"},
	{"RT_VIEW_SPEC_HIGHRES"},
	{"RT_LIGHTING_HIGHRES"},
	{"RT_SPECULAR_HIGHRES"},

	{"DS_DEPTH_LOWRES"},
	{"RT_VIEW_DEPTH_LOWRES"},
	{"RT_VIEW_NORMAL_LOWRES"},
	{"RT_LIGHTING_LOWRES"},

	{"RT_LIGHTING_TEMP_LOWRES"},

	{"MAX_RENDER_TARGET_TYPES"}
};

enum ViewBindingType_t
{
	RTB_SHADOW_DEPTH0 = 0x0,
	RTB_SHADOW_DEPTH1,
	RTB_SHADOW_DEPTH2,

	RTB_SHADOW_DEPTH_MULTIPLE_0,
	RTB_SHADOW_DEPTH_MULTIPLE_1,
	RTB_SHADOW_DEPTH_MULTIPLE_2,
	RTB_SHADOW_DEPTH_MULTIPLE_3,

	RTB_SHADOW_DEPTH_MULTIPLE_4,
	RTB_SHADOW_DEPTH_MULTIPLE_5,
	RTB_SHADOW_DEPTH_MULTIPLE_6,
	RTB_SHADOW_DEPTH_MULTIPLE_7,

	RTB_SHADOW_DEPTH_MULTIPLE_8,
	RTB_SHADOW_DEPTH_MULTIPLE_9,
	RTB_SHADOW_DEPTH_MULTIPLE_10,
	RTB_SHADOW_DEPTH_MULTIPLE_11,

	RTB_SHADOW_DEPTH_MULTIPLE_12,
	RTB_SHADOW_DEPTH_MULTIPLE_13,
	RTB_SHADOW_DEPTH_MULTIPLE_14,
	RTB_SHADOW_DEPTH_MULTIPLE_15,

	RTB_SHADOW_DEPTH_MULTIPLE_16,
	RTB_SHADOW_DEPTH_MULTIPLE_17,
	RTB_SHADOW_DEPTH_MULTIPLE_18,
	RTB_SHADOW_DEPTH_MULTIPLE_19,

	RTB_SHADOW_DEPTH_MULTIPLE_20,
	RTB_SHADOW_DEPTH_MULTIPLE_21,
	RTB_SHADOW_DEPTH_MULTIPLE_22,
	RTB_SHADOW_DEPTH_MULTIPLE_23,

	RTB_SHADOW_DEPTH_MULTIPLE_24,
	RTB_SHADOW_DEPTH_MULTIPLE_25,
	RTB_SHADOW_DEPTH_MULTIPLE_26,
	RTB_SHADOW_DEPTH_MULTIPLE_27,

	RTB_SHADOW_DEPTH_MULTIPLE_28,
	RTB_SHADOW_DEPTH_MULTIPLE_29,
	RTB_SHADOW_DEPTH_MULTIPLE_30,
	RTB_SHADOW_DEPTH_MULTIPLE_31,

	RTB_DEFERRED_DEPTH_NORM_SPEC,
	RTB_DEFERRED_SCALE_DOWN,
	RTB_DEFERRED_NORM_SPEC,
	RTB_CLEAR_SPEC_HIGHRES,
	RTB_LIGHTING_HIGHRES,
	RTB_LIGHTING_LOWRES,
	RTB_SSAO_LOWRES,
	RTB_BILAT_UPSAMPLE_0,
	RTB_BILAT_UPSAMPLE_1,
	RTB_LIGHT_BLUR_0,
	RTB_LIGHT_BLUR_1,
	RTB_SHADOW_BLUR_0,
	RTB_SHADOW_BLUR_1,
	RTB_SHADOW_BLUR_2,
	RTB_SAMPLE_LIGHTING,
	RTB_AERIAL_PERSPECTIVE,
	RTB_SKY,

	RTB_FORWARD,

	MAX_VIEW_BINDING_TYPES
};

ViewRelatedConstants_t CreateViewConstantsForFrustum( CWorldRenderFrustum* pFrustum )
{
	const Vector vEyePt = pFrustum->GetCameraPosition();
	Vector vEyeDir = pFrustum->Forward();
	float flFarPlane = pFrustum->GetFarPlane();
	vEyeDir /= flFarPlane;

	ViewRelatedConstants_t viewConstants;
	viewConstants.m_mViewProjection = pFrustum->GetViewProj();
	viewConstants.m_vEyePt.Init( vEyePt.x, vEyePt.y, vEyePt.z, 1 );
	viewConstants.m_flFarPlane.Init( flFarPlane, flFarPlane, flFarPlane, 1 );
	viewConstants.m_vEyeDir.Init( vEyeDir.x, vEyeDir.y, vEyeDir.z, 1 );
	return viewConstants;
}

#define MAX_SIMUL_VIEWS 5

class CRenderView;

class CStaticMeshRenderable
{
public:
	CStaticMeshRenderable() {}
	~CStaticMeshRenderable() {}

	inline bool operator==( const CStaticMeshRenderable& src ) const { return src.m_pDrawCall == m_pDrawCall; }

	IBVHNode							*m_pNode;
	CBVHDrawCall						*m_pDrawCall;
};

class CDynamicRenderable
{
public:
	CDynamicRenderable() {}
	~CDynamicRenderable() {}

	inline bool operator==( const CDynamicRenderable &src ) const { return src.m_hRenderable == m_hRenderable; }

	HRenderableStrong m_hRenderable;
	VMatrix m_mWorld;
	Vector m_vOrigin;
};

class CPointLightRenderable
{
public:
	CPointLightRenderable() {}
	~CPointLightRenderable() {}

	inline bool operator==( const CPointLightRenderable& src ) const { return src.m_pLight == m_pLight; }

	PointLightData_t *m_pLight;
	Vector m_vOrigin;
};

class CSpotLightRenderable
{
public:
	CSpotLightRenderable() {}
	~CSpotLightRenderable() {}

	inline bool operator==( const CSpotLightRenderable& src ) const { return src.m_pLight == m_pLight; }

	SpotLightData_t *m_pLight;
	Vector m_vOrigin;
	float m_flSquaredDistToEye;
	bool m_bInterior;
	bool m_bValid;
};

class CHemiLightRenderable
{
public:
	CHemiLightRenderable() {}
	~CHemiLightRenderable() {}

	inline bool operator==( const CHemiLightRenderable& src ) const { return src.m_pLight == m_pLight; }

	HemiLightData_t *m_pLight;
	Vector m_vOrigin;
};

struct RenderJob_t
{
	CWorldRendererTest *m_pTestApp;
	CRenderView *m_pRenderView;
	int m_nStartStatic;
	int m_nCountStatic;

	int m_nStartDynamic;
	int m_nCountDynamic;

	int m_nIndex;
};

class CRenderView
{
public:
	CRenderView() {}
	~CRenderView() { g_pRenderDevice->DestroyRenderTargetBinding( m_hRenderTargetBinding ); }

	void Init( IRenderDevice* pRenderDevice,
			   CWorldRenderFrustum *pFrustum,
			   RenderTargetBinding_t hRenderTargetBinding, 
			   RenderViewport_t &viewport, 
			   RenderViewFlags_t nFlags, 
			   int nPass,
			   int nViewType )
	{
		g_pRenderDevice = pRenderDevice;
		m_pFrustum = pFrustum;
		m_hRenderTargetBinding = hRenderTargetBinding;
		m_viewport = viewport;
		m_nFlags = nFlags;
		m_nPass = nPass;
		m_nViewType = nViewType;
		m_bValid = true;
	}

	RenderTargetBinding_t GetRenderTargetBinding() { return m_hRenderTargetBinding; }
	RenderViewFlags_t GetViewFlags() { return m_nFlags; }
	int GetRenderPass() { return m_nPass; }
	int GetViewType() { return m_nViewType; }
	CWorldRenderFrustum *GetFrustum() { return m_pFrustum; }
	IRenderDevice *GetRenderDevice() { return g_pRenderDevice; }
	bool IsValid() { return m_bValid; }
	void SetValid( bool bValid ) { m_bValid = bValid; }

	void UpdateFrustum( CWorldRenderFrustum *pFrustum )
	{
		m_pFrustum = pFrustum;
	}

	void Clear( IRenderContext *pRenderContext, Vector4D &vClearColor, int nFlags )
	{
		Assert( pRenderContext );

		BeginRender( pRenderContext );

		pRenderContext->Clear( vClearColor, nFlags );

		// don't call endrender because it clears the rendercontext and the renderable list
		pRenderContext->Submit();
	}

	void BeginRender( IRenderContext *pRenderContext )
	{
		pRenderContext->BindRenderTargets( m_hRenderTargetBinding );
		pRenderContext->SetViewports( 1, &m_viewport );
	}

	void EndRender( IRenderContext *pRenderContext, bool bClearList = true )
	{
		if ( pRenderContext )
		{
			pRenderContext->Submit();
		}

		if ( bClearList )
		{
			if ( m_renderableList.Count() > 0 )
			{
				m_renderableList.SetCountNonDestructively( 0 );
			}
			if ( m_dynList.Count() > 0 )
			{
				m_dynList.SetCountNonDestructively( 0 );
			}
		}
	}

	void AddStaticMeshRenderable( CStaticMeshRenderable *pRenderable )
	{
		m_renderableList.AddToTail( pRenderable );
	}

	void AddDynamicRenderable( CDynamicRenderable *pRenderable )
	{
		m_dynList.AddToTail( pRenderable );
	}

	bool HasRenderables() { return ( ( m_renderableList.Count() != 0 ) || ( m_dynList.Count() != 0 ) ); }

	CUtlVector< CStaticMeshRenderable* > &GetRenderableList() { return m_renderableList; }
	CUtlVector< CDynamicRenderable* > &GetDynamicList() { return m_dynList; }
private:
	RenderTargetBinding_t				m_hRenderTargetBinding;
	RenderViewport_t					m_viewport;
	RenderViewFlags_t					m_nFlags;
	int									m_nPass;
	int									m_nViewType;
	bool								m_bValid;

	IRenderDevice						*g_pRenderDevice;
	CWorldRenderFrustum					*m_pFrustum;
	CUtlVector< CStaticMeshRenderable* > m_renderableList;
	CUtlVector< CDynamicRenderable* >	m_dynList;
};

float RPercent()
{
	return float( rand() - (RAND_MAX/2) ) / (float)(RAND_MAX/2);
}

float RPercentABS()
{
	return float( rand() ) / (float)(RAND_MAX);
}

//-----------------------------------------------------------------------------
// Tests the world renderer
//-----------------------------------------------------------------------------
class CWorldRendererTest : public CRenderSystemBenchmarkTest
{
	typedef CRenderSystemBenchmarkTest BaseClass;

public:
	CWorldRendererTest( int nVariant );
	virtual	~CWorldRendererTest( void );
	virtual void RenderFrame( const RenderViewport_t &viewport, PlatWindow_t hWnd );
	virtual void RenderFrame_Internal( const RenderViewport_t &viewport );
	virtual void SimulateFrame( float flTimeStep );
	virtual void GetDescription( char *pNameBufferOut, size_t nBufLen );
	virtual bool ProcessUserInput( const InputEvent_t &ie );
	virtual bool CanBeRun();

	void RenderViewStatic( CRenderView *pRenderView, int nStart, int nCount, int nIndex );
	void RenderViewDynamic( CRenderView *pRenderView, int nStart, int nCount, int nIndex );
	void SetStateForRenderViewType( IRenderContext *pRenderContext, int nRenderView );
	ConstantBufferHandle_t GetViewRelated() { return m_hViewRelated; }
	ConstantBufferHandle_t GetLightBufferRelated() { return m_hLightBufferData; }
	IResourceDictionary *GetResourceDictionary() { return m_pResourceDictionary; }
	RsDepthStencilStateHandle_t GetSetStencilDS() { return m_hSetStencilDS; }
	LightBufferData_t *GetLightBufferData() { return &m_lightBufferData; }

private:
	void SetupMultiShadowMatrices( int nViewportStart, int nSqrtNumShadows, float flBias );
	void SetupShadowMatrices();
	void CullRenderablesAgainstView( CRenderView &renderView, CUtlVector<CStaticMeshRenderable> &renderableList, CUtlVector<CDynamicRenderable> &dynList );
	void RenderView( CRenderView &renderView );
	void UpdateShadowData();
	void UpdateFlashlightData();
	void UpdateViewModelData();
	void UpdateDroppedRenderables( float flElapsedTime );
	void GenerateRenderables( Vector &vCameraPos );
	void GeneratePointLightRenderables( IBVHNode *pNode, Vector &vOrigin, CFrustum *pFrustum, Vector &vEye );
	void GenerateSpotLightRenderables( IBVHNode *pNode, Vector &vOrigin, CFrustum *pFrustum, Vector &vEye );
	void GenerateHemiLightRenderables( IBVHNode *pNode, Vector &vOrigin, CFrustum *pFrustum, Vector &vEye );

	void BilateralUpsample();
	void RenderSSAO();
	void ScaleDepthAndNormalBuffers();
	void RenderAerialPerspective();
	void RenderSky();

	void RenderShadowDepthBuffers( IRenderContext *pRenderContext );
	void RenderSunShadowFrustums( IRenderContext *pRenderContext );
	void RenderBouncedLight( IRenderContext *pRenderContext );
	void RenderDirectLight( IRenderContext *pRenderContext );
	void BlurLightBuffer( );
	void BlurShadowBuffers( );

	void RenderDecals( IRenderContext *pRenderContext, int nVariation );
	void RenderDynamic( IRenderContext *pRenderContext, CDynamicRenderable *pRenderable, int nVariation, bool bSunDepth, bool bSetStencil );
	void RenderParticleLights( IRenderContext *pRenderContext, CParticleCollection *pParticles, int nVariation, bool bSunDepth, bool bSetStencil );
	void RenderScenePointLights( IRenderContext *pRenderContext, CUtlVector<CPointLightRenderable> &lightVector, bool bInterior );
	void RenderSceneHemiLights( IRenderContext *pRenderContext, CUtlVector<CHemiLightRenderable> &lightVector, bool bInterior );
	void RenderSceneSpotLights( IRenderContext *pRenderContext, CUtlVector<CSpotLightRenderable> &lightVector, bool bInterior );
	void RenderShadowedSpotLights( IRenderContext *pRenderContext, CUtlVector<CSpotLightRenderable> &lightVector );
	void SimulateParticles( float flTimeStep );
	void CalculateEyeRays( float flFarPlane );
	void InitDeferredData( const RenderViewport_t &viewport );
	void InitParticleData();
	void InitRenderableData();
	void UpdateFrustum( int nWidth, int nHeight );
	void AddDecal( IRenderContext *pRenderContext, Vector &vHit, Vector &vDecalDir, float flDecalSizeU, float flDecalSizeV, float flDecalShift, float flDecalInfluenceLength, bool bPaint );
	void AddWallMonster( IRenderContext *pRenderContext, Vector &vHit, Vector &vDecalDir, float flDecalSizeU, float flDecalSizeV, float flDecalShift, float flDecalInfluenceLength );
	void DropRenderable();
	void CreateSphere( int nTessellation );
	void CreateHemi( int nTessellationRes );
	void CreateCone( int nTessellation );
	void RenderScreenQuad( IRenderContext *pRenderContext, Vector *pEyeRays, const char *pDebugName );
	RenderShaderHandle_t GetVertexShader( char *pShaderName, IRenderDevice *pDevice, const char *pShaderVersion, const char *pDefineText = NULL );
	RenderShaderHandle_t GetPixelShader( char *pShaderName, IRenderDevice *pDevice, const char *pShaderVersion, const char *pDefineText = NULL );
	HRenderTexture CreateRenderTarget( RenderTargetType_t type, const RenderViewport_t &viewport );
	RenderTargetBinding_t CreateRenderTargetBinding( ViewBindingType_t type, const RenderViewport_t &viewport );
	void InitRenderTargetsAndViews( const RenderViewport_t &viewport );

	CWorldRenderFrustum *m_pFrustum;
	CWorldRenderFrustum *m_pDropFrustum;
	Vector m_vCullPos;
	usercmd_t m_cmd;

	HRenderTextureStrong m_pRenderTargets[ MAX_RENDER_TARGET_TYPES ];
	RenderTargetBinding_t m_pViewBindings[ MAX_VIEW_BINDING_TYPES ];
	CRenderView m_pRenderViews[ MAX_VIEW_BINDING_TYPES ];
	int m_nRenderThreads;
	RenderJob_t *m_pRenderJobs;

	// Resources
	ConstantBufferHandle_t m_hViewRelated;
	ConstantBufferHandle_t m_hSingleMatrixRelated;
	ConstantBufferHandle_t m_hLightingRelated;
	ConstantBufferHandle_t m_hDeferredLightingRelated;
	ConstantBufferHandle_t m_hLightBufferData;
	ConstantBufferHandle_t m_hDecalScreenData;
	ConstantBufferHandle_t m_hBlurParams;
	ConstantBufferHandle_t m_hSphereSampleData;

	CWorldRenderFrustum *m_pSplitFrustums[ NUM_SHADOW_SPLITS ];
	VMatrix m_pShadowMatrices[ NUM_SHADOW_SPLITS ];
	CWorldRenderFrustum *m_pMultiShadowFrustums[ NUM_MULTI_SHADOWS ];
	VMatrix m_pMultiShadowMatrices[ NUM_MULTI_SHADOWS ];

	LightingConstants_t m_forwardLightingData;
	DeferredLightingConstants_t m_deferredLightingData;
	BlurParams_t m_blurParams;
	LightBufferData_t m_lightBufferData;
	AerialPerspectiveConstants_t m_aerialPerspectiveData;
	SampleSphereData_t m_sphereSampleData;
	float m_flSampleRadius;

	// Render list and renderable lists
	CUtlVector<IBVHNode*> m_renderList;
	CUtlVector<CStaticMeshRenderable> m_renderableList;
	CUtlVector<CDynamicRenderable> m_dynRenderableList;
	CUtlVector<CPointLightRenderable> m_exteriorPointLights;
	CUtlVector<CPointLightRenderable> m_interiorPointLights;
	CUtlVector<CSpotLightRenderable> m_exteriorSpotLights;
	CUtlVector<CSpotLightRenderable> m_interiorSpotLights;
	CUtlVector<CHemiLightRenderable> m_exteriorHemiLights;
	CUtlVector<CHemiLightRenderable> m_interiorHemiLights;
	CUtlVector<CSpotLightRenderable> m_shadowedSpotLights;
	SpotLightData_t m_flashlight;
	float m_flMaxLightEncompassingFarPlane;

	bool m_bEnableVis;
	bool m_bDropFrustum;
	bool m_bSSAO;
	bool m_bBlurLighting;
	bool m_bBlurShadows;
	bool m_bDrawAerialPerspective;
	bool m_bDrawBouncedLight;
	bool m_bDrawDirectLight;
	bool m_bLightingOnly;
	bool m_bFlashlight;
	bool m_bViewLowTexture;

	// Deferred resources
	bool m_bMultiThreaded;
	bool m_bDeferred;
	bool m_bDeferredInit;
	bool m_bRenderTargetsInit;
	
	RenderTargetType_t m_nViewBuffer;

	float m_flLowResBufferScale;

	RenderShaderHandle_t m_hCopyTexture[4];
	RenderShaderHandle_t m_hBilateralBlur[4];
	RenderShaderHandle_t m_hShadowBlur[4];

	RenderInputLayout_t	m_hQuadLayout;
	Vector m_vEyeRays[4];
	Vector m_vEyeLocalRays[4];

	int m_nRandTextureSize;
	HRenderTextureStrong m_hFlashlightCookie[2];
	HRenderTextureStrong m_hRandomTexture;
	RenderShaderHandle_t m_hSSAOPS;
	RenderShaderHandle_t m_hAerialPerspectivePS[2];
	ConstantBufferHandle_t m_hAerialPerspectivePSCB;
	RsBlendStateHandle_t m_hExtinctionBS;
	RsBlendStateHandle_t m_hInscatteringBS;
	RsBlendStateHandle_t m_hAdditiveBS;
	RsBlendStateHandle_t m_hWriteAlphaBS;
	RsBlendStateHandle_t m_hWriteAllBS;
	RsDepthStencilStateHandle_t m_hSetStencilDS;
	RsDepthStencilStateHandle_t m_hZWriteNoTestDS;

	RenderShaderHandle_t m_hShadowFrustumVS[3];
	RenderShaderHandle_t m_hShadowFrustumPS[3];

	int m_nSphereIndices;
	int m_nHemiIndices;
	int m_nConeIndices;
	HRenderBufferStrong m_hSphereVB;
	HRenderBufferStrong m_hSphereIB;
	HRenderBufferStrong m_hHemiVB;
	HRenderBufferStrong m_hHemiIB;
	HRenderBufferStrong m_hConeVB;
	HRenderBufferStrong m_hConeIB;

	RenderShaderHandle_t m_hSceneLightVS[3];
	RenderShaderHandle_t m_hSceneLightPS[6];
	RenderInputLayout_t m_hSceneLightLayout[3];

	// Sky
	RenderInputLayout_t m_hSphereLayout;
	RenderShaderHandle_t m_hSkyVS;
	RenderShaderHandle_t m_hSkyPS;
	ConstantBufferHandle_t m_hSkyVSCB;
	ConstantBufferHandle_t m_hSkyPSCB;
	SkyPSCB_t m_skyData;
	Vector4D m_vRenderLightColor;
	bool m_bRenderSky;
	RsDepthStencilStateHandle_t m_hZTestAndStencilTestDS;
	RsDepthStencilStateHandle_t m_hStencilTestDS;

	// Decals
	RenderInputLayout_t m_hDecalLayout;
	HRenderBufferStrong m_hDecalVB;
	HRenderBufferStrong m_hDecalVB2;
	HRenderBufferStrong m_hDecalVB3;
	HRenderBufferStrong m_hDecalIB;
	RenderShaderHandle_t m_hDecalVS[2];
	RenderShaderHandle_t m_hDecalPS[2];
	HRenderTextureStrong m_hDecalAlbedo;
	HRenderTextureStrong m_hDecalAlbedo2;
	HRenderTextureStrong m_hDecalNormal;
	HRenderTextureStrong m_hDecalNormal2;
	HRenderTextureStrong m_hDecalNormal3[3];
	DecalScreenData_t m_decalScreenData;
	DecalScreenData_t m_lowResScreenData;
	DecalScreenData_t m_shadowScreenData;
	DecalVertex_t *m_pDecalBackingStore;
	DecalVertex_t *m_pDecalBackingStore2;
	int	m_nMaxDecals;
	bool m_bFullBuffer;
	bool m_bFullBuffer2;
	int m_nGlobalDecalPos;
	int m_nGlobalDecalPos2;
	int m_nGlobalDecalPos3;
	Vector m_vPreviousMonsterNormal;
	int m_nWallMonsterTexture;
	float m_flWallMonsterTimer;
	int m_nNumTriangles;

	// Particles
	CUtlVector<CParticleCollection*> m_lightSystemList;
	CUtlVector<CParticleCollection*> m_sphereSystemList;
	CUtlVector<SimulateWorkUnitWorldRender_t> m_particleWorkUnits;
	RenderInputLayout_t	m_hPointLightLayout;
	RenderShaderHandle_t m_hPointLightVS[5];
	RenderShaderHandle_t m_hPointLightPS[5];

	// Renderable test
	RenderShaderHandle_t m_hSimpleMeshVS[4];
	RenderShaderHandle_t m_hSimpleMeshPS[4];

	Vector m_vLightDir;
	Vector2D m_vLightAngleElevation;
	float m_flLightAngSpeed;
	float m_flLightElvSpeed;
	int m_nShadowSplits;
	RenderViewport_t m_shadowViewport;
	RenderViewport_t m_multiShadowViewport[ NUM_MULTI_SHADOWS ];
	VMatrix m_splitScaleBiasMatrices[ NUM_SHADOW_SPLITS ];
	VMatrix m_multiShadowScaleBiasMatrices[ NUM_MULTI_SHADOWS ];
	int m_nCurrentFrameNumber;
	int m_nShadowSize;
	int m_nLastFrustumWidth;
	int m_nLastFrustumHeight;
	int m_nWindowCenterX;
	int m_nWindowCenterY;
	int m_nCursorDeltaX;
	int m_nCursorDeltaY;
	int m_nCursorDeltaResetX;
	int m_nCursorDeltaResetY;
	int m_nReportLevel;
	float m_flDecalCountdown;
	float m_flParticleCountdown;

	float m_flNearPlane;
	float m_flFarPlane;

	// WorldRenderer
	IWorldRendererMgr *m_pWorldRendererMgr;
	IWorldRenderer *m_pWorldRenderer;
	IResourceDictionary *m_pResourceDictionary;
	bool m_bWorldLoaded;
};

DECLARE_TEST( CWorldRendererTest );

static void PerformStaticMeshWorkUnit( RenderJob_t & job )
{
	job.m_pTestApp->RenderViewStatic( job.m_pRenderView, job.m_nStartStatic, job.m_nCountStatic, job.m_nIndex );
	job.m_pTestApp->RenderViewDynamic( job.m_pRenderView, job.m_nStartDynamic, job.m_nCountDynamic, job.m_nIndex );
}

static int g_pBoxIndices[36] = { 2,1,0,3,2,0, 6,5,1,2,6,1, 7,4,5,6,7,5, 3,0,4,7,3,4, 6,2,3,7,6,3, 1,5,4,0,1,4 };

//-----------------------------------------------------------------------------
// Constructor, destructor
//-----------------------------------------------------------------------------
CWorldRendererTest::CWorldRendererTest( int nVariant ) : BaseClass( nVariant )
{
	if ( !g_pWorldRendererMgr )
		return;

	g_pWorldRendererTest = this;

	// Disable HW instancing on GL for now
	if ( g_nPlatform == RST_PLATFORM_GL )
		g_pWorldRendererMgr->SetHWInstancingEnabled( false );

	CRenderContextPtr pRenderContext( g_pRenderDevice );

	m_flDecalCountdown = 0.0f;
	m_flParticleCountdown = 0.0f;

	if ( IsPlatformX360() )
	{
		m_nShadowSize = 512;
	}
	else
	{
		m_nShadowSize = 1024;
	}

	m_shadowViewport.Init( 0, 0, m_nShadowSize, m_nShadowSize, 0, 1 );

	SetupShadowMatrices();

	m_nViewBuffer = RT_LIGHTING_HIGHRES;

	m_nRenderThreads = g_pThreadPool->NumThreads();
	m_pRenderJobs = new RenderJob_t[ m_nRenderThreads ];

	m_nCurrentFrameNumber = 0;
	m_hViewRelated = g_pRenderDevice->CreateConstantBuffer( sizeof( ViewRelatedConstants_t ) );
	m_hSingleMatrixRelated = g_pRenderDevice->CreateConstantBuffer( sizeof( VMatrix ) );
	m_hLightingRelated = g_pRenderDevice->CreateConstantBuffer( sizeof( LightingConstants_t ) );
	m_hSkyVSCB = g_pRenderDevice->CreateConstantBuffer( sizeof( SkyVSCB_t ) );
	m_hSkyPSCB = g_pRenderDevice->CreateConstantBuffer( sizeof( SkyPSCB_t ) );

	//m_flLowResBufferScale = 0.5f;
	m_flLowResBufferScale = 0.5f;
	m_bEnableVis = true;
	m_bDropFrustum = false;
	m_bSSAO = true;
	m_bBlurLighting = false;
	m_bBlurShadows = true;
	m_bDrawAerialPerspective = true;
	m_bDrawBouncedLight = true;
	m_bDrawDirectLight = true;
	m_bLightingOnly = false;
	m_bFlashlight = false;
	m_bViewLowTexture = false;

	// Deferred
	m_bDeferred = true;
	m_bDeferredInit = false;
	m_bRenderTargetsInit = false;
	m_bMultiThreaded = true;

	// No deferred on GL yet
	if ( g_nPlatform == RST_PLATFORM_GL || g_nPlatform == RST_PLATFORM_X360 )
		m_bDeferred = false;

	m_bWorldLoaded = true;
	// Create a world renderer
	m_pWorldRenderer = g_pWorldRendererMgr->CreateWorldRenderer();

	// Load the world
	const char *pWorldName = CommandLine()->ParmValue( "-map", "maps/ep2_outland_10" );
	if ( !m_pWorldRenderer->Unserialize( pWorldName ) )
	{
		Error( "Cannot load world!\n" );
		m_bWorldLoaded = false;
		return;	   
	}

	m_pResourceDictionary = m_pWorldRenderer->GetResourceDictionary();

	// Initialization
	static const uint64 sMegabyte = 1024 * 1024;
	uint64 nMaxGPUMemory = 768 * sMegabyte;
	uint64 nMaxSysMemory = 512 * sMegabyte;

	if ( IsPlatformX360() )
	{
		// Set this low until texture eviction works on the 360
		nMaxGPUMemory = 256 * sMegabyte;
		nMaxSysMemory = 32 * sMegabyte;
	}
	m_pWorldRenderer->Initialize( g_pRenderDevice, nMaxGPUMemory, nMaxSysMemory );

	// Alloc split frustums
	for ( int s=0; s<NUM_SHADOW_SPLITS; ++s )
	{
		m_pSplitFrustums[s] = (CWorldRenderFrustum*)MemAlloc_AllocAligned( sizeof( CWorldRenderFrustum ), 16 );
	}

	// Alloc multi-shadow frustums
	for ( int s=0; s<NUM_MULTI_SHADOWS; ++s )
	{
		m_pMultiShadowFrustums[s] = (CWorldRenderFrustum*)MemAlloc_AllocAligned( sizeof( CWorldRenderFrustum ), 16 );
	}

	// Build up a frustum
	m_pFrustum = (CWorldRenderFrustum*)MemAlloc_AllocAligned( sizeof( CWorldRenderFrustum ), 16 );
	m_pDropFrustum = (CWorldRenderFrustum*)MemAlloc_AllocAligned( sizeof( CWorldRenderFrustum ), 16 );

	m_nLastFrustumWidth = 1024;
	m_nLastFrustumHeight = 768;
	float flFOVY = 90.0f;
	float flAspect = m_nLastFrustumWidth / (float)m_nLastFrustumHeight;

	// Find the player start
	Vector vEyePos( 0, 0, 0 );
	QAngle vAngles( -64, 90, 0 );

	CUtlVector< KeyValues* > playerstarts;
	m_pWorldRenderer->GetEntities( "info_player_start", playerstarts );
	if ( playerstarts.Count() )
	{
		const char *pEye = playerstarts[0]->GetString( "origin" );
		const char *pAngles = playerstarts[0]->GetString( "angles" );

		sscanf( pEye, "%f %f %f", &vEyePos.x, &vEyePos.y, &vEyePos.z );
		sscanf( pAngles, "%f %f %f", &vAngles.x, &vAngles.y, &vAngles.z );
		vEyePos.z += 64;
	}

	// eyepos, eyeangles, znear, zfar, fov, aspect ratio
	m_flNearPlane = 10.0f;
	m_flFarPlane = 18000.0f;
	m_pFrustum->InitCamera( vEyePos, vAngles, m_flNearPlane, m_flFarPlane, CalcFovX(flFOVY, flAspect), flAspect );
	m_pFrustum->UpdateFrustumFromCamera();

	// parallel spit shadow maps
	m_vLightAngleElevation.x = 120.0f;
	m_vLightAngleElevation.y = 70.0f;
	m_vLightDir = Vector(0,0,1);
	Q_memset( &m_skyData, 0, sizeof( SkyPSCB_t ) );
	m_vRenderLightColor = Vector4D(1,1,1,1);
	m_flLightAngSpeed = 20.0f;
	m_flLightElvSpeed = 20.0f;

	m_nShadowSplits = NUM_SHADOW_SPLITS;

	const char *pVertexShaderVersion = g_pRenderDevice->GetShaderVersionString( RENDER_VERTEX_SHADER );
  	const char *pPixelShaderVersion = g_pRenderDevice->GetShaderVersionString( RENDER_PIXEL_SHADER );

	// sphere and cone primitives
	CreateSphere( 10 );
	CreateHemi( 10 );
	CreateCone( 10 );

	if ( m_bDeferred )
	{
		// Decals
		m_nMaxDecals = 2000;
		m_bFullBuffer = false;
		m_nGlobalDecalPos = 0;
		m_bFullBuffer2 = false;
		m_nGlobalDecalPos2 = 0;
		m_nGlobalDecalPos3 = 0;
		m_vPreviousMonsterNormal.Init( 0, 0, 1 );
		m_nWallMonsterTexture = 0;
		m_flWallMonsterTimer = 0.0f;

		static RenderInputLayoutField_t decalLayout[] =
		{
			DEFINE_PER_VERTEX_FIELD( 0, "position", 0, DecalVertex_t, m_vPos )
			DEFINE_PER_VERTEX_FIELD( 0, "texcoord",	0, DecalVertex_t, m_vDecalOrigin )
			DEFINE_PER_VERTEX_FIELD( 0, "texcoord",	1, DecalVertex_t, m_vDecalRight )
			DEFINE_PER_VERTEX_FIELD( 0, "texcoord", 2, DecalVertex_t, m_vDecalUpAndInfluence )
		};

		m_hDecalLayout = g_pRenderDevice->CreateInputLayout( "decallayout", ARRAYSIZE( decalLayout ), decalLayout );

		BufferDesc_t decalDesc;
		decalDesc.m_nElementCount = m_nMaxDecals * 8;
		decalDesc.m_nElementSizeInBytes = sizeof( DecalVertex_t );
		decalDesc.m_pBudgetGroupName = "decals";
		decalDesc.m_pDebugName = "decalVB";
		m_hDecalVB = g_pRenderDevice->CreateVertexBuffer( RENDER_BUFFER_TYPE_SEMISTATIC, decalDesc );
		decalDesc.m_pDebugName = "decalVB2";
		m_hDecalVB2 = g_pRenderDevice->CreateVertexBuffer( RENDER_BUFFER_TYPE_SEMISTATIC, decalDesc );
		decalDesc.m_nElementCount = 8;
		decalDesc.m_pDebugName = "decalVB3";
		m_hDecalVB3 = g_pRenderDevice->CreateVertexBuffer( RENDER_BUFFER_TYPE_SEMISTATIC, decalDesc );
		
		decalDesc.m_nElementCount = m_nMaxDecals * 36;
		decalDesc.m_nElementSizeInBytes = sizeof( uint16 );
		decalDesc.m_pDebugName = "decalIB";
		m_hDecalIB = g_pRenderDevice->CreateIndexBuffer( RENDER_BUFFER_TYPE_STATIC, decalDesc );

		LockDesc_t lockDesc;
		pRenderContext->LockIndexBuffer( m_hDecalIB, m_nMaxDecals * 36 * sizeof( uint16 ), &lockDesc );
		uint16 *pIndices = (uint16*)lockDesc.m_pMemory;
		
		int nOffset = 0;
		for ( int d=0; d<m_nMaxDecals; ++d )
		{
			for ( int i=0; i<36; ++i )
			{
				pIndices[i] = g_pBoxIndices[i] + nOffset;
			}
			nOffset += 8;
			pIndices += 36;
		}
		pRenderContext->UnlockIndexBuffer( m_hDecalIB, m_nMaxDecals * 36 * sizeof( uint16 ), &lockDesc );

		m_hDecalVS[0] = GetVertexShader( "maps/decalsvs", g_pRenderDevice, pVertexShaderVersion, "#define SHADER_VARIATION 0\n" );
		m_hDecalPS[0] = GetPixelShader( "maps/decalsps", g_pRenderDevice, pPixelShaderVersion, "#define SHADER_VARIATION 0\n" );
		m_hDecalVS[1] = GetVertexShader( "maps/decalsvs", g_pRenderDevice, pVertexShaderVersion, "#define SHADER_VARIATION 1\n" );
		m_hDecalPS[1] = GetPixelShader( "maps/decalsps", g_pRenderDevice, pPixelShaderVersion, "#define SHADER_VARIATION 1\n" );

		m_hDecalScreenData = g_pRenderDevice->CreateConstantBuffer( sizeof( DecalScreenData_t ) );

		m_hDecalAlbedo = RENDER_TEXTURE_HANDLE_INVALID;//g_pRenderDevice->FindOrCreateFileTexture( "maps/decaltest_albedo.vtf" );
		//m_hDecalNormal = g_pRenderDevice->FindOrCreateFileTexture( "maps/decaltest_normal.vtf" );
		m_hDecalNormal = g_pRenderDevice->FindOrCreateFileTexture( "materials/plastercrack.vtf" );
		m_hDecalAlbedo2 = g_pRenderDevice->FindOrCreateFileTexture( "materials/paintdecal.vtf" );
		m_hDecalNormal2 = g_pRenderDevice->FindOrCreateFileTexture( "materials/paintdecalnorm.vtf" );
		m_hDecalNormal3[0] = g_pRenderDevice->FindOrCreateFileTexture( "materials/gearhead1.vtf" );
		m_hDecalNormal3[1] = g_pRenderDevice->FindOrCreateFileTexture( "materials/gearhead2.vtf" );
		m_hDecalNormal3[2] = g_pRenderDevice->FindOrCreateFileTexture( "materials/gearhead3.vtf" );

		m_pDecalBackingStore = new DecalVertex_t[ m_nMaxDecals * 8 ];
		m_pDecalBackingStore2 = new DecalVertex_t[ m_nMaxDecals * 8 ];
	}

	m_bRenderSky = true;
	if ( m_bRenderSky )
	{
		// Load shaders
		m_hSkyVS = GetVertexShader( "maps/skyvs", g_pRenderDevice, pVertexShaderVersion );
		m_hSkyPS = GetPixelShader( "maps/skyps", g_pRenderDevice, pPixelShaderVersion );
	}

	if ( m_bDeferred )
	{
		// particle system
		InitParticleData();
	}

	InitRenderableData();

	// Input
	Q_memset( &m_cmd, 0, sizeof( usercmd_t ) );
	m_nWindowCenterX = -1;
	m_nWindowCenterY = -1;
	m_nCursorDeltaX = 0;
	m_nCursorDeltaY = 0;
	m_nCursorDeltaResetX = 0;
	m_nCursorDeltaResetY = 0;
	m_nReportLevel = 0;

	g_pInputStackSystem->SetCursorVisible( GetInputContext(), false );
}


CWorldRendererTest::~CWorldRendererTest( void )
{
	if ( !g_pWorldRendererMgr )
		return;

	g_pInputStackSystem->SetCursorVisible( GetInputContext(), true );

	g_pRenderDevice->DestroyConstantBuffer( m_hViewRelated );
	g_pRenderDevice->DestroyConstantBuffer( m_hLightingRelated );

	m_pWorldRenderer->DestroyResources( g_pRenderDevice );
	g_pWorldRendererMgr->DestroyWorldRenderer( m_pWorldRenderer );

	m_dynRenderableList.RemoveAll();

	for ( int s=0; s<NUM_SHADOW_SPLITS; ++s )
	{
		MemAlloc_FreeAligned( m_pSplitFrustums[s] );
	}
	for ( int s=0; s<NUM_MULTI_SHADOWS; ++s )
	{
		MemAlloc_FreeAligned( m_pMultiShadowFrustums[s] );
	}

	MemAlloc_FreeAligned( m_pFrustum );
}


class CUniformSampler
{
private:
	Vector*			m_pvDirections;
	int				m_NumSamples;
	int				m_NumVariations;

public:
	CUniformSampler() :
	  m_pvDirections( NULL ),
	  m_NumSamples( 0 ),
	  m_NumVariations( 0 )
	  {
	  }
	~CUniformSampler()
	{
		if ( m_pvDirections ) { delete []m_pvDirections; };
	}

	int GetNumVariations() { return m_NumVariations; }
	int GetNumSamples() { return m_NumSamples; }
	bool InitSamples( int SqrtNumSamples, int NumVariations );
	Vector GetSampleDirection( int Sample, int Variation );
};


bool CUniformSampler::InitSamples( int SqrtNumSamples, int NumVariations )
{
	m_NumSamples = SqrtNumSamples * SqrtNumSamples;
	m_NumVariations = NumVariations;

	m_pvDirections = new Vector[ m_NumSamples * m_NumVariations ];
	if ( !m_pvDirections )
		return false;
#if 1
	int i=0; // array index
	float oneoverN = 1.0f/(float)SqrtNumSamples;

	for ( int n=0; n<m_NumVariations; n++ )
	{
		// fill an N*N*2 array with uniformly distributed
		// samples across the sphere using jittered stratification
		for ( int a=0; a<SqrtNumSamples; a++ ) 
		{
			for ( int b=0; b<SqrtNumSamples; b++ ) 
			{
				// generate unbiased distribution of spherical coords
				float x = ( a + fabs( RPercent() ) ) * oneoverN; // do not reuse results
				float y = ( b + fabs( RPercent() ) ) * oneoverN; // each sample must be random
				float theta = 2.0f * acosf(sqrtf(1.0f - x));
				float phi = 2.0f * M_PI * y;

				// convert spherical coords to unit vector
				Vector vec(sinf(theta)*cosf(phi), sinf(theta)*sinf(phi), cosf(theta));
				m_pvDirections[i] = vec;

				++i;
			}
		}
	}
#else
	int i=0;
	for ( int n=0; n<m_NumVariations; n++ )
	{
		// fill an N*N*2 array with uniformly distributed
		// samples across the sphere using jittered stratification
		for ( int a=0; a<SqrtNumSamples * SqrtNumSamples; a++ ) 
		{	
			m_pvDirections[i].x = RPercent();
			m_pvDirections[i].y = RPercent();
			m_pvDirections[i].z = RPercent();
			m_pvDirections[i].NormalizeInPlace();
			i++;
		}
	}
#endif
	return true;
}

Vector CUniformSampler::GetSampleDirection( int Sample, int Variation )
{
	int Start = m_NumSamples * Variation;
	return m_pvDirections[ Start + Sample ];
}

void CWorldRendererTest::InitDeferredData( const RenderViewport_t &viewport )
{
	CRenderContextPtr pRenderContext( g_pRenderDevice );

	static RenderInputLayoutField_t quadLayout[] =
	{
		DEFINE_PER_VERTEX_FIELD( 0, "position", 0, QuadVertex_t, m_vPos )
		DEFINE_PER_VERTEX_FIELD( 0, "texcoord", 0, QuadVertex_t, m_vEyeRay )
	};
	m_hQuadLayout = g_pRenderDevice->CreateInputLayout( "quadlayout", ARRAYSIZE( quadLayout ), quadLayout );

	// Constants
	m_hDeferredLightingRelated = g_pRenderDevice->CreateConstantBuffer( sizeof( DeferredLightingConstants_t ) );
	m_hLightBufferData = g_pRenderDevice->CreateConstantBuffer( sizeof( LightBufferData_t ) );

	const char *pVertexShaderVersion = g_pRenderDevice->GetShaderVersionString( RENDER_VERTEX_SHADER );
	const char *pPixelShaderVersion = g_pRenderDevice->GetShaderVersionString( RENDER_PIXEL_SHADER );

	// Shaders for low-res buffers
	//float flBlurFalloff = 0.0005f;
	float flBlurFalloff = 0.005f;
	float flSharpness = 1000.0f;
	m_blurParams.m_flBlurFalloff.Init( flBlurFalloff, flBlurFalloff, flBlurFalloff, flBlurFalloff );
	m_blurParams.m_flSharpness.Init( flSharpness, flSharpness, flSharpness, flSharpness );
	m_blurParams.m_flFarPlane.Init( 1, 1, 1, 1 );
	m_hBlurParams = g_pRenderDevice->CreateConstantBuffer( sizeof( BlurParams_t ) );
	m_hCopyTexture[0] = GetPixelShader( "maps/copytextureps", g_pRenderDevice, pPixelShaderVersion, "#define SINGLE_TARGET 0\n#define COPY_TARGET_W 0\n#define COMBINE_LIGHTING 0\n" );
	m_hCopyTexture[1] = GetPixelShader( "maps/copytextureps", g_pRenderDevice, pPixelShaderVersion, "#define SINGLE_TARGET 1\n#define COPY_TARGET_W 0\n#define COMBINE_LIGHTING 0\n" );
	m_hCopyTexture[2] = GetPixelShader( "maps/copytextureps", g_pRenderDevice, pPixelShaderVersion, "#define SINGLE_TARGET 1\n#define COPY_TARGET_W 1\n#define COMBINE_LIGHTING 0\n" );
	m_hCopyTexture[3] = GetPixelShader( "maps/copytextureps", g_pRenderDevice, pPixelShaderVersion, "#define SINGLE_TARGET 1\n#define COPY_TARGET_W 0\n#define COMBINE_LIGHTING 1\n" );
	m_hBilateralBlur[0] = GetPixelShader( "maps/bilateralblur", g_pRenderDevice, pPixelShaderVersion, "#define BILAT_BLUR 1\n#define HORZ_BLUR 1\n#define BLUR_RADIUS 8\n"  );
	m_hBilateralBlur[1] = GetPixelShader( "maps/bilateralblur", g_pRenderDevice, pPixelShaderVersion, "#define BILAT_BLUR 1\n#define HORZ_BLUR 0\n#define BLUR_RADIUS 8\n"  );
	m_hBilateralBlur[2] = GetPixelShader( "maps/bilateralblur", g_pRenderDevice, pPixelShaderVersion, "#define BILAT_BLUR 1\n#define HORZ_BLUR_FULL 1\n#define BLUR_RADIUS 6\n"  );
	m_hBilateralBlur[3] = GetPixelShader( "maps/bilateralblur", g_pRenderDevice, pPixelShaderVersion, "#define BILAT_BLUR 1\n#define HORZ_BLUR 0\n#define BLUR_RADIUS 6\n"  );

	m_hShadowBlur[0] = GetPixelShader( "maps/bilateralblur", g_pRenderDevice, pPixelShaderVersion, "#define BILAT_BLUR 0\n#define HORZ_BLUR_FULL 1\n#define BLUR_RADIUS 3\n"  );
	m_hShadowBlur[1] = GetPixelShader( "maps/bilateralblur", g_pRenderDevice, pPixelShaderVersion, "#define BILAT_BLUR 0\n#define HORZ_BLUR 0\n#define BLUR_RADIUS 3\n"  );
	m_hShadowBlur[2] = GetPixelShader( "maps/bilateralblur", g_pRenderDevice, pPixelShaderVersion, "#define BILAT_BLUR 0\n#define HORZ_BLUR_FULL 1\n#define BLUR_RADIUS 2\n"  );
	m_hShadowBlur[3] = GetPixelShader( "maps/bilateralblur", g_pRenderDevice, pPixelShaderVersion, "#define BILAT_BLUR 0\n#define HORZ_BLUR 0\n#define BLUR_RADIUS 2\n"  );

	// Shaders for deferred ligthing
	m_hShadowFrustumVS[0] = GetVertexShader( "maps/shadowfrustumvs", g_pRenderDevice, pVertexShaderVersion, "#define DISCARD_OUTSIDE 1\n#define ALL_FRUSTUMS 0\n"  );
	m_hShadowFrustumPS[0] = GetPixelShader( "maps/shadowfrustumps", g_pRenderDevice, pPixelShaderVersion, "#define DISCARD_OUTSIDE 1\n#define ALL_FRUSTUMS 0\n"  );
	m_hShadowFrustumVS[1] = GetVertexShader( "maps/shadowfrustumvs", g_pRenderDevice, pVertexShaderVersion, "#define ALL_FRUSTUMS 0\n" );
	m_hShadowFrustumPS[1] = GetPixelShader( "maps/shadowfrustumps", g_pRenderDevice, pPixelShaderVersion, "#define ALL_FRUSTUMS 0\n" );
	m_hShadowFrustumVS[2] = GetVertexShader( "maps/shadowfrustumvs", g_pRenderDevice, pVertexShaderVersion, "#define ALL_FRUSTUMS 1\n"  );
	m_hShadowFrustumPS[2] = GetPixelShader( "maps/shadowfrustumps", g_pRenderDevice, pPixelShaderVersion, "#define ALL_FRUSTUMS 1\n"  );

	// Scene light shaders
	m_hSceneLightVS[0] = GetVertexShader( "maps/scenelightvs", g_pRenderDevice, pVertexShaderVersion, "#define LIGHT_TYPE 0\n"  );
	m_hSceneLightVS[1] = GetVertexShader( "maps/scenelightvs", g_pRenderDevice, pVertexShaderVersion, "#define LIGHT_TYPE 1\n"  );
	m_hSceneLightVS[2] = GetVertexShader( "maps/scenelightvs", g_pRenderDevice, pVertexShaderVersion, "#define LIGHT_TYPE 2\n"  );

	m_hSceneLightPS[0] = GetPixelShader( "maps/scenelightps", g_pRenderDevice, pPixelShaderVersion,   "#define LIGHT_TYPE 0\n#define LIGHT_SHADOWED 0\n"  );
	m_hSceneLightPS[1] = GetPixelShader( "maps/scenelightps", g_pRenderDevice, pPixelShaderVersion,   "#define LIGHT_TYPE 1\n#define LIGHT_SHADOWED 0\n"  );
	m_hSceneLightPS[2] = GetPixelShader( "maps/scenelightps", g_pRenderDevice, pPixelShaderVersion,   "#define LIGHT_TYPE 2\n#define LIGHT_SHADOWED 0\n"  );
	m_hSceneLightPS[3] = GetPixelShader( "maps/scenelightps", g_pRenderDevice, pPixelShaderVersion,   "#define LIGHT_TYPE 0\n#define LIGHT_SHADOWED 1\n"  );
	m_hSceneLightPS[4] = GetPixelShader( "maps/scenelightps", g_pRenderDevice, pPixelShaderVersion,   "#define LIGHT_TYPE 1\n#define LIGHT_SHADOWED 1\n"  );
	m_hSceneLightPS[5] = GetPixelShader( "maps/scenelightps", g_pRenderDevice, pPixelShaderVersion,   "#define LIGHT_TYPE 2\n#define LIGHT_SHADOWED 1\n"  );

	static RenderInputLayoutField_t pointLightLayout[] =
	{
		DEFINE_PER_VERTEX_FIELD( 0, "position", 0, SphereVertex_t, m_vPos )
		DEFINE_PER_INSTANCE_FIELD( 1, 1, "texcoord", 0, PointLightData_t, m_vOrigin )
		DEFINE_PER_INSTANCE_FIELD( 1, 1, "texcoord", 1, PointLightData_t, m_vColorNRadius )
		DEFINE_PER_INSTANCE_FIELD( 1, 1, "texcoord", 2, PointLightData_t, m_vAttenuation )
	};
	static RenderInputLayoutField_t hemiLightLayout[] =
	{
		DEFINE_PER_VERTEX_FIELD( 0, "position", 0, SphereVertex_t, m_vPos )
		DEFINE_PER_INSTANCE_FIELD( 1, 1, "texcoord", 0, HemiLightData_t, m_vTransform0 )
		DEFINE_PER_INSTANCE_FIELD( 1, 1, "texcoord", 1, HemiLightData_t, m_vTransform1 )
		DEFINE_PER_INSTANCE_FIELD( 1, 1, "texcoord", 2, HemiLightData_t, m_vTransform2 )
		DEFINE_PER_INSTANCE_FIELD( 1, 1, "texcoord", 3, HemiLightData_t, m_vColorNRadius )
		DEFINE_PER_INSTANCE_FIELD( 1, 1, "texcoord", 4, HemiLightData_t, m_vAttenuation )
	};
	static RenderInputLayoutField_t spotLightLayout[] =
	{
		DEFINE_PER_VERTEX_FIELD( 0, "position", 0, SphereVertex_t, m_vPos )
		DEFINE_PER_INSTANCE_FIELD( 1, 1, "texcoord", 0, SpotLightData_t, m_vTransform0 )
		DEFINE_PER_INSTANCE_FIELD( 1, 1, "texcoord", 1, SpotLightData_t, m_vTransform1 )
		DEFINE_PER_INSTANCE_FIELD( 1, 1, "texcoord", 2, SpotLightData_t, m_vTransform2 )
		DEFINE_PER_INSTANCE_FIELD( 1, 1, "texcoord", 3, SpotLightData_t, m_vColorNRadius )
		DEFINE_PER_INSTANCE_FIELD( 1, 1, "texcoord", 4, SpotLightData_t, m_vAttenuationNCosSpot )
	};

	m_hSceneLightLayout[0] = g_pRenderDevice->CreateInputLayout( "scenelight_point", ARRAYSIZE( pointLightLayout ), pointLightLayout );
	m_hSceneLightLayout[1] = g_pRenderDevice->CreateInputLayout( "scenelight_hemi", ARRAYSIZE( hemiLightLayout ), hemiLightLayout );
	m_hSceneLightLayout[2] = g_pRenderDevice->CreateInputLayout( "scenelight_spot", ARRAYSIZE( spotLightLayout ), spotLightLayout );

	m_hFlashlightCookie[0] = g_pRenderDevice->FindOrCreateFileTexture( "materials/flashlight4.vtf" );
	m_hFlashlightCookie[1] = g_pRenderDevice->FindOrCreateFileTexture( "materials/flashlight16.vtf" );

	// SSAO
	m_hSSAOPS = GetPixelShader( "maps/ssao", g_pRenderDevice, pPixelShaderVersion );

	CUniformSampler ssaoSampler;
	ssaoSampler.InitSamples( (int)sqrtf( (float)NUM_SSAO_SAMPLES ), 1 );

	m_hSphereSampleData = g_pRenderDevice->CreateConstantBuffer( sizeof( SampleSphereData_t ) );
	m_flSampleRadius = 16.0f;
	m_sphereSampleData.m_vRandSampleScale.Init( 1, 1, 1, 1 );
	m_sphereSampleData.m_vSampleRadiusNBias.Init( m_flSampleRadius, m_flSampleRadius, m_flSampleRadius, m_flSampleRadius );
	for ( int s=0; s<NUM_SSAO_SAMPLES; ++s )
	{
		Vector vSample = ssaoSampler.GetSampleDirection( s, 0 );
		//vSample *= 0.2f + 0.8f * RPercentABS();
		vSample *= RPercentABS();
		m_sphereSampleData.m_vSphereSamples[s].Init( vSample.x, vSample.y, vSample.z, 1 );
	}
	pRenderContext->SetConstantBufferData( m_hSphereSampleData, &m_sphereSampleData, sizeof( SampleSphereData_t ) );

#if 1
	// random texture
	m_nRandTextureSize = 4;
	CUniformSampler randTexSampler;
	randTexSampler.InitSamples( m_nRandTextureSize, 1 );

	TextureHeader_t randSpec;
	memset( &randSpec, 0, sizeof(TextureHeader_t) );
	randSpec.m_nWidth = m_nRandTextureSize;
	randSpec.m_nHeight = m_nRandTextureSize;
	randSpec.m_nNumMipLevels = 1;
	randSpec.m_nDepth = 1;
	randSpec.m_nFlags = TSPEC_UNFILTERABLE_OK;
	randSpec.m_nImageFormat = IMAGE_FORMAT_BGRA8888;
	if ( g_nPlatform == RST_PLATFORM_DX11 )
	{
		randSpec.m_nImageFormat = IMAGE_FORMAT_RGBA8888;
	}
	m_hRandomTexture = g_pRenderDevice->FindOrCreateTexture( "worldrenderertest", "randomtexture", &randSpec );
	
	int nTotalRands = randSpec.m_nWidth * randSpec.m_nHeight;
	uint8 *pRandBits = new uint8[ nTotalRands * 4 ];
	for ( int r=0; r<nTotalRands; ++r )
	{
		Vector vRandVector = randTexSampler.GetSampleDirection( r, 0 );

		pRandBits[ r * 4     ] = (uint8)( ( vRandVector.z * 128.0f ) + 127 );
		pRandBits[ r * 4 + 1 ] = (uint8)( ( vRandVector.y * 128.0f ) + 127 );
		pRandBits[ r * 4 + 2 ] = (uint8)( ( vRandVector.x * 128.0f ) + 127 );
		pRandBits[ r * 4 + 3 ] = 0;
	}

	pRenderContext->SetTextureData( m_hRandomTexture, &randSpec, pRandBits, nTotalRands * 4, false );
	delete []pRandBits;
#else
	// random texture
	m_nRandTextureSize = 32;
	m_hRandomTexture = g_pRenderDevice->FindOrCreateFileTexture( "materials/SSAOReflectionVectors.vtf" );
#endif

	// Aerial perspective
	m_hAerialPerspectivePS[0] = GetPixelShader( "maps/aerialperspectiveps", g_pRenderDevice, pPixelShaderVersion, "#define SHADER_VARIATION 0\n" );
	m_hAerialPerspectivePS[1] = GetPixelShader( "maps/aerialperspectiveps", g_pRenderDevice, pPixelShaderVersion, "#define SHADER_VARIATION 1\n" );
	m_hAerialPerspectivePSCB = g_pRenderDevice->CreateConstantBuffer( sizeof( AerialPerspectiveConstants_t ) );

	// states for aerial perspective
	RsBlendStateDesc_t bd;
	memset( &bd, 0, sizeof( bd ) );
	bd.m_bAlphaToCoverageEnable = false;
	bd.m_bIndependentBlendEnable = false;
	for ( int i=0; i<4; ++i )
	{
		bd.m_bBlendEnable[i] = true;
		bd.m_srcBlend[i] = RS_BLEND_MODE_ZERO;
		bd.m_destBlend[i] = RS_BLEND_MODE_SRC_COLOR;
		bd.m_blendOp[i] = RS_BLEND_OP_ADD;
		bd.m_nRenderTargetWriteMask[i] = RS_COLOR_WRITE_ENABLE_R | RS_COLOR_WRITE_ENABLE_G | RS_COLOR_WRITE_ENABLE_B;
	}
	m_hExtinctionBS = pRenderContext->FindOrCreateBlendState( &bd );
	for ( int i=0; i<4; ++i )
	{
		bd.m_srcBlend[i] = RS_BLEND_MODE_ONE;
		bd.m_destBlend[i] = RS_BLEND_MODE_ONE;
	}
	m_hInscatteringBS = pRenderContext->FindOrCreateBlendState( &bd );

	m_hAdditiveBS = pRenderContext->FindOrCreateBlendState( &bd );

	for ( int i=0; i<4; ++i )
	{
		bd.m_bBlendEnable[i] = false;
		bd.m_srcBlend[i] = RS_BLEND_MODE_ZERO;
		bd.m_destBlend[i] = RS_BLEND_MODE_SRC_COLOR;
		bd.m_blendOp[i] = RS_BLEND_OP_ADD;
		bd.m_nRenderTargetWriteMask[i] = RS_COLOR_WRITE_ENABLE_A;
	}
	m_hWriteAlphaBS = pRenderContext->FindOrCreateBlendState( &bd );

	for ( int i=0; i<4; ++i )
	{
		bd.m_bBlendEnable[i] = false;
		bd.m_srcBlend[i] = RS_BLEND_MODE_ZERO;
		bd.m_destBlend[i] = RS_BLEND_MODE_SRC_COLOR;
		bd.m_blendOp[i] = RS_BLEND_OP_ADD;
		bd.m_nRenderTargetWriteMask[i] = RS_COLOR_WRITE_ENABLE_ALL;
	}
	m_hWriteAllBS = pRenderContext->FindOrCreateBlendState( &bd );

	RsDepthStencilStateDesc_t dsDesc;
	dsDesc.m_bDepthTestEnable = true;
	dsDesc.m_bDepthWriteEnable = false;
	dsDesc.m_depthFunc = RS_CMP_LESS_EQUAL;
	dsDesc.m_hiZEnable360 = RS_HI_Z_AUTOMATIC;
	dsDesc.m_hiZWriteEnable360 = RS_HI_Z_AUTOMATIC;

	dsDesc.m_bStencilEnable = true;
	dsDesc.m_nStencilReadMask = 0xFF;
	dsDesc.m_nStencilWriteMask = 0xFF;

	dsDesc.m_frontStencilFailOp = RS_STENCIL_OP_KEEP;
	dsDesc.m_frontStencilDepthFailOp = RS_STENCIL_OP_KEEP;
	dsDesc.m_frontStencilPassOp = RS_STENCIL_OP_KEEP;
	dsDesc.m_frontStencilFunc = RS_CMP_EQUAL;

	dsDesc.m_backStencilFailOp = RS_STENCIL_OP_KEEP;
	dsDesc.m_backStencilDepthFailOp = RS_STENCIL_OP_KEEP;
	dsDesc.m_backStencilPassOp = RS_STENCIL_OP_KEEP;
	dsDesc.m_backStencilFunc = RS_CMP_EQUAL;

	dsDesc.m_bHiStencilEnable360 = false;
	dsDesc.m_bHiStencilWriteEnable360 = false;
	dsDesc.m_hiStencilFunc360 = RS_HI_STENCIL_CMP_EQUAL;
	dsDesc.m_nHiStencilRef360 = 0;

	m_hZTestAndStencilTestDS = pRenderContext->FindOrCreateDepthStencilState( &dsDesc );

	dsDesc.m_bDepthTestEnable = false;
	dsDesc.m_bDepthWriteEnable = false;
	m_hStencilTestDS = pRenderContext->FindOrCreateDepthStencilState( &dsDesc );

	dsDesc.m_bDepthTestEnable = true;
	dsDesc.m_bDepthWriteEnable = true;

	dsDesc.m_frontStencilFailOp = RS_STENCIL_OP_KEEP;
	dsDesc.m_frontStencilDepthFailOp = RS_STENCIL_OP_KEEP;
	dsDesc.m_frontStencilPassOp = RS_STENCIL_OP_REPLACE;
	dsDesc.m_frontStencilFunc = RS_CMP_ALWAYS;

	dsDesc.m_backStencilFailOp = RS_STENCIL_OP_KEEP;
	dsDesc.m_backStencilDepthFailOp = RS_STENCIL_OP_KEEP;
	dsDesc.m_backStencilPassOp = RS_STENCIL_OP_REPLACE;
	dsDesc.m_backStencilFunc = RS_CMP_ALWAYS;

	m_hSetStencilDS = pRenderContext->FindOrCreateDepthStencilState( &dsDesc );

	//
	dsDesc.m_bDepthTestEnable = true;
	dsDesc.m_bDepthWriteEnable = true;
	dsDesc.m_depthFunc = RS_CMP_ALWAYS;
	dsDesc.m_hiZEnable360 = RS_HI_Z_AUTOMATIC;
	dsDesc.m_hiZWriteEnable360 = RS_HI_Z_AUTOMATIC;

	dsDesc.m_bStencilEnable = false;
	dsDesc.m_nStencilReadMask = 0xFF;
	dsDesc.m_nStencilWriteMask = 0xFF;

	dsDesc.m_frontStencilFailOp = RS_STENCIL_OP_KEEP;
	dsDesc.m_frontStencilDepthFailOp = RS_STENCIL_OP_KEEP;
	dsDesc.m_frontStencilPassOp = RS_STENCIL_OP_KEEP;
	dsDesc.m_frontStencilFunc = RS_CMP_EQUAL;

	dsDesc.m_backStencilFailOp = RS_STENCIL_OP_KEEP;
	dsDesc.m_backStencilDepthFailOp = RS_STENCIL_OP_KEEP;
	dsDesc.m_backStencilPassOp = RS_STENCIL_OP_KEEP;
	dsDesc.m_backStencilFunc = RS_CMP_EQUAL;

	dsDesc.m_bHiStencilEnable360 = false;
	dsDesc.m_bHiStencilWriteEnable360 = false;

	m_hZWriteNoTestDS = pRenderContext->FindOrCreateDepthStencilState( &dsDesc );

	m_bDeferredInit = true;
}

void CWorldRendererTest::InitParticleData()
{
	CRenderContextPtr pRenderContext( g_pRenderDevice );

	struct ParticleVertex_t
	{
		Vector	m_vPos;
	};

	static RenderInputLayoutField_t pointLightLayout[] =
	{
		DEFINE_PER_VERTEX_FIELD( 0, "position", 0, ParticleVertex_t, m_vPos )
		DEFINE_PER_INSTANCE_FIELD( 1, 1, "texcoord", 0, PerParticleData_t, m_vPosRadius )
		DEFINE_PER_INSTANCE_FIELD( 1, 1, "texcoord", 1, PerParticleData_t, m_vColor )
	};
	m_hPointLightLayout = g_pRenderDevice->CreateInputLayout( "pointlight", ARRAYSIZE( pointLightLayout ), pointLightLayout );

	const char *pVertexShaderVersion = g_pRenderDevice->GetShaderVersionString( RENDER_VERTEX_SHADER);
	const char *pPixelShaderVersion = g_pRenderDevice->GetShaderVersionString( RENDER_PIXEL_SHADER );
	for ( int i=0; i<5; ++i )
	{
		char pBuffer[100];
		Q_snprintf( pBuffer, 100, "#define SHADER_VARIATION %d\n", i );
		m_hPointLightVS[i] = GetVertexShader( "maps/pointlightvs", g_pRenderDevice, pVertexShaderVersion, pBuffer );
		m_hPointLightPS[i] = GetPixelShader( "maps/pointlightps", g_pRenderDevice, pPixelShaderVersion, pBuffer );
	}
}

void CWorldRendererTest::InitRenderableData()
{
	CRenderContextPtr pRenderContext( g_pRenderDevice );

	// Load the simple shaders for dynamic renderables
	const char *pVertexShaderVersion = g_pRenderDevice->GetShaderVersionString( RENDER_VERTEX_SHADER);
	const char *pPixelShaderVersion = g_pRenderDevice->GetShaderVersionString( RENDER_PIXEL_SHADER );
	for ( int i=0; i<4; ++i )
	{
		char pBuffer[100];
		Q_snprintf( pBuffer, 100, "#define SHADER_VARIATION %d\n#define g_flPhongExp 10\n#define g_flPhongBoost 1.5\n", i );
		m_hSimpleMeshVS[i] = GetVertexShader( "maps/meshsimplevs", g_pRenderDevice, pVertexShaderVersion, pBuffer );
		m_hSimpleMeshPS[i] = GetPixelShader( "maps/meshsimpleps", g_pRenderDevice, pPixelShaderVersion, pBuffer );
	}

	// Load the minigun
	HRenderable hRenderable = g_pMeshSystem->FindOrCreateFileRenderable( g_pRenderableList[ 0 ] );
	int index = m_dynRenderableList.AddToTail();

	m_dynRenderableList[ index ].m_hRenderable = hRenderable;
	m_dynRenderableList[ index ].m_vOrigin.Init( 0, 0, 0 );
	m_dynRenderableList[ index ].m_mWorld.Identity();
}

void CWorldRendererTest::UpdateFrustum( int nWidth, int nHeight )
{
	// Build up a frustum
	if ( nWidth == m_nLastFrustumWidth && nHeight == m_nLastFrustumHeight )
		return;

	m_nLastFrustumWidth = nWidth;
	m_nLastFrustumHeight = nHeight;

	float flAspect = nWidth / (float)nHeight;
	m_pFrustum->SetAspect( flAspect );
	m_pFrustum->SetFOV( CalcFovX(90.0f, flAspect) );
	m_pFrustum->UpdateFrustumFromCamera();
}

void CWorldRendererTest::RenderScreenQuad( IRenderContext *pRenderContext, Vector *pEyeRays, const char *pDebugName )
{
	CDynamicVertexData<QuadVertex_t> vb( pRenderContext, 4, pDebugName, "screenquad" );
	vb.Lock( );
	vb->m_vPos = Vector( -1, -1, 0.5f );
	vb->m_vEyeRay = pEyeRays[0];
	vb.AdvanceVertex();

	vb->m_vPos = Vector( 1, -1, 0.5f );
	vb->m_vEyeRay = pEyeRays[1];
	vb.AdvanceVertex();

	vb->m_vPos = Vector( -1, 1, 0.5f );
	vb->m_vEyeRay = pEyeRays[2];
	vb.AdvanceVertex();

	vb->m_vPos = Vector( 1, 1, 0.5f );
	vb->m_vEyeRay = pEyeRays[3];
	vb.AdvanceVertex();
	
	vb.Unlock();
	vb.Bind( 0, 0 );

	pRenderContext->Draw( RENDER_PRIM_TRIANGLE_STRIP, 0, 4 );
}

void CWorldRendererTest::RenderFrame( const RenderViewport_t &viewport, PlatWindow_t hWnd )
{
	if ( !m_bRenderTargetsInit )
	{
		InitRenderTargetsAndViews( viewport );
	}

	if ( !m_bDeferredInit )
	{
		InitDeferredData( viewport );
	}

	if ( m_nReportLevel == 1 )
	{
		g_VProfCurrentProfile.Reset();
		g_VProfCurrentProfile.ResetPeaks();
		g_VProfCurrentProfile.Start();
		m_nReportLevel++;
		Msg("VPROF Trace Begin\n");
	}

	RenderFrame_Internal( viewport );

	if ( m_nReportLevel == 3 )
	{
		g_VProfCurrentProfile.Stop();
		g_VProfCurrentProfile.OutputReport( VPRT_FULL & ~VPRT_HIERARCHY, NULL );
		Msg("VPROF Trace Complete\n");
		m_nReportLevel = 0;
	}
	else if ( m_nReportLevel )
	{
		g_VProfCurrentProfile.MarkFrame();
	}
}

void CWorldRendererTest::CullRenderablesAgainstView( CRenderView &renderView, CUtlVector<CStaticMeshRenderable> &renderableList, CUtlVector<CDynamicRenderable> &dynList )
{
	if ( !renderView.IsValid() )
		return;

	RenderViewFlags_t nFlags = renderView.GetViewFlags();
	if ( !( nFlags & ( VIEW_PLAYER_CAMERA | VIEW_LIGHT_SHADOW | VIEW_REFLECTION ) ) )
		return;

	if ( nFlags & ( VIEW_POST_PROCESS | VIEW_LIGHTING | VIEW_DECALS ) )
		return;

	CWorldRenderFrustum *pFrustum = renderView.GetFrustum();
	if( !pFrustum )
		return;

	if ( m_bDropFrustum && pFrustum == m_pFrustum )
		pFrustum = m_pDropFrustum;

	// Static
	int nRenderables = renderableList.Count();
	for ( int r=0; r<nRenderables; ++r )
	{
		CStaticMeshRenderable &renderable = renderableList[ r ];
		
		IBVHNode *pNode = renderable.m_pNode;
		Vector vOriginShift = pNode->GetOrigin().m_vLocal;
		CBVHDrawCall *pDraw = renderable.m_pDrawCall;

		if ( pDraw->m_Flags & DRAW_CULL )
		{
			if ( !pFrustum->BoundingVolumeIntersectsFrustum( pDraw->m_Bounds, vOriginShift ) )
			{
				continue;
			}
		}

		// Add a renderable
		renderView.AddStaticMeshRenderable( &renderable );
	}

	// Dynamic
	nRenderables = dynList.Count();
	for ( int r=0; r<nRenderables; ++r )
	{
		CDynamicRenderable &renderable = dynList[ r ];
		
		if ( !g_pMeshSystem->RenderableIntersectsFrustum( renderable.m_hRenderable, pFrustum, -renderable.m_vOrigin ) )
			continue;

		// Add a renderable
		renderView.AddDynamicRenderable( &renderable );
	}
}

void CWorldRendererTest::SetupMultiShadowMatrices( int nViewportStart, int nSqrtNumShadows, float flBias )
{
	int nGutterSize = 4;
	if ( nViewportStart > 0 )
		nGutterSize = 2;

	float flScale = ( 0.5f / nSqrtNumShadows ) - ( nGutterSize / (float)m_nShadowSize );
	int nMultiShadowSize = m_nShadowSize / nSqrtNumShadows;
	int nTop = 0;
	int nViewport = nViewportStart;

	float frange   = 1.0f;
	if ( IsPlatformX360() )
	{
		frange   = -1.0f;
		flBias    = flBias * frange;
	}

	for ( int t=0; t<nSqrtNumShadows; ++t )
	{
		int nLeft = 0;
		for( int s=0; s<nSqrtNumShadows; ++s )
		{
			int nGutteredLeft = nLeft + nGutterSize;
			int nGutteredTop = nTop + nGutterSize;
			int nGutteredMultiShadowedSize = nMultiShadowSize - nGutterSize * 2;
			m_multiShadowViewport[ nViewport ].Init( nGutteredLeft, nGutteredTop, nGutteredMultiShadowedSize, nGutteredMultiShadowedSize, 0, 1.0f );

			float fBiasVal = flBias;
			if ( IsPlatformX360() )
			{
				fBiasVal = 1.0f - flBias;
			}

			float flShiftX = flScale + ( nGutteredLeft + 0.5f ) / m_nShadowSize;
			float flShiftY = flScale + ( nGutteredTop + 0.5f ) / m_nShadowSize;

			VMatrix texScaleBiasMat( flScale,	0.0f,		0.0f,		0.0f,
									 0.0f,		-flScale,	0.0f,		0.0f,
									 0.0f,		0.0f,		frange,		0.0f,
									 flShiftX,	flShiftY,	fBiasVal,	1.0f );

			m_multiShadowScaleBiasMatrices[ nViewport ] = texScaleBiasMat;

			nViewport++;
			nLeft += nMultiShadowSize;
		}
		nTop += nMultiShadowSize;
	}
}

void CWorldRendererTest::SetupShadowMatrices()
{
	// Multiple shadow viewports
	float fOffsetX = 0.5f + (0.5f / (float)m_nShadowSize);
	float fOffsetY = 0.5f + (0.5f / (float)m_nShadowSize);
	float frange   = 1.0f;
	float fBias    = -0.001f * frange;
	if ( IsPlatformX360() )
	{
		frange   = -1.0f;
		fBias    = 0.005f * frange;
	}

	for ( int s=0; s<NUM_SHADOW_SPLITS; ++s )
	{		
		//set special texture matrix for shadow mapping
		float fBiasVal = fBias;
		if ( IsPlatformX360() )
		{
			fBiasVal = 1.0f - fBias;
		}

		VMatrix texScaleBiasMat( 0.5f,     0.0f,     0.0f,      0.0f,
								 0.0f,    -0.5f,     0.0f,      0.0f,
								 0.0f,     0.0f,     frange,	0.0f,
								 fOffsetX, fOffsetY, fBiasVal,	1.0f );
		m_splitScaleBiasMatrices[ s ] = texScaleBiasMat;

		fBias *= 1.5f;
	}

	SetupMultiShadowMatrices( 0, SQRT_NUM_HIGH_RES_SHADOWS, -0.001f );
	if ( SQRT_NUM_LOW_RES_SHADOWS )
	{
		SetupMultiShadowMatrices( NUM_HIGH_RES_SHADOWS, SQRT_NUM_LOW_RES_SHADOWS, -0.003f );
	}
}

int SortSpotLights( const CSpotLightRenderable *pOne, const CSpotLightRenderable *pTwo )
{
	if ( pOne->m_flSquaredDistToEye < pTwo->m_flSquaredDistToEye )
		return -1;
	else if ( pOne->m_flSquaredDistToEye > pTwo->m_flSquaredDistToEye )
		return 1;
	return 0;
}

void CWorldRendererTest::GenerateRenderables( Vector &vCameraPos )
{
	// Figure out where we are and if we're interior or not
	int nLeafNode = m_pWorldRenderer->GetLeafNodeForPoint( vCameraPos );
	bool bCanSeeSky = true;
	if ( nLeafNode != -1 )
	{
		IBVHNode *pNode = m_pWorldRenderer->GetNode( nLeafNode );
		int nFlags = pNode->GetFlags();
		bCanSeeSky = ( nFlags & NODE_CAN_SEE_SKY ) != 0;
	}

	// Clear renderables
	m_renderList.SetCountNonDestructively( 0 );
	m_renderableList.SetCountNonDestructively( 0 );
	m_interiorPointLights.SetCountNonDestructively( 0 );
	m_exteriorPointLights.SetCountNonDestructively( 0 );
	m_interiorSpotLights.SetCountNonDestructively( 0 );
	m_exteriorSpotLights.SetCountNonDestructively( 0 );
	m_interiorHemiLights.SetCountNonDestructively( 0 );
	m_exteriorHemiLights.SetCountNonDestructively( 0 );
	m_shadowedSpotLights.SetCountNonDestructively( 0 );

	// Clear far plane
	m_flMaxLightEncompassingFarPlane = 0.0f;

	// Build the render list for this view
	BVHNodeFlags_t nSkipFlags = (BVHNodeFlags_t)0x0;
	if ( bCanSeeSky == false )
		nSkipFlags = NODE_CAN_SEE_SKY;

	float flLODScale =  1.0f;
	if ( IsPlatformX360() )
	{
		flLODScale = 0.5f;
	}
	float flElapsedTime = 0.0f;
	m_pWorldRenderer->BuildRenderList( &m_renderList, nSkipFlags, vCameraPos, flLODScale, m_pFrustum->GetFarPlane(), flElapsedTime, m_nCurrentFrameNumber );

	// Distance sort render traversals
	m_pWorldRenderer->SortRenderList( &m_renderList, vCameraPos );

	//Create node requests and dispatch them to the async filesystem
	// This can cause eviction of resources.
	m_pWorldRenderer->CreateAndDispatchLoadRequests( g_pRenderDevice, m_pFrustum->GetCameraPosition() );

	// Create renderables from each draw call encountered
	int nNodes = m_renderList.Count();
	for ( int n=0; n<nNodes; ++n )
	{
		IBVHNode *pNode = m_renderList[ n ];
		Vector vOriginShift = pNode->GetOrigin().m_vLocal;

		// Gross cull of the bounds before turning them into renderables
		AABB_t bounds = pNode->GetBounds();
		if ( !m_pFrustum->BoundingVolumeIntersectsFrustum( bounds, vOriginShift ) )
			continue;

		// Draw calls
		int nDraws = pNode->GetNumDrawCalls();
		for ( int d=0; d<nDraws; ++d )
		{
			CBVHDrawCall &draw = pNode->GetDrawCall( d );

			CStaticMeshRenderable renderable;
			renderable.m_pNode = pNode;
			renderable.m_pDrawCall = &draw;
			m_renderableList.AddToTail( renderable );	
		}

		// Point Lights
		GeneratePointLightRenderables( pNode, vOriginShift, m_pFrustum, vCameraPos );

		// Spot lights
		GenerateSpotLightRenderables( pNode, vOriginShift, m_pFrustum, vCameraPos );

		// Hemi lights
		GenerateHemiLightRenderables( pNode, vOriginShift, m_pFrustum, vCameraPos );
	}

	if ( m_bFlashlight )
	{
		CSpotLightRenderable renderable;
		renderable.m_vOrigin.Init( 0, 0, 0 );
		renderable.m_pLight = &m_flashlight;
		renderable.m_bValid = true;
		renderable.m_flSquaredDistToEye = 0.0f;

		// We're outside the light
		renderable.m_bInterior = false;
		m_shadowedSpotLights.AddToTail( renderable );
	}

	// We've been storing squared distance, but we want linear distance
	m_flMaxLightEncompassingFarPlane = sqrtf( m_flMaxLightEncompassingFarPlane );

	// Sort spot lights and set the NUM_MULTI_SHADOWS closest as shadow casting
	m_shadowedSpotLights.Sort( SortSpotLights );
	
	/*
	// Artificially limit shadows past a certain point
	int nShadows = 0;
	for ( int s=0; s<m_shadowedSpotLights.Count(); ++s )
	{
		if ( m_shadowedSpotLights[ s ].m_flSquaredDistToEye > MAX_LIGHT_DISTANCE * MAX_LIGHT_DISTANCE )
		{
			break;
		}

		nShadows++;
	}*/
	int nShadows = m_shadowedSpotLights.Count();

	nShadows = MIN( nShadows, NUM_MULTI_SHADOWS );
	m_shadowedSpotLights.SetCountNonDestructively( nShadows );

	for ( int s=0; s<nShadows; ++s )
	{
		int index = m_exteriorSpotLights.Find( m_shadowedSpotLights[s] );
		if ( index != -1 )
		{
			m_exteriorSpotLights.FastRemove( index );
		}

		index = m_interiorSpotLights.Find( m_shadowedSpotLights[s] );
		if ( index != -1 )
		{
			m_interiorSpotLights.FastRemove( index );
		}
	}
}

void CWorldRendererTest::GeneratePointLightRenderables( IBVHNode *pNode, Vector &vOrigin, CFrustum *pFrustum, Vector &vEye )
{
	float flNearPlane = pFrustum->GetNearPlane();
	int nLights = pNode->GetNumPointLights();
	PointLightData_t *pPointLights = pNode->GetPointLights();

	for ( int i=0; i<nLights; ++i )
	{
		float flRadius = pPointLights[i].m_vColorNRadius.w;

		AABB_t bounds;
		Vector vLightOrigin = pPointLights[i].m_vOrigin;
		bounds.m_vMinBounds = vLightOrigin - Vector( flRadius, flRadius, flRadius );
		bounds.m_vMaxBounds = vLightOrigin + Vector( flRadius, flRadius, flRadius );

		if ( pFrustum->BoundingVolumeIntersectsFrustum( bounds, vOrigin ) )
		{
			CPointLightRenderable renderable;
			renderable.m_vOrigin = vOrigin;
			renderable.m_pLight = &pPointLights[i];

			Vector vNewOrigin = vLightOrigin - vOrigin;
			Vector vDelta = vEye - vNewOrigin;
			float flSquaredDist = DotProduct( vDelta, vDelta );
			float flTargetRad = flRadius * 1.2f + flNearPlane;
			if ( DotProduct( vDelta, vDelta ) < flTargetRad * flTargetRad )
			{
				// We're inside the light
				m_interiorPointLights.AddToTail( renderable );
			}
			else
			{
				// We're outside the light
				m_exteriorPointLights.AddToTail( renderable );
			}

			m_flMaxLightEncompassingFarPlane = MAX( m_flMaxLightEncompassingFarPlane, flSquaredDist + flTargetRad * flTargetRad );
		}
	}
}

void CWorldRendererTest::GenerateSpotLightRenderables( IBVHNode *pNode, Vector &vOrigin, CFrustum *pFrustum, Vector &vEye )
{
	float flNearPlane = pFrustum->GetNearPlane();
	Vector vForward = pFrustum->Forward();
	Vector vFarEye = vEye + flNearPlane * vForward * 1.2f;
	int nLights = pNode->GetNumSpotLights();
	SpotLightData_t *pSpotLights = pNode->GetSpotLights();

	for ( int i=0; i<nLights; ++i )
	{
		float flRadius = pSpotLights[i].m_vColorNRadius.w;
		float flTargetRad = flRadius * 1.2f + 500.0f + flNearPlane;
		Vector vLightOrigin = Vector( pSpotLights[i].m_vTransform0.w, pSpotLights[i].m_vTransform1.w, pSpotLights[i].m_vTransform2.w );

		AABB_t bounds;
		bounds.m_vMinBounds = vLightOrigin - Vector( flTargetRad, flTargetRad, flTargetRad );
		bounds.m_vMaxBounds = vLightOrigin + Vector( flTargetRad, flTargetRad, flTargetRad );

		if ( pFrustum->BoundingVolumeIntersectsFrustum( bounds, vOrigin ) )
		{
			CSpotLightRenderable renderable;
			renderable.m_vOrigin = vOrigin;
			renderable.m_pLight = &pSpotLights[i];
			renderable.m_bValid = true;

			Vector vNewOrigin = vLightOrigin - vOrigin;
			Vector vDelta = vEye - vNewOrigin;
			Vector vLightDir = Vector( pSpotLights[i].m_vTransform0.z, pSpotLights[i].m_vTransform1.z, pSpotLights[i].m_vTransform2.z );

			float flSquaredDist = DotProduct( vDelta, vDelta );
			renderable.m_flSquaredDistToEye = flSquaredDist;

			//if ( flRadius > 3000.0f )
			//	renderable.m_flSquaredDistToEye = FLT_MAX;

			Vector vToLightFar = vFarEye - vNewOrigin;
			Vector vToLightNear = vEye - vNewOrigin;
			vToLightFar.NormalizeInPlace();
			vToLightNear.NormalizeInPlace();
			float flDotFar = DotProduct( vToLightFar, vLightDir );
			float flDotNear = DotProduct( vToLightNear, vLightDir );
			float flCosAngle = pSpotLights[i].m_vAttenuationNCosSpot.w * 0.85f;

			bool bInCone = ( flDotFar > flCosAngle || flDotNear > flCosAngle );
			if ( flSquaredDist < flTargetRad * flTargetRad && bInCone )
			{
				// We're inside the light
				renderable.m_bInterior = true;
				m_interiorSpotLights.AddToTail( renderable );
			}
			else
			{
				// We're outside the light
				renderable.m_bInterior = false;
				m_exteriorSpotLights.AddToTail( renderable );
			}

			m_shadowedSpotLights.AddToTail( renderable );

			m_flMaxLightEncompassingFarPlane = MAX( m_flMaxLightEncompassingFarPlane, flSquaredDist + flTargetRad * flTargetRad + 4000 * 4000 );
		}
	}
}

void CWorldRendererTest::GenerateHemiLightRenderables( IBVHNode *pNode, Vector &vOrigin, CFrustum *pFrustum, Vector &vEye )
{
	float flNearPlane = pFrustum->GetNearPlane();
	Vector vForward = pFrustum->Forward();
	Vector vFarEye = vEye + flNearPlane * vForward * 1.1f;
	int nLights = pNode->GetNumHemiLights();
	HemiLightData_t *pHemiLights = pNode->GetHemiLights();

	for ( int i=0; i<nLights; ++i )
	{
		float flRadius = pHemiLights[i].m_vColorNRadius.w;
		Vector vLightOrigin = Vector( pHemiLights[i].m_vTransform0.w, pHemiLights[i].m_vTransform1.w, pHemiLights[i].m_vTransform2.w );
		AABB_t bounds;
		bounds.m_vMinBounds = vLightOrigin - Vector( flRadius, flRadius, flRadius );
		bounds.m_vMaxBounds = vLightOrigin + Vector( flRadius, flRadius, flRadius );

		if ( pFrustum->BoundingVolumeIntersectsFrustum( bounds, vOrigin ) )
		{
			CHemiLightRenderable renderable;
			renderable.m_vOrigin = vOrigin;
			renderable.m_pLight = &pHemiLights[i];

			Vector vNewOrigin = vLightOrigin - vOrigin;
			Vector vDelta = vEye - vNewOrigin;
			float flSquaredDist = DotProduct( vDelta, vDelta );
			Vector vLightDir = Vector( pHemiLights[i].m_vTransform0.z, pHemiLights[i].m_vTransform1.z, pHemiLights[i].m_vTransform2.z );
			float flTargetRad = flRadius * 1.2f + flNearPlane;

			Vector vToLightFar = vFarEye - vNewOrigin;
			Vector vToLightNear = vEye - vNewOrigin;
			vToLightFar.NormalizeInPlace();
			vToLightNear.NormalizeInPlace();
			float flDotFar = DotProduct( vToLightFar, vLightDir );
			float flDotNear = DotProduct( vToLightNear, vLightDir );
			float flCosAngle = 0.0f;

			bool bInHemi = ( flDotFar > flCosAngle || flDotNear > flCosAngle );
			if ( DotProduct( vDelta, vDelta ) < flTargetRad * flTargetRad && bInHemi )
			{
				// We're inside the light
				m_interiorHemiLights.AddToTail( renderable );
			}
			else
			{
				// We're outside the light
				m_exteriorHemiLights.AddToTail( renderable );
			}

			m_flMaxLightEncompassingFarPlane = MAX( m_flMaxLightEncompassingFarPlane, flSquaredDist + flTargetRad * flTargetRad );
		}
	}
}

void CWorldRendererTest::RenderViewStatic( CRenderView *pRenderView, int nStart, int nCount, int nIndex )
{
	CRenderContextPtr pRenderContext( g_pRenderDevice );
	pRenderView->BeginRender( pRenderContext );

	SetStateForRenderViewType( pRenderContext, pRenderView->GetViewType() );

	int nRenderPass = pRenderView->GetRenderPass();
	CWorldRenderFrustum *pFrustum = pRenderView->GetFrustum();
	CUtlVector< CStaticMeshRenderable* > &renderableList = pRenderView->GetRenderableList();

	// Set commonly used constants
	ViewRelatedConstants_t viewConstants = CreateViewConstantsForFrustum( pFrustum );

	if ( nRenderPass == VARIATION_SAMPLE_LIGHTING )
	{
		pRenderContext->SetConstantBufferData( m_hLightBufferData, (void*)&m_lightBufferData, sizeof( LightBufferData_t ) );
		pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hLightBufferData, 0, 0 );
	}

	if ( m_bViewLowTexture && nRenderPass == VARIATION_SAMPLE_LIGHTING )
	{
		nRenderPass = VARIATION_SAMPLE_LIGHTING_LOW_TEXTURE;
	}

	// Render the nodes
	Vector vLastOrigin = Vector(0,0,0);
	bool bFirst = true;
	bool bSunDepth = false;
	if ( nRenderPass == VARIATION_DEPTH && pRenderView->GetViewType() < RTB_SHADOW_DEPTH_MULTIPLE_0 )
		bSunDepth = true;
	bool bSetStencil = false;
	if ( nRenderPass == VARIATION_NORM_DEPTH_SPEC )
		bSetStencil = true;

	for ( int r=0; r<nCount; ++r )
	{
		CStaticMeshRenderable *pRenderable = renderableList[ nStart + r ];

		IBVHNode *pNode = pRenderable->m_pNode;
		AABB_t bounds = pNode->GetBounds();
		Vector vOrigin = pNode->GetOrigin().m_vLocal;
		int nFlags = pNode->GetFlags();
		bool bCanSeeSky = ( nFlags & NODE_CAN_SEE_SKY ) != 0;

		// Don't render depth for sun shadow maps if we can't see the sky
		if ( bSunDepth && !bCanSeeSky )
			continue;

		if ( ( vLastOrigin != vOrigin ) || bFirst )
		{
			VMatrix mViewRelated = viewConstants.m_mViewProjection;

			VMatrix mTrans;
			mTrans.Identity();
			mTrans.SetTranslation( -vOrigin );
			mViewRelated = mTrans.Transpose() * mViewRelated;

			ViewRelatedConstants_t newViewConstants = viewConstants;
			newViewConstants.m_mViewProjection = mViewRelated;
			newViewConstants.m_vEyePt.x += vOrigin.x;
			newViewConstants.m_vEyePt.y += vOrigin.y;
			newViewConstants.m_vEyePt.z += vOrigin.z;

			pRenderContext->SetConstantBufferData( m_hViewRelated, (void*)&newViewConstants, sizeof( ViewRelatedConstants_t ) );
			pRenderContext->BindConstantBuffer( RENDER_VERTEX_SHADER, m_hViewRelated, 0, 0 );
			
			vLastOrigin = vOrigin;
			bFirst = false;
		}

		if ( bSetStencil )
		{
			if ( bCanSeeSky )
			{
				pRenderContext->SetDepthStencilState( m_hSetStencilDS, g_nCanSeeSkyStencilRef );
			}
			else
			{
				pRenderContext->SetDepthStencilState( m_hSetStencilDS, g_nCannotSeeSkyStencilRef );
			}
		}

		pNode->Draw( pRenderContext, pRenderable->m_pDrawCall, m_pResourceDictionary, (ShaderComboVariation_t)nRenderPass, m_hSingleMatrixRelated );
	}

	pRenderView->EndRender( pRenderContext, false );
}


void CWorldRendererTest::RenderViewDynamic( CRenderView *pRenderView, int nStart, int nCount, int nIndex )
{
	CRenderContextPtr pRenderContext( g_pRenderDevice );
	pRenderView->BeginRender( pRenderContext );

	// Get view constants
	CWorldRenderFrustum *pFrustum = pRenderView->GetFrustum();
	ViewRelatedConstants_t viewConstants = CreateViewConstantsForFrustum( pFrustum );

	// Init material data
	RenderMaterialData_t &materialData = pRenderContext->GetMaterialData();
	materialData.Init();
	materialData.flTime = Plat_FloatTime();
	materialData.mVP = viewConstants.m_mViewProjection;
	materialData.mWVP = viewConstants.m_mViewProjection;
	materialData.vCameraPosition = viewConstants.m_vEyePt.AsVector3D();
	materialData.vCameraForwardVec = viewConstants.m_vEyeDir.AsVector3D().Normalized();
	materialData.flFarPlane = viewConstants.m_flFarPlane.x;
	materialData.vViewportSize[0] = 1.0f / m_lightBufferData.m_vInvScreenExtents.x;
	materialData.vViewportSize[1] = 1.0f / m_lightBufferData.m_vInvScreenExtents.y;

	materialData.customTextures[0] = m_pRenderTargets[ RT_LIGHTING_HIGHRES ];
	materialData.customTextures[1] = m_pRenderTargets[ RT_SPECULAR_HIGHRES ];

	int nRenderPass = pRenderView->GetRenderPass();
	if ( nRenderPass == VARIATION_DEPTH )
	{
		materialData.nMode = MODE_DEPTH;
	}
	else if ( nRenderPass == VARIATION_NORM_DEPTH_SPEC )
	{
		materialData.nMode = MODE_NORMAL_DEPTH_SPEC;
	}
	else if ( nRenderPass == VARIATION_SAMPLE_LIGHTING )
	{
		materialData.nMode = MODE_DEFERRED_GATHER;
	}
	else
	{
		materialData.nMode = MODE_FORWARD;
	}

	// Sun and stencil bools
	bool bSunDepth = false;
	if ( ( nRenderPass == VARIATION_DEPTH ) && ( pRenderView->GetViewType() < RTB_SHADOW_DEPTH_MULTIPLE_0 ) )
	{
		bSunDepth = true;
	}

	bool bSetStencil = false;
	if ( nRenderPass == VARIATION_NORM_DEPTH_SPEC )
	{
		bSetStencil = true;
	}

	// Render the nodes
	CUtlVector< CDynamicRenderable * > &renderableList = pRenderView->GetDynamicList();
	for ( int r = 0; r < nCount; r++ )
	{
		CDynamicRenderable *pRenderable = renderableList[ nStart + r ];

		// Copy world matrix into material data
		memcpy( materialData.mWorldArray[0], &( pRenderable->m_mWorld.m[0] ), sizeof( pRenderable->m_mWorld ) );

		RenderDynamic( pRenderContext, pRenderable, ( ShaderComboVariation_t )nRenderPass, bSunDepth, bSetStencil );
	}

	pRenderView->EndRender( pRenderContext, false );
}

void CWorldRendererTest::RenderView( CRenderView &renderView )
{
	if ( m_bMultiThreaded )
	{
		CUtlVector< CStaticMeshRenderable* > &renderableList = renderView.GetRenderableList();
		CUtlVector< CDynamicRenderable* > &dynList = renderView.GetDynamicList();
		int nRenderablesStatic = renderableList.Count();
		int nRenderablesDynamic = dynList.Count();
		int nCountStatic = nRenderablesStatic / m_nRenderThreads;
		int nCountDynamic = nRenderablesDynamic / m_nRenderThreads;
		int nTotalRenderablesStatic = 0;
		int nTotalRenderablesDynamic = 0;
		for ( int t=0; t<m_nRenderThreads; ++t )
		{
			m_pRenderJobs[ t ].m_pRenderView = &renderView;
			m_pRenderJobs[ t ].m_nStartStatic = nTotalRenderablesStatic;
			m_pRenderJobs[ t ].m_nCountStatic = nCountStatic;
			m_pRenderJobs[ t ].m_nStartDynamic = nTotalRenderablesDynamic;
			m_pRenderJobs[ t ].m_nCountDynamic = nCountDynamic;

			m_pRenderJobs[ t ].m_pTestApp = this;
			m_pRenderJobs[ t ].m_nIndex = t;
			nTotalRenderablesStatic += nCountStatic;
			nTotalRenderablesDynamic += nCountDynamic;
		}
		m_pRenderJobs[ m_nRenderThreads - 1 ].m_nCountStatic = nRenderablesStatic - m_pRenderJobs[ m_nRenderThreads - 1 ].m_nStartStatic;
		m_pRenderJobs[ m_nRenderThreads - 1 ].m_nCountDynamic = nRenderablesDynamic - m_pRenderJobs[ m_nRenderThreads - 1 ].m_nStartDynamic;

		ParallelProcess( m_pRenderJobs, m_nRenderThreads, PerformStaticMeshWorkUnit );
	}
	else
	{
		RenderViewStatic( &renderView, 0, renderView.GetRenderableList().Count(), 0 );
		RenderViewDynamic( &renderView, 0, renderView.GetDynamicList().Count(), 0 );
	}
}

void CWorldRendererTest::UpdateShadowData()
{
	for ( int s=0; s<m_nShadowSplits; ++s )
	{
		VMatrix mLightRelated;
		mLightRelated = m_pSplitFrustums[s]->GetViewProj();
		m_pShadowMatrices[s] = mLightRelated * m_splitScaleBiasMatrices[ s ];
		m_forwardLightingData.m_mShadowMatrices[s] = m_pShadowMatrices[s];
	}

	for ( int s=0; s<NUM_MULTI_SHADOWS; ++s )
	{
		m_pRenderViews[ RTB_SHADOW_DEPTH_MULTIPLE_0 + s ].SetValid( false );
	}

	for ( int s=0; s<m_shadowedSpotLights.Count(); ++s )
	{
		CSpotLightRenderable &renderable = m_shadowedSpotLights[s];
		
		Vector vOrigin = Vector( renderable.m_pLight->m_vTransform0.w, renderable.m_pLight->m_vTransform1.w, renderable.m_pLight->m_vTransform2.w );
		vOrigin -= renderable.m_vOrigin;
		Vector vDirection = Vector( renderable.m_pLight->m_vTransform0.z, renderable.m_pLight->m_vTransform1.z, renderable.m_pLight->m_vTransform2.z );
		Vector vUp = Vector( renderable.m_pLight->m_vTransform0.y, renderable.m_pLight->m_vTransform1.y, renderable.m_pLight->m_vTransform2.y );

		vDirection.NormalizeInPlace();
		vUp.NormalizeInPlace();
		QAngle vAngles;
		VectorAngles( vDirection, vUp, vAngles );

		float flRadius = renderable.m_pLight->m_vColorNRadius.w;
		float flFOV = RAD2DEG( acosf( renderable.m_pLight->m_vAttenuationNCosSpot.w ) * 2 );

		m_pMultiShadowFrustums[ s ]->InitCamera( vOrigin, vAngles, 20.0f, flRadius + 500.0f, flFOV, 1.0f );
		m_pMultiShadowFrustums[ s ]->UpdateFrustumFromCamera();

		VMatrix mLightRelated = m_pMultiShadowFrustums[ s ]->GetViewProj();
		m_pMultiShadowMatrices[ s ] = mLightRelated * m_multiShadowScaleBiasMatrices[ s ];

		m_pRenderViews[ RTB_SHADOW_DEPTH_MULTIPLE_0 + s ].SetValid( true );
	}
}

void CWorldRendererTest::UpdateFlashlightData()
{
	float flFlashlightLength = 1000.0f;
	float flSpotAngle = DEG2RAD( 45.0f );
	Vector vColor( 1,1,0.8f );
	vColor *= 100.0f;
	float flMax = 255.0f;

	Vector vAttenuation;
	vAttenuation.x = 0;
	vAttenuation.y = flMax / flFlashlightLength;
	vAttenuation.z = 0;
	float flTan45 = tanf( M_PI / 4.0f );
	float flScale = tanf( flSpotAngle ) / flTan45;

	Vector vOrigin = m_pFrustum->GetCameraPosition();
	Vector vDirection = m_pFrustum->Forward();
	Vector vLeft = m_pFrustum->Left();
	Vector vUp = m_pFrustum->Up();

	vOrigin -= vUp * 15.0f;
	vOrigin += vLeft * 25;

	Vector vRight = -vLeft;
	vRight *= flScale * flFlashlightLength;
	vUp *= flScale * flFlashlightLength;
	vDirection *= flFlashlightLength;

	m_flashlight.m_vTransform0.Init( vRight.x, vUp.x, vDirection.x, vOrigin.x );
	m_flashlight.m_vTransform1.Init( vRight.y, vUp.y, vDirection.y, vOrigin.y );
	m_flashlight.m_vTransform2.Init( vRight.z, vUp.z, vDirection.z, vOrigin.z );
	m_flashlight.m_vColorNRadius.Init( vColor.x, vColor.y, vColor.z, flFlashlightLength );
	m_flashlight.m_vAttenuationNCosSpot.Init( vAttenuation.x, vAttenuation.y, vAttenuation.z, cosf( flSpotAngle ) );
}

void CWorldRendererTest::UpdateViewModelData()
{
	if ( m_dynRenderableList.Count() < 1 )
		return;

	Vector vOrigin = m_pFrustum->GetCameraPosition();
	Vector vDirection = m_pFrustum->Forward();
	Vector vLeft = m_pFrustum->Left();
	Vector vUp = m_pFrustum->Up();

	vOrigin -= vUp * 15.0f;
	vOrigin -= vLeft * 25;
	vOrigin += vDirection * 30;

	VMatrix mWorld;
	mWorld.Identity();
	mWorld.SetForward( vDirection * 0.6f );
	mWorld.SetLeft( vLeft );
	mWorld.SetUp( vUp );

	VMatrix mRot;
	Vector vAxis( 0, 0, 1 );
	MatrixBuildRotationAboutAxis( mRot, vAxis, 90.0f );
	vAxis.Init( 1, 0, 0 );
	MatrixRotate( mRot, vAxis, 90.0f );

	m_dynRenderableList[ 0 ].m_vOrigin = vOrigin;
	m_dynRenderableList[ 0 ].m_mWorld = mWorld * mRot;
	m_dynRenderableList[ 0 ].m_mWorld.SetTranslation( vOrigin );
}

void CWorldRendererTest::UpdateDroppedRenderables( float flElapsedTime )
{
	int nRenderables = m_dynRenderableList.Count();
	for ( int i=1; i<nRenderables; ++i )
	{
		Vector vAxis( 0, 1, 0 );
		MatrixRotate( m_dynRenderableList[ i ].m_mWorld, vAxis, flElapsedTime * 60.0f );
		m_dynRenderableList[ i ].m_mWorld.SetTranslation( m_dynRenderableList[ i ].m_vOrigin );
	}
}

void CWorldRendererTest::RenderShadowDepthBuffers( IRenderContext *pRenderContext )
{
	Vector4D vShadowClear(1,1,1,1);

	VPROF_SCOPE_BEGIN("RenderSplitShadows");
	for ( int s=0; s<m_nShadowSplits; ++s )
	{
		m_pRenderViews[ RTB_SHADOW_DEPTH0 + s ].Clear( pRenderContext, vShadowClear, RENDER_CLEAR_FLAGS_CLEAR_DEPTH );

		if ( m_pRenderViews[ RTB_SHADOW_DEPTH0 + s ].HasRenderables() )
		{
			RenderView( m_pRenderViews[ RTB_SHADOW_DEPTH0 + s ] );

			// Render spheres
			m_pRenderViews[ RTB_SHADOW_DEPTH0 + s ].BeginRender( pRenderContext );
			
			ViewRelatedConstants_t viewConstants = CreateViewConstantsForFrustum( m_pSplitFrustums[s] );
			pRenderContext->SetConstantBufferData( m_hViewRelated, (void*)&viewConstants, sizeof( ViewRelatedConstants_t ) );
			pRenderContext->BindConstantBuffer( RENDER_VERTEX_SHADER, m_hViewRelated, 0, 0 );

			pRenderContext->SetBlendMode( RENDER_BLEND_NOPIXELWRITE );
			pRenderContext->SetZBufferMode( RENDER_ZBUFFER_ZTEST_AND_WRITE );
			pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );

			int nParticleSystems = m_sphereSystemList.Count();
			for ( int p=0; p<nParticleSystems; ++p )
			{
				RenderParticleLights( pRenderContext, m_sphereSystemList[p], VARIATION_DEPTH, true, false );
			}

			// Submit
			m_pRenderViews[ RTB_SHADOW_DEPTH0 + s ].EndRender( pRenderContext );
		}
	}
	VPROF_SCOPE_END();
	
	VPROF_SCOPE_BEGIN("RenderMultiShadows");
	for ( int s=0; s<m_shadowedSpotLights.Count(); ++s )
	{
		if ( s == 0 )
		{
			m_pRenderViews[ RTB_SHADOW_DEPTH_MULTIPLE_0 + s ].BeginRender( pRenderContext );

			pRenderContext->SetViewports( 1, &m_shadowViewport );
			pRenderContext->Clear( vShadowClear, RENDER_CLEAR_FLAGS_CLEAR_DEPTH );

			m_pRenderViews[ RTB_SHADOW_DEPTH_MULTIPLE_0 + s ].EndRender( pRenderContext, false );
		}

		if ( s == NUM_HIGH_RES_SHADOWS )
		{
			m_pRenderViews[ RTB_SHADOW_DEPTH_MULTIPLE_0 + s ].BeginRender( pRenderContext );

			pRenderContext->SetViewports( 1, &m_shadowViewport );
			pRenderContext->Clear( vShadowClear, RENDER_CLEAR_FLAGS_CLEAR_DEPTH );

			m_pRenderViews[ RTB_SHADOW_DEPTH_MULTIPLE_0 + s ].EndRender( pRenderContext, false );
		}
		
		if ( m_pRenderViews[ RTB_SHADOW_DEPTH_MULTIPLE_0 + s ].HasRenderables() )
		{
			RenderView( m_pRenderViews[ RTB_SHADOW_DEPTH_MULTIPLE_0 + s ] );
		}

		// Render spheres
		m_pRenderViews[ RTB_SHADOW_DEPTH_MULTIPLE_0 + s ].BeginRender( pRenderContext );

		ViewRelatedConstants_t viewConstants = CreateViewConstantsForFrustum( m_pMultiShadowFrustums[ s ] );
		pRenderContext->SetConstantBufferData( m_hViewRelated, (void*)&viewConstants, sizeof( ViewRelatedConstants_t ) );
		pRenderContext->BindConstantBuffer( RENDER_VERTEX_SHADER, m_hViewRelated, 0, 0 );

		int nParticleSystems = m_sphereSystemList.Count();
		for ( int p=0; p<nParticleSystems; ++p )
		{
			RenderParticleLights( pRenderContext, m_sphereSystemList[p], VARIATION_DEPTH, false, false );
		}

		// Submit
		m_pRenderViews[ RTB_SHADOW_DEPTH_MULTIPLE_0 + s ].EndRender( pRenderContext );
	}
	VPROF_SCOPE_END();
}

void CWorldRendererTest::RenderSunShadowFrustums( IRenderContext *pRenderContext )
{
	ViewRelatedConstants_t viewConstants = CreateViewConstantsForFrustum( m_pFrustum );

	pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );
	pRenderContext->SetBlendState( m_hAdditiveBS );
	pRenderContext->SetDepthStencilState( m_hStencilTestDS, g_nCanSeeSkyStencilRef );

	pRenderContext->BindTexture( 0, m_pRenderTargets[ RT_VIEW_NORMAL_HIGHRES ] );
	pRenderContext->SetSamplerStatePS( 0, RS_FILTER_MIN_MAG_MIP_POINT );

	if ( IsPlatformX360() )
	{
		pRenderContext->BindTexture( 1, m_pRenderTargets[ DS_DEPTH_HIGHRES ] );
	}
	else
	{
		pRenderContext->BindTexture( 1, m_pRenderTargets[ RT_VIEW_DEPTH_HIGHRES ] );
	}
	pRenderContext->SetSamplerStatePS( 1, RS_FILTER_MIN_MAG_MIP_POINT );

	pRenderContext->BindTexture( 2, m_pRenderTargets[ RT_VIEW_SPEC_HIGHRES ] );
	pRenderContext->SetSamplerStatePS( 2, RS_FILTER_MIN_MAG_MIP_POINT, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );

	pRenderContext->SetConstantBufferData( m_hViewRelated, (void*)&viewConstants, sizeof( ViewRelatedConstants_t ) );
	pRenderContext->BindConstantBuffer( RENDER_VERTEX_SHADER, m_hViewRelated, 0, 0 );

	pRenderContext->BindVertexShader( m_hShadowFrustumVS[2], m_hQuadLayout );
	pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hShadowFrustumPS[2] );

	for ( int s=0; s<NUM_SHADOW_SPLITS; ++s )
	{
		m_deferredLightingData.m_mShadowMatrix[s] = m_pShadowMatrices[s];
		pRenderContext->BindTexture( 4 + s, m_pRenderTargets[ DS_SHADOW_DEPTH0 + s ] );

		if ( g_nPlatform == RST_PLATFORM_DX11 )
		{
			pRenderContext->SetSamplerStatePS( 4 + s, RS_FILTER_MIN_MAG_MIP_POINT );
		}
		else
		{
			pRenderContext->SetSamplerStatePS( 4 + s, RS_FILTER_MIN_MAG_MIP_LINEAR );
		}
	}

	pRenderContext->SetConstantBufferData( m_hDeferredLightingRelated, (void*)&m_deferredLightingData, sizeof( DeferredLightingConstants_t ) );
	pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hDeferredLightingRelated, 0, 0 );

	RenderScreenQuad( pRenderContext, m_vEyeRays, "sunshadows" );
}

void CWorldRendererTest::RenderBouncedLight( IRenderContext *pRenderContext )
{
	ViewRelatedConstants_t viewConstants = CreateViewConstantsForFrustum( m_pFrustum );

	pRenderContext->SetBlendState( m_hAdditiveBS );
	pRenderContext->SetZBufferMode( RENDER_ZBUFFER_ZTEST_NO_WRITE );
	pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );

	pRenderContext->BindTexture( 0, m_pRenderTargets[ RT_VIEW_NORMAL_LOWRES ] );
	pRenderContext->SetSamplerStatePS( 0, RS_FILTER_MIN_MAG_MIP_POINT, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );
	pRenderContext->BindTexture( 1, m_pRenderTargets[ RT_VIEW_DEPTH_LOWRES ] );
	pRenderContext->SetSamplerStatePS( 1, RS_FILTER_MIN_MAG_MIP_POINT, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );

	pRenderContext->SetConstantBufferData( m_hViewRelated, (void*)&viewConstants, sizeof( ViewRelatedConstants_t ) );
	pRenderContext->BindConstantBuffer( RENDER_VERTEX_SHADER, m_hViewRelated, 0, 0 );

	pRenderContext->SetConstantBufferData( m_hDecalScreenData, &m_lowResScreenData, sizeof( DecalScreenData_t ) );
	pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hDecalScreenData, 0, 0 );

	RenderSceneHemiLights( pRenderContext, m_exteriorHemiLights, false );
	RenderSceneHemiLights( pRenderContext, m_interiorHemiLights, true );
}

void CWorldRendererTest::RenderDirectLight( IRenderContext *pRenderContext )
{
	ViewRelatedConstants_t viewConstants = CreateViewConstantsForFrustum( m_pFrustum );
	pRenderContext->SetConstantBufferData( m_hViewRelated, (void*)&viewConstants, sizeof( ViewRelatedConstants_t ) );
	pRenderContext->BindConstantBuffer( RENDER_VERTEX_SHADER, m_hViewRelated, 0, 0 );

	if ( IsPlatformX360() )
	{
		pRenderContext->BindTexture( 1, m_pRenderTargets[ DS_DEPTH_HIGHRES ] );
	}
	else
	{
		pRenderContext->BindTexture( 1, m_pRenderTargets[ RT_VIEW_DEPTH_HIGHRES ] );
	}
	pRenderContext->SetSamplerStatePS( 1, RS_FILTER_MIN_MAG_MIP_POINT );

	pRenderContext->BindTexture( 2, m_pRenderTargets[ RT_VIEW_SPEC_HIGHRES ] );
	pRenderContext->SetSamplerStatePS( 2, RS_FILTER_MIN_MAG_MIP_POINT, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );

	// Additive light phase
	pRenderContext->SetBlendState( m_hAdditiveBS );
	pRenderContext->SetZBufferMode( RENDER_ZBUFFER_NONE_STENCIL_TEST_NOTEQUAL );
	pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );

	int nParticleSystems = m_lightSystemList.Count();
	for ( int p=0; p<nParticleSystems; ++p )
	{
		RenderParticleLights( pRenderContext, m_lightSystemList[p], VARIATION_DEFAULT, false, false );
	}

	// Render scene lights
	pRenderContext->SetConstantBufferData( m_hDecalScreenData, &m_decalScreenData, sizeof( DecalScreenData_t ) );
	pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hDecalScreenData, 0, 0 );

	RenderScenePointLights( pRenderContext, m_exteriorPointLights, false );
	RenderScenePointLights( pRenderContext, m_interiorPointLights, true );
	RenderSceneSpotLights( pRenderContext, m_exteriorSpotLights, false );
	RenderSceneSpotLights( pRenderContext, m_interiorSpotLights, true );

	RenderShadowedSpotLights( pRenderContext, m_shadowedSpotLights );
}

void CWorldRendererTest::BlurLightBuffer( )
{
	CRenderContextPtr pRenderContext( g_pRenderDevice );
	
	ViewRelatedConstants_t viewConstants = CreateViewConstantsForFrustum( m_pFrustum );

	// Bilat blur ( Horizontal )
	{
		m_pRenderViews[ RTB_LIGHT_BLUR_0 ].BeginRender( pRenderContext );

		pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );
		pRenderContext->SetZBufferMode( RENDER_ZBUFFER_NONE );
		//pRenderContext->SetBlendState( m_hWriteAllBS );
		pRenderContext->SetBlendMode( RENDER_BLEND_NONE );

		pRenderContext->BindTexture( 0, m_pRenderTargets[ RT_VIEW_DEPTH_HIGHRES ] );
		pRenderContext->SetSamplerStatePS( 0, RS_FILTER_MIN_MAG_MIP_POINT, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );
		pRenderContext->BindTexture( 1, m_pRenderTargets[ RT_LIGHTING_HIGHRES ] );
		pRenderContext->SetSamplerStatePS( 1, RS_FILTER_MIN_MAG_MIP_LINEAR, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );

		pRenderContext->SetConstantBufferData( m_hViewRelated, (void*)&viewConstants, sizeof( ViewRelatedConstants_t ) );
		pRenderContext->BindConstantBuffer( RENDER_VERTEX_SHADER, m_hViewRelated, 0, 0 );

		pRenderContext->SetConstantBufferData( m_hDecalScreenData, &m_decalScreenData, sizeof( DecalScreenData_t ) );
		pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hDecalScreenData, 0, 0 );

		pRenderContext->SetConstantBufferData( m_hBlurParams, (void*)&m_blurParams, sizeof( BlurParams_t ) );
		pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hBlurParams, 1, 7 );

		pRenderContext->BindVertexShader( m_hShadowFrustumVS[2], m_hQuadLayout );
		pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hBilateralBlur[2] );

		RenderScreenQuad( pRenderContext, m_vEyeRays, "bilatblurhorz" );

		// Submit
		m_pRenderViews[ RTB_LIGHT_BLUR_0 ].EndRender( pRenderContext );
	}

	// Bilat upsampling ( Vertical )
	{
		m_pRenderViews[ RTB_LIGHT_BLUR_1 ].BeginRender( pRenderContext );

		pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );
		pRenderContext->SetZBufferMode( RENDER_ZBUFFER_NONE );
		//pRenderContext->SetBlendState( m_hWriteAllBS );
		pRenderContext->SetBlendMode( RENDER_BLEND_NONE );

		pRenderContext->BindTexture( 0, m_pRenderTargets[ RT_VIEW_DEPTH_HIGHRES ] );
		pRenderContext->SetSamplerStatePS( 0, RS_FILTER_MIN_MAG_MIP_POINT, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );
		pRenderContext->BindTexture( 1, m_pRenderTargets[ RT_VIEW_SPEC_HIGHRES ] );
		pRenderContext->SetSamplerStatePS( 1, RS_FILTER_MIN_MAG_MIP_LINEAR, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );

		pRenderContext->SetConstantBufferData( m_hViewRelated, (void*)&viewConstants, sizeof( ViewRelatedConstants_t ) );
		pRenderContext->BindConstantBuffer( RENDER_VERTEX_SHADER, m_hViewRelated, 0, 0 );

		pRenderContext->SetConstantBufferData( m_hDecalScreenData, &m_decalScreenData, sizeof( DecalScreenData_t ) );
		pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hDecalScreenData, 0, 0 );

		pRenderContext->SetConstantBufferData( m_hBlurParams, (void*)&m_blurParams, sizeof( BlurParams_t ) );
		pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hBlurParams, 1, 7 );

		pRenderContext->BindVertexShader( m_hShadowFrustumVS[2], m_hQuadLayout );
		pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hBilateralBlur[3] );

		RenderScreenQuad( pRenderContext, m_vEyeRays, "bilatblurvert" );

		// Submit
		m_pRenderViews[ RTB_LIGHT_BLUR_1 ].EndRender( pRenderContext );
	}
}

void CWorldRendererTest::BlurShadowBuffers( )
{
	CRenderContextPtr pRenderContext( g_pRenderDevice );
	
	ViewRelatedConstants_t viewConstants = CreateViewConstantsForFrustum( m_pFrustum );

	BlurParams_t highResBlurParams = m_blurParams;
	BlurParams_t lowResBlurParams = m_blurParams;

	// High res shadow blur
	{
		// blur ( Horizontal )
		{
			m_pRenderViews[ RTB_SHADOW_BLUR_0 ].BeginRender( pRenderContext );

			pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );
			pRenderContext->SetZBufferMode( RENDER_ZBUFFER_NONE );
			pRenderContext->SetBlendMode( RENDER_BLEND_NONE );

			pRenderContext->BindTexture( 1, m_pRenderTargets[ RT_SHADOW_MULTIPLE_0 ] );
			pRenderContext->SetSamplerStatePS( 1, RS_FILTER_MIN_MAG_MIP_LINEAR, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );

			pRenderContext->SetConstantBufferData( m_hViewRelated, (void*)&viewConstants, sizeof( ViewRelatedConstants_t ) );
			pRenderContext->BindConstantBuffer( RENDER_VERTEX_SHADER, m_hViewRelated, 0, 0 );

			pRenderContext->SetConstantBufferData( m_hDecalScreenData, &m_shadowScreenData, sizeof( DecalScreenData_t ) );
			pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hDecalScreenData, 0, 0 );

			pRenderContext->SetConstantBufferData( m_hBlurParams, (void*)&highResBlurParams, sizeof( BlurParams_t ) );
			pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hBlurParams, 1, 7 );

			pRenderContext->BindVertexShader( m_hShadowFrustumVS[2], m_hQuadLayout );
			pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hShadowBlur[0] );

			RenderScreenQuad( pRenderContext, m_vEyeRays, "blurshadowshorz" );

			// Submit
			m_pRenderViews[ RTB_SHADOW_BLUR_0 ].EndRender( pRenderContext );
		}

		// blur ( Vertical )
		{
			m_pRenderViews[ RTB_SHADOW_BLUR_1 ].BeginRender( pRenderContext );

			pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );
			pRenderContext->SetZBufferMode( RENDER_ZBUFFER_NONE );
			pRenderContext->SetBlendMode( RENDER_BLEND_NONE );

			pRenderContext->BindTexture( 1, m_pRenderTargets[ RT_SHADOW_BLUR_TEMP ] );
			pRenderContext->SetSamplerStatePS( 1, RS_FILTER_MIN_MAG_MIP_LINEAR, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );

			pRenderContext->SetConstantBufferData( m_hViewRelated, (void*)&viewConstants, sizeof( ViewRelatedConstants_t ) );
			pRenderContext->BindConstantBuffer( RENDER_VERTEX_SHADER, m_hViewRelated, 0, 0 );

			pRenderContext->SetConstantBufferData( m_hDecalScreenData, &m_shadowScreenData, sizeof( DecalScreenData_t ) );
			pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hDecalScreenData, 0, 0 );

			pRenderContext->SetConstantBufferData( m_hBlurParams, (void*)&highResBlurParams, sizeof( BlurParams_t ) );
			pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hBlurParams, 1, 7 );

			pRenderContext->BindVertexShader( m_hShadowFrustumVS[2], m_hQuadLayout );
			pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hShadowBlur[1] );

			RenderScreenQuad( pRenderContext, m_vEyeRays, "blurshadowvert" );

			// Submit
			m_pRenderViews[ RTB_SHADOW_BLUR_1 ].EndRender( pRenderContext );
		}
	}

	// Low res shadow blur
	{
		// blur ( Horizontal )
		{
			m_pRenderViews[ RTB_SHADOW_BLUR_0 ].BeginRender( pRenderContext );

			pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );
			pRenderContext->SetZBufferMode( RENDER_ZBUFFER_NONE );
			pRenderContext->SetBlendMode( RENDER_BLEND_NONE );

			pRenderContext->BindTexture( 1, m_pRenderTargets[ RT_SHADOW_MULTIPLE_1 ] );
			pRenderContext->SetSamplerStatePS( 1, RS_FILTER_MIN_MAG_MIP_LINEAR, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );

			pRenderContext->SetConstantBufferData( m_hViewRelated, (void*)&viewConstants, sizeof( ViewRelatedConstants_t ) );
			pRenderContext->BindConstantBuffer( RENDER_VERTEX_SHADER, m_hViewRelated, 0, 0 );

			pRenderContext->SetConstantBufferData( m_hDecalScreenData, &m_shadowScreenData, sizeof( DecalScreenData_t ) );
			pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hDecalScreenData, 0, 0 );

			pRenderContext->SetConstantBufferData( m_hBlurParams, (void*)&lowResBlurParams, sizeof( BlurParams_t ) );
			pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hBlurParams, 1, 7 );

			pRenderContext->BindVertexShader( m_hShadowFrustumVS[2], m_hQuadLayout );
			pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hShadowBlur[2] );

			RenderScreenQuad( pRenderContext, m_vEyeRays, "blurshadowhorz2" );

			// Submit
			m_pRenderViews[ RTB_SHADOW_BLUR_0 ].EndRender( pRenderContext );
		}

		// blur ( Vertical )
		{
			m_pRenderViews[ RTB_SHADOW_BLUR_2 ].BeginRender( pRenderContext );

			pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );
			pRenderContext->SetZBufferMode( RENDER_ZBUFFER_NONE );
			pRenderContext->SetBlendMode( RENDER_BLEND_NONE );

			pRenderContext->BindTexture( 1, m_pRenderTargets[ RT_SHADOW_BLUR_TEMP ] );
			pRenderContext->SetSamplerStatePS( 1, RS_FILTER_MIN_MAG_MIP_LINEAR, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );

			pRenderContext->SetConstantBufferData( m_hViewRelated, (void*)&viewConstants, sizeof( ViewRelatedConstants_t ) );
			pRenderContext->BindConstantBuffer( RENDER_VERTEX_SHADER, m_hViewRelated, 0, 0 );

			pRenderContext->SetConstantBufferData( m_hDecalScreenData, &m_shadowScreenData, sizeof( DecalScreenData_t ) );
			pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hDecalScreenData, 0, 0 );

			pRenderContext->SetConstantBufferData( m_hBlurParams, (void*)&lowResBlurParams, sizeof( BlurParams_t ) );
			pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hBlurParams, 1, 7 );

			pRenderContext->BindVertexShader( m_hShadowFrustumVS[2], m_hQuadLayout );
			pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hShadowBlur[3] );

			RenderScreenQuad( pRenderContext, m_vEyeRays, "blurshadowvert2" );

			// Submit
			m_pRenderViews[ RTB_SHADOW_BLUR_2 ].EndRender( pRenderContext );
		}
	}
}

void CWorldRendererTest::RenderDecals( IRenderContext *pRenderContext, int nVariation )
{
	ViewRelatedConstants_t viewConstants = CreateViewConstantsForFrustum( m_pFrustum );

	// Paint Decals
	if ( m_bFullBuffer2 || m_nGlobalDecalPos2 )
	{
		pRenderContext->SetBlendMode( RENDER_BLEND_ALPHABLENDING );

		pRenderContext->SetConstantBufferData( m_hViewRelated, (void*)&viewConstants, sizeof( ViewRelatedConstants_t ) );
		pRenderContext->BindConstantBuffer( RENDER_VERTEX_SHADER, m_hViewRelated, 0, 0 );

		pRenderContext->SetConstantBufferData( m_hDecalScreenData, &m_decalScreenData, sizeof( DecalScreenData_t ) );
		pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hDecalScreenData, 0, 0 );

		if ( nVariation == 0 )
		{
			pRenderContext->BindTexture( 1, m_hDecalNormal2 );
			pRenderContext->SetSamplerStatePS( 1, RS_FILTER_MIN_MAG_MIP_LINEAR, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );
		}
		else
		{
			pRenderContext->BindTexture( 1, m_hDecalAlbedo2 );
			pRenderContext->SetSamplerStatePS( 1, RS_FILTER_MIN_MAG_MIP_LINEAR, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );
		}

		pRenderContext->BindVertexBuffer( 1, 0, 0, 0 );

		pRenderContext->BindVertexBuffer( 0, m_hDecalVB2, 0, sizeof( DecalVertex_t ) );
		pRenderContext->BindIndexBuffer( m_hDecalIB, 0 );
		pRenderContext->BindVertexShader( m_hDecalVS[ nVariation ], m_hDecalLayout );
		pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hDecalPS[ nVariation ] );

		int nIndices = 0;
		if ( m_bFullBuffer2 )
		{
			nIndices = m_nMaxDecals * 36;
		}
		else
		{
			nIndices = m_nGlobalDecalPos2 * 36;
		}

		pRenderContext->DrawIndexed( RENDER_PRIM_TRIANGLES, 0, nIndices );
	}

	// Bullet Decals
	if ( m_bFullBuffer || m_nGlobalDecalPos )
	{
		bool bDraw = true;
		pRenderContext->SetBlendMode( RENDER_BLEND_ALPHABLENDING );

		pRenderContext->SetConstantBufferData( m_hViewRelated, (void*)&viewConstants, sizeof( ViewRelatedConstants_t ) );
		pRenderContext->BindConstantBuffer( RENDER_VERTEX_SHADER, m_hViewRelated, 0, 0 );

		pRenderContext->SetConstantBufferData( m_hDecalScreenData, &m_decalScreenData, sizeof( DecalScreenData_t ) );
		pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hDecalScreenData, 0, 0 );

		if ( nVariation == 0 )
		{
			pRenderContext->BindTexture( 1, m_hDecalNormal );
			pRenderContext->SetSamplerStatePS( 1, RS_FILTER_MIN_MAG_MIP_LINEAR, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );
		}
		else
		{
			if ( m_hDecalAlbedo == RENDER_TEXTURE_HANDLE_INVALID )
			{
				bDraw = false;
			}
			else
			{
				pRenderContext->BindTexture( 1, m_hDecalAlbedo );
				pRenderContext->SetSamplerStatePS( 1, RS_FILTER_MIN_MAG_MIP_LINEAR, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );
			}
		}

		if ( bDraw )
		{
			pRenderContext->BindVertexBuffer( 0, m_hDecalVB, 0, sizeof( DecalVertex_t ) );
			pRenderContext->BindIndexBuffer( m_hDecalIB, 0 );
			pRenderContext->BindVertexShader( m_hDecalVS[ nVariation ], m_hDecalLayout );
			pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hDecalPS[ nVariation ] );

			int nIndices = 0;
			if ( m_bFullBuffer )
			{
				nIndices = m_nMaxDecals * 36;
			}
			else
			{
				nIndices = m_nGlobalDecalPos * 36;
			}

			pRenderContext->DrawIndexed( RENDER_PRIM_TRIANGLES, 0, nIndices );
		}
	}

	// Wall monster decals
	if ( m_nGlobalDecalPos3 )
	{
		pRenderContext->SetBlendMode( RENDER_BLEND_ALPHABLENDING );

		pRenderContext->SetConstantBufferData( m_hViewRelated, (void*)&viewConstants, sizeof( ViewRelatedConstants_t ) );
		pRenderContext->BindConstantBuffer( RENDER_VERTEX_SHADER, m_hViewRelated, 0, 0 );

		pRenderContext->SetConstantBufferData( m_hDecalScreenData, &m_decalScreenData, sizeof( DecalScreenData_t ) );
		pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hDecalScreenData, 0, 0 );

		if ( nVariation == 0 )
		{
			pRenderContext->BindTexture( 1, m_hDecalNormal3[ m_nWallMonsterTexture ] );
			pRenderContext->SetSamplerStatePS( 1, RS_FILTER_MIN_MAG_MIP_LINEAR, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );
		
			pRenderContext->BindVertexBuffer( 0, m_hDecalVB3, 0, sizeof( DecalVertex_t ) );
			pRenderContext->BindIndexBuffer( m_hDecalIB, 0 );
			pRenderContext->BindVertexShader( m_hDecalVS[ nVariation ], m_hDecalLayout );
			pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hDecalPS[ nVariation ] );

			int nIndices = 36;
			pRenderContext->DrawIndexed( RENDER_PRIM_TRIANGLES, 0, nIndices );
		}
	}
}

void CWorldRendererTest::RenderDynamic( IRenderContext *pRenderContext, CDynamicRenderable *pRenderable, int nVariation, bool bSunDepth, bool bSetStencil )
{
	if ( bSunDepth )
	{
		bool bCanSeeSky = true;
		int nLeafNode = m_pWorldRenderer->GetLeafNodeForPoint( pRenderable->m_vOrigin );
		if ( nLeafNode > -1 )
		{
			IBVHNode *pNode = m_pWorldRenderer->GetNode( nLeafNode );
			if ( pNode )
			{
				int nFlags = pNode->GetFlags();
				bCanSeeSky = ( nFlags & NODE_CAN_SEE_SKY ) ? true : false;
			}
		}
	
		if ( !bCanSeeSky )
		{
			return;
		}
	}

	g_pMeshSystem->DrawRenderable( pRenderContext, pRenderable->m_hRenderable, m_hSimpleMeshVS[ nVariation ], m_hSimpleMeshPS[ nVariation ] );
}

void CWorldRendererTest::RenderParticleLights( IRenderContext *pRenderContext, CParticleCollection *pInputSystem, int nVariation, bool bSunDepth, bool bSetStencil )
{
	VPROF("RenderParticleLights");

	Vector vCenter = pInputSystem->GetControlPointAtCurrentTime( 0 );
	int nLeafNode = m_pWorldRenderer->GetLeafNodeForPoint( vCenter );
	IBVHNode *pNode = m_pWorldRenderer->GetNode( nLeafNode );
	int nFlags = pNode->GetFlags();
	bool bCanSeeSky = ( nFlags & NODE_CAN_SEE_SKY ) != 0;

	if ( bSunDepth && !bCanSeeSky )
		return;

	if ( bSetStencil )
	{	
		if ( bCanSeeSky )
		{
			pRenderContext->SetDepthStencilState( m_hSetStencilDS, g_nCanSeeSkyStencilRef );
		}
		else
		{
			pRenderContext->SetDepthStencilState( m_hSetStencilDS, g_nCannotSeeSkyStencilRef );
		}
	}

	pRenderContext->SetConstantBufferData( m_hDecalScreenData, &m_decalScreenData, sizeof( DecalScreenData_t ) );
	pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hDecalScreenData, 0, 0 );

	pRenderContext->BindVertexShader( m_hPointLightVS[nVariation], m_hPointLightLayout );
	pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hPointLightPS[nVariation] );

	pRenderContext->BindVertexBuffer( 0, m_hSphereVB, 0, sizeof( SphereVertex_t ) );
	pRenderContext->BindIndexBuffer( m_hSphereIB, 0 );

	CDynamicVertexData<PerParticleData_t> vb( pRenderContext, pInputSystem->m_nActiveParticles, "particles", "particles" );
	vb.Lock( );

	for ( int p=0; p<pInputSystem->m_nActiveParticles; ++p )
	{
		float const *pPos = pInputSystem->GetFloatAttributePtr( PARTICLE_ATTRIBUTE_XYZ, p );
		float const *pRadius = pInputSystem->GetFloatAttributePtr( PARTICLE_ATTRIBUTE_RADIUS, p );
		float const *pColor = pInputSystem->GetFloatAttributePtr( PARTICLE_ATTRIBUTE_TINT_RGB, p );

		switch( nVariation )
		{
		case VARIATION_DEFAULT:
			vb->m_vPosRadius.Init( pPos[0], pPos[4], pPos[8], pRadius[0] );
			break;
		case 4:
			vb->m_vPosRadius.Init( pPos[0], pPos[4], pPos[8], pRadius[0] * 0.05f );
			break;
		default:
			vb->m_vPosRadius.Init( pPos[0], pPos[4], pPos[8], pRadius[0] * 0.10f );
			break;
		}

		vb->m_vColor.Init( pColor[0], pColor[4], pColor[8], 1 );
		//vb->m_vColor.Init( 0.9, 0.4, 1.0, 1 );
		vb->m_vColor.AsVector3D().NormalizeInPlace();
		vb.AdvanceVertex();
	}

	vb.Unlock( );
	vb.Bind( 1, 0 );

	pRenderContext->DrawIndexedInstanced( RENDER_PRIM_TRIANGLES, 0, m_nNumTriangles * 3, pInputSystem->m_nActiveParticles );
}

void CWorldRendererTest::RenderScenePointLights( IRenderContext *pRenderContext, CUtlVector<CPointLightRenderable> &lightVector, bool bInterior )
{
	if ( bInterior )
	{
		pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_FRONTFACING );
		pRenderContext->SetZBufferMode( RENDER_ZBUFFER_ZTEST_GREATER_NO_WRITE );
	}
	else
	{
		pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );
		pRenderContext->SetZBufferMode( RENDER_ZBUFFER_ZTEST_NO_WRITE );
	}

	const int nMaxLightsPerDraw = 512;
	CDynamicVertexData<PointLightData_t> *pVB = NULL;

	int nLights = lightVector.Count();
	int nLightsDrawn = 0;
	for ( int i=0; i<nLights; ++i )
	{
		if ( !pVB )
		{
			pVB = new CDynamicVertexData<PointLightData_t>( pRenderContext, nMaxLightsPerDraw, "scenelights_point", "scenelights_point" );
			pVB->Lock();
		}

		Vector vLightOrigin = lightVector[i].m_pLight->m_vOrigin;
		Vector vNewOrigin = vLightOrigin - lightVector[i].m_vOrigin;
		(*pVB)->m_vOrigin = vNewOrigin;
		(*pVB)->m_vColorNRadius = lightVector[i].m_pLight->m_vColorNRadius;
		(*pVB)->m_vAttenuation = lightVector[i].m_pLight->m_vAttenuation;
		pVB->AdvanceVertex();

		nLightsDrawn ++;
		if ( nLightsDrawn >= nMaxLightsPerDraw )
		{
			nLightsDrawn = 0;
			pVB->Unlock();

			pRenderContext->BindVertexBuffer( 0, m_hSphereVB, 0, sizeof( SphereVertex_t ) );
			pRenderContext->BindIndexBuffer( m_hSphereIB, 0 );
			pVB->Bind( 1, 0 );
			
			pRenderContext->BindVertexShader( m_hSceneLightVS[0], m_hSceneLightLayout[0] );
			pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hSceneLightPS[0] );

			pRenderContext->DrawIndexedInstanced( RENDER_PRIM_TRIANGLES, 0, m_nSphereIndices, nMaxLightsPerDraw );
			
			delete pVB;
			pVB = NULL;
		}
	}

	if ( pVB )
	{
		Assert( nLightsDrawn > 0 );
		pVB->Unlock();

		pRenderContext->BindVertexBuffer( 0, m_hSphereVB, 0, sizeof( SphereVertex_t ) );
		pRenderContext->BindIndexBuffer( m_hSphereIB, 0 );
		pVB->Bind( 1, 0 );
		
		pRenderContext->BindVertexShader( m_hSceneLightVS[0], m_hSceneLightLayout[0] );
		pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hSceneLightPS[0] );

		pRenderContext->DrawIndexedInstanced( RENDER_PRIM_TRIANGLES, 0, m_nSphereIndices, nLightsDrawn );

		delete pVB;
	}
}

void CWorldRendererTest::RenderSceneHemiLights( IRenderContext *pRenderContext, CUtlVector<CHemiLightRenderable> &lightVector, bool bInterior )
{
	if ( bInterior )
	{
		pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_FRONTFACING );
		pRenderContext->SetZBufferMode( RENDER_ZBUFFER_ZTEST_GREATER_NO_WRITE );
	}
	else
	{
		pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );
		pRenderContext->SetZBufferMode( RENDER_ZBUFFER_ZTEST_NO_WRITE );
	}

	const int nMaxLightsPerDraw = 512;
	CDynamicVertexData<HemiLightData_t> *pVB = NULL;

	int nLights = lightVector.Count();
	int nLightsDrawn = 0;
	for ( int i=0; i<nLights; ++i )
	{
		if ( !pVB )
		{
			pVB = new CDynamicVertexData<HemiLightData_t>( pRenderContext, nMaxLightsPerDraw, "scenelights_hemi", "scenelights_hemi" );
			pVB->Lock();
		}
		Vector vOrigin = lightVector[i].m_vOrigin;

		(*pVB)->m_vTransform0 = lightVector[i].m_pLight->m_vTransform0;
		(*pVB)->m_vTransform1 = lightVector[i].m_pLight->m_vTransform1;
		(*pVB)->m_vTransform2 = lightVector[i].m_pLight->m_vTransform2;
		(*pVB)->m_vTransform0.w -= vOrigin.x;
		(*pVB)->m_vTransform1.w -= vOrigin.y;
		(*pVB)->m_vTransform2.w -= vOrigin.z;
		(*pVB)->m_vColorNRadius = lightVector[i].m_pLight->m_vColorNRadius;
		(*pVB)->m_vAttenuation = lightVector[i].m_pLight->m_vAttenuation;

		pVB->AdvanceVertex();

		nLightsDrawn ++;
		if ( nLightsDrawn >= nMaxLightsPerDraw )
		{
			nLightsDrawn = 0;
			pVB->Unlock();

			pRenderContext->BindVertexBuffer( 0, m_hHemiVB, 0, sizeof( SphereVertex_t ) );
			pRenderContext->BindIndexBuffer( m_hHemiIB, 0 );
			pVB->Bind( 1, 0 );
			
			pRenderContext->BindVertexShader( m_hSceneLightVS[1], m_hSceneLightLayout[1] );
			pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hSceneLightPS[1] );

			pRenderContext->DrawIndexedInstanced( RENDER_PRIM_TRIANGLES, 0, m_nHemiIndices, nMaxLightsPerDraw );
			
			delete pVB;
			pVB = NULL;
		}
	}

	if ( pVB )
	{
		pVB->Unlock();
		if ( nLightsDrawn > 0 )
		{
			pRenderContext->BindVertexBuffer( 0, m_hHemiVB, 0, sizeof( SphereVertex_t ) );
			pRenderContext->BindIndexBuffer( m_hHemiIB, 0 );
			pVB->Bind( 1, 0 );
			
			pRenderContext->BindVertexShader( m_hSceneLightVS[1], m_hSceneLightLayout[1] );
			pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hSceneLightPS[1] );

			pRenderContext->DrawIndexedInstanced( RENDER_PRIM_TRIANGLES, 0, m_nHemiIndices, nLightsDrawn );
		}

		delete pVB;
	}
}

void CWorldRendererTest::RenderSceneSpotLights( IRenderContext *pRenderContext, CUtlVector<CSpotLightRenderable> &lightVector, bool bInterior )
{
	if ( bInterior )
	{
		pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_FRONTFACING );
		pRenderContext->SetZBufferMode( RENDER_ZBUFFER_ZTEST_GREATER_NO_WRITE );
	}
	else
	{
		pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );
		pRenderContext->SetZBufferMode( RENDER_ZBUFFER_ZTEST_NO_WRITE );
	}

	const int nMaxLightsPerDraw = 512;
	CDynamicVertexData<SpotLightData_t> *pVB = NULL;

	int nLights = lightVector.Count();
	int nLightsDrawn = 0;
	for ( int i=0; i<nLights; ++i )
	{
		if ( !lightVector[i].m_bValid )
			continue;

		if ( !pVB )
		{
			pVB = new CDynamicVertexData<SpotLightData_t>( pRenderContext, nMaxLightsPerDraw, "scenelights_spot", "scenelights_spot" );
			pVB->Lock();
		}

		Vector vOrigin = lightVector[i].m_vOrigin;

		(*pVB)->m_vTransform0 = lightVector[i].m_pLight->m_vTransform0;
		(*pVB)->m_vTransform1 = lightVector[i].m_pLight->m_vTransform1;
		(*pVB)->m_vTransform2 = lightVector[i].m_pLight->m_vTransform2;
		(*pVB)->m_vTransform0.w -= vOrigin.x;
		(*pVB)->m_vTransform1.w -= vOrigin.y;
		(*pVB)->m_vTransform2.w -= vOrigin.z;
		(*pVB)->m_vColorNRadius = lightVector[i].m_pLight->m_vColorNRadius;
		(*pVB)->m_vAttenuationNCosSpot = lightVector[i].m_pLight->m_vAttenuationNCosSpot;

		pVB->AdvanceVertex();

		nLightsDrawn ++;
		if ( nLightsDrawn >= nMaxLightsPerDraw )
		{
			nLightsDrawn = 0;
			pVB->Unlock();

			pRenderContext->BindVertexBuffer( 0, m_hConeVB, 0, sizeof( SphereVertex_t ) );
			pRenderContext->BindIndexBuffer( m_hConeIB, 0 );
			pVB->Bind( 1, 0 );
			
			pRenderContext->BindVertexShader( m_hSceneLightVS[2], m_hSceneLightLayout[2] );
			pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hSceneLightPS[2] );

			pRenderContext->DrawIndexedInstanced( RENDER_PRIM_TRIANGLES, 0, m_nHemiIndices, nMaxLightsPerDraw );
			
			delete pVB;
			pVB = NULL;
		}
	}

	if ( pVB )
	{
		pVB->Unlock();

		Assert( nLightsDrawn > 0 );
		pRenderContext->BindVertexBuffer( 0, m_hConeVB, 0, sizeof( SphereVertex_t ) );
		pRenderContext->BindIndexBuffer( m_hConeIB, 0 );
		pVB->Bind( 1, 0 );
		
		pRenderContext->BindVertexShader( m_hSceneLightVS[2], m_hSceneLightLayout[2] );
		pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hSceneLightPS[2] );

		pRenderContext->DrawIndexedInstanced( RENDER_PRIM_TRIANGLES, 0, m_nConeIndices, nLightsDrawn );

		delete pVB;
	}
}


void CWorldRendererTest::RenderShadowedSpotLights( IRenderContext *pRenderContext, CUtlVector<CSpotLightRenderable> &lightVector )
{
	int nLights = lightVector.Count();
	if ( nLights == 0 )
		return;

	const int nMaxLightsPerDraw = NUM_MULTI_SHADOWS;
	CDynamicVertexData<SpotLightData_t> *pVB = new CDynamicVertexData<SpotLightData_t>( pRenderContext, nMaxLightsPerDraw, "scenelights_shadowspot", "scenelights_shadowspot" );
	pVB->Lock();

	Assert( nLights <= NUM_MULTI_SHADOWS );
	for ( int i=0; i<nLights; ++i )
	{
		Vector vOrigin = lightVector[i].m_vOrigin;

		(*pVB)->m_vTransform0 = lightVector[i].m_pLight->m_vTransform0;
		(*pVB)->m_vTransform1 = lightVector[i].m_pLight->m_vTransform1;
		(*pVB)->m_vTransform2 = lightVector[i].m_pLight->m_vTransform2;
		(*pVB)->m_vTransform0.w -= vOrigin.x;
		(*pVB)->m_vTransform1.w -= vOrigin.y;
		(*pVB)->m_vTransform2.w -= vOrigin.z;
		(*pVB)->m_vColorNRadius = lightVector[i].m_pLight->m_vColorNRadius;
		(*pVB)->m_vAttenuationNCosSpot = lightVector[i].m_pLight->m_vAttenuationNCosSpot;

		pVB->AdvanceVertex();
	}

	pVB->Unlock();

	// Bind
	pRenderContext->BindVertexShader( m_hSceneLightVS[2], m_hSceneLightLayout[2] );
	pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hSceneLightPS[5] );

	pRenderContext->BindVertexBuffer( 0, m_hConeVB, 0, sizeof( SphereVertex_t ) );
	pRenderContext->BindIndexBuffer( m_hConeIB, 0 );

	for ( int i=0; i<nLights; ++i )
	{
		if ( i < NUM_HIGH_RES_SHADOWS )
		{
			pRenderContext->BindTexture( 4, m_pRenderTargets[ RT_SHADOW_MULTIPLE_0 ] );
			pRenderContext->SetSamplerStatePS( 4, RS_FILTER_MIN_MAG_MIP_LINEAR, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );

			pRenderContext->BindTexture( 3, m_hFlashlightCookie[0] );
			pRenderContext->SetSamplerStatePS( 3, RS_FILTER_MIN_MAG_MIP_LINEAR, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );
		}
		else
		{
			pRenderContext->BindTexture( 4, m_pRenderTargets[ RT_SHADOW_MULTIPLE_1 ] );
			pRenderContext->SetSamplerStatePS( 4, RS_FILTER_MIN_MAG_MIP_LINEAR, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );

			pRenderContext->BindTexture( 3, m_hFlashlightCookie[1] );
			pRenderContext->SetSamplerStatePS( 3, RS_FILTER_MIN_MAG_MIP_LINEAR, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );
		}

		pRenderContext->SetConstantBufferData( m_hSingleMatrixRelated, &m_pMultiShadowMatrices[ i ], sizeof( VMatrix ) );
		pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hSingleMatrixRelated, 1, 7 );

		if ( lightVector[i].m_bInterior )
		{
			pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_FRONTFACING );
			pRenderContext->SetZBufferMode( RENDER_ZBUFFER_ZTEST_GREATER_NO_WRITE );
		}
		else
		{
			pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );
			pRenderContext->SetZBufferMode( RENDER_ZBUFFER_ZTEST_NO_WRITE );
		}

		pVB->Bind( 1, i * sizeof( SpotLightData_t ) );

		pRenderContext->DrawIndexedInstanced( RENDER_PRIM_TRIANGLES, 0, m_nConeIndices, 1 );
	}

	delete pVB;
}

void CWorldRendererTest::CalculateEyeRays( float flFarPlane )
{
	Vector vForward = m_pFrustum->Forward();
	Vector vUp = m_pFrustum->Up();
	Vector vLeft = m_pFrustum->Left();

	float flFovX = m_pFrustum->GetFOV();
	float flFovY = CalcFovY( flFovX, m_pFrustum->GetAspect() );
	flFovX *= 0.5f;
	flFovY *= 0.5f;
	Vector vFowardShift = flFarPlane * vForward;
	Vector vUpShift = flFarPlane * tanf( DEG2RAD( flFovY ) ) * vUp;
	Vector vRightShift = flFarPlane * tanf( DEG2RAD( flFovX ) ) * -vLeft;
	m_vEyeRays[0] = vFowardShift + -vRightShift + -vUpShift;
	m_vEyeRays[1] = vFowardShift + vRightShift + -vUpShift;
	m_vEyeRays[2] = vFowardShift + -vRightShift + vUpShift;
	m_vEyeRays[3] = vFowardShift + vRightShift + vUpShift;

	vFowardShift = flFarPlane * Vector( 0, 0, 1 );
	vUpShift = flFarPlane * tanf( DEG2RAD( flFovY ) ) * Vector( 0, 1, 0 );
	vRightShift = flFarPlane * tanf( DEG2RAD( flFovX ) ) * Vector( 1, 0, 0 );
	m_vEyeLocalRays[0] = vFowardShift + -vRightShift + -vUpShift;
	m_vEyeLocalRays[1] = vFowardShift + vRightShift + -vUpShift;
	m_vEyeLocalRays[2] = vFowardShift + -vRightShift + vUpShift;
	m_vEyeLocalRays[3] = vFowardShift + vRightShift + vUpShift;
}

void CWorldRendererTest::BilateralUpsample( )
{
	CRenderContextPtr pRenderContext( g_pRenderDevice );
	
	ViewRelatedConstants_t viewConstants = CreateViewConstantsForFrustum( m_pFrustum );

	// Bilat upsampling ( Horizontal )
	{
		m_pRenderViews[ RTB_BILAT_UPSAMPLE_0 ].BeginRender( pRenderContext );

		pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );
		pRenderContext->SetZBufferMode( RENDER_ZBUFFER_NONE );
		pRenderContext->SetBlendState( m_hWriteAllBS );

		if ( IsPlatformX360() )
			pRenderContext->BindTexture( 0, m_pRenderTargets[ DS_DEPTH_LOWRES ] );
		else
			pRenderContext->BindTexture( 0, m_pRenderTargets[ RT_VIEW_DEPTH_LOWRES ] );
		pRenderContext->SetSamplerStatePS( 0, RS_FILTER_MIN_MAG_MIP_POINT, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );
		pRenderContext->BindTexture( 1, m_pRenderTargets[ RT_LIGHTING_LOWRES ] );
		pRenderContext->SetSamplerStatePS( 1, RS_FILTER_MIN_MAG_MIP_LINEAR, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );

		pRenderContext->SetConstantBufferData( m_hViewRelated, (void*)&viewConstants, sizeof( ViewRelatedConstants_t ) );
		pRenderContext->BindConstantBuffer( RENDER_VERTEX_SHADER, m_hViewRelated, 0, 0 );

		pRenderContext->SetConstantBufferData( m_hDecalScreenData, &m_lowResScreenData, sizeof( DecalScreenData_t ) );
		pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hDecalScreenData, 0, 0 );

		pRenderContext->SetConstantBufferData( m_hBlurParams, (void*)&m_blurParams, sizeof( BlurParams_t ) );
		pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hBlurParams, 1, 7 );

		pRenderContext->BindVertexShader( m_hShadowFrustumVS[2], m_hQuadLayout );
		pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hBilateralBlur[0] );

		RenderScreenQuad( pRenderContext, m_vEyeRays, "bilatupsamplehorz" );

		// Submit
		m_pRenderViews[ RTB_BILAT_UPSAMPLE_0 ].EndRender( pRenderContext );
	}

	// Bilat upsampling ( Vertical )
	{
		m_pRenderViews[ RTB_BILAT_UPSAMPLE_1 ].BeginRender( pRenderContext );

		pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );
		pRenderContext->SetZBufferMode( RENDER_ZBUFFER_NONE );
		pRenderContext->SetBlendState( m_hWriteAllBS );

		if ( IsPlatformX360() )
			pRenderContext->BindTexture( 0, m_pRenderTargets[ DS_DEPTH_HIGHRES ] );
		else
			pRenderContext->BindTexture( 0, m_pRenderTargets[ RT_VIEW_DEPTH_HIGHRES ] );

		pRenderContext->SetSamplerStatePS( 0, RS_FILTER_MIN_MAG_MIP_POINT, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );
		pRenderContext->BindTexture( 1, m_pRenderTargets[ RT_LIGHTING_TEMP_LOWRES ] );
		pRenderContext->SetSamplerStatePS( 1, RS_FILTER_MIN_MAG_MIP_LINEAR, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );

		pRenderContext->SetConstantBufferData( m_hViewRelated, (void*)&viewConstants, sizeof( ViewRelatedConstants_t ) );
		pRenderContext->BindConstantBuffer( RENDER_VERTEX_SHADER, m_hViewRelated, 0, 0 );

		pRenderContext->SetConstantBufferData( m_hDecalScreenData, &m_decalScreenData, sizeof( DecalScreenData_t ) );
		pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hDecalScreenData, 0, 0 );

		pRenderContext->SetConstantBufferData( m_hBlurParams, (void*)&m_blurParams, sizeof( BlurParams_t ) );
		pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hBlurParams, 1, 7 );

		pRenderContext->BindVertexShader( m_hShadowFrustumVS[2], m_hQuadLayout );
		pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hBilateralBlur[1] );

		RenderScreenQuad( pRenderContext, m_vEyeRays, "bilatupsamplevert" );

		// Submit
		m_pRenderViews[ RTB_BILAT_UPSAMPLE_1 ].EndRender( pRenderContext );
	}
}

void CWorldRendererTest::RenderSSAO()
{
	CRenderContextPtr pRenderContext( g_pRenderDevice );
	ViewRelatedConstants_t viewConstants = CreateViewConstantsForFrustum( m_pFrustum );

	m_pRenderViews[ RTB_SSAO_LOWRES ].BeginRender( pRenderContext );

	pRenderContext->SetZBufferMode( RENDER_ZBUFFER_NONE );
	pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );
	pRenderContext->SetBlendState( m_hWriteAlphaBS );

#if 0
	pRenderContext->BindTexture( 0, m_pRenderTargets[ RT_VIEW_DEPTH_LOWRES ] );
	pRenderContext->SetSamplerStatePS( 0, RS_FILTER_MIN_MAG_MIP_LINEAR, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );
	pRenderContext->BindTexture( 1, m_pRenderTargets[ RT_VIEW_NORMAL_LOWRES ] );
	pRenderContext->SetSamplerStatePS( 1, RS_FILTER_MIN_MAG_MIP_LINEAR, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );
	pRenderContext->BindTexture( 2, m_hRandomTexture );
	pRenderContext->SetSamplerStatePS( 2, RS_FILTER_MIN_MAG_MIP_POINT, RS_TEXTURE_ADDRESS_WRAP, RS_TEXTURE_ADDRESS_WRAP, RS_TEXTURE_ADDRESS_WRAP );
#else
	pRenderContext->BindTexture( 0, m_pRenderTargets[ RT_VIEW_DEPTH_LOWRES ] );
	pRenderContext->SetSamplerStatePS( 0, RS_FILTER_MIN_MAG_MIP_POINT, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );
	pRenderContext->BindTexture( 1, m_pRenderTargets[ RT_VIEW_NORMAL_LOWRES ] );
	pRenderContext->SetSamplerStatePS( 1, RS_FILTER_MIN_MAG_MIP_POINT, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );
	pRenderContext->BindTexture( 2, m_hRandomTexture );
	pRenderContext->SetSamplerStatePS( 2, RS_FILTER_MIN_MAG_MIP_POINT, RS_TEXTURE_ADDRESS_WRAP, RS_TEXTURE_ADDRESS_WRAP, RS_TEXTURE_ADDRESS_WRAP );
#endif

	pRenderContext->SetConstantBufferData( m_hViewRelated, (void*)&viewConstants, sizeof( ViewRelatedConstants_t ) );
	pRenderContext->BindConstantBuffer( RENDER_VERTEX_SHADER, m_hViewRelated, 0, 0 );

	pRenderContext->SetConstantBufferData( m_hDecalScreenData, &m_lowResScreenData, sizeof( DecalScreenData_t ) );
	pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hDecalScreenData, 0, 0 );

	pRenderContext->SetConstantBufferData( m_hSphereSampleData, &m_sphereSampleData, sizeof( SampleSphereData_t ) );
	pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hSphereSampleData, 1, 7 );
	
	pRenderContext->BindVertexShader( m_hShadowFrustumVS[2], m_hQuadLayout );
	pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hSSAOPS );
	RenderScreenQuad( pRenderContext, m_vEyeRays/*m_vEyeLocalRays*/, "ssao" );

	// Submit
	m_pRenderViews[ RTB_SSAO_LOWRES ].EndRender( pRenderContext );
}

void CWorldRendererTest::ScaleDepthAndNormalBuffers()
{
	CRenderContextPtr pRenderContext( g_pRenderDevice );
	ViewRelatedConstants_t viewConstants = CreateViewConstantsForFrustum( m_pFrustum );

	m_pRenderViews[ RTB_DEFERRED_SCALE_DOWN ].BeginRender( pRenderContext );

	pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );
	pRenderContext->SetBlendMode( RENDER_BLEND_NONE );
	pRenderContext->SetDepthStencilState( m_hZWriteNoTestDS );

	if ( IsPlatformX360() )
	{
		pRenderContext->BindTexture( 0, m_pRenderTargets[ DS_DEPTH_HIGHRES ] );
	}
	else
	{
		pRenderContext->BindTexture( 0, m_pRenderTargets[ RT_VIEW_DEPTH_HIGHRES ] );
	}
	pRenderContext->SetSamplerStatePS( 0, RS_FILTER_MIN_MAG_MIP_POINT/*RENDER_TEXFILTERMODE_LINEAR*/, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );

	pRenderContext->BindTexture( 1, m_pRenderTargets[ RT_VIEW_NORMAL_HIGHRES ] );
	pRenderContext->SetSamplerStatePS( 1, RS_FILTER_MIN_MAG_MIP_POINT/*RENDER_TEXFILTERMODE_LINEAR*/, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );

	pRenderContext->SetConstantBufferData( m_hViewRelated, (void*)&viewConstants, sizeof( ViewRelatedConstants_t ) );
	pRenderContext->BindConstantBuffer( RENDER_VERTEX_SHADER, m_hViewRelated, 0, 0 );

	DecalScreenData_t lowResCopyData = m_lowResScreenData;
	lowResCopyData.m_mInvViewProj = viewConstants.m_mViewProjection;
	pRenderContext->SetConstantBufferData( m_hDecalScreenData, &lowResCopyData, sizeof( DecalScreenData_t ) );
	pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hDecalScreenData, 0, 0 );

	pRenderContext->BindVertexShader( m_hShadowFrustumVS[2], m_hQuadLayout );
	pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hCopyTexture[0] );

	RenderScreenQuad( pRenderContext, m_vEyeRays, "scaledepthnorm" );

	// Submit
	m_pRenderViews[ RTB_DEFERRED_SCALE_DOWN ].EndRender( pRenderContext );
}

void CWorldRendererTest::RenderAerialPerspective()
{
	CRenderContextPtr pRenderContext( g_pRenderDevice );
	ViewRelatedConstants_t viewConstants = CreateViewConstantsForFrustum( m_pFrustum );

	m_pRenderViews[ RTB_AERIAL_PERSPECTIVE ].BeginRender( pRenderContext );

	pRenderContext->SetZBufferMode( RENDER_ZBUFFER_NONE_STENCIL_TEST_NOTEQUAL );
	pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );

	if ( IsPlatformX360() )
	{
		pRenderContext->BindTexture( 0, m_pRenderTargets[ DS_DEPTH_HIGHRES ] );
	}
	else
	{
		pRenderContext->BindTexture( 0, m_pRenderTargets[ RT_VIEW_DEPTH_HIGHRES ] );
	}
	pRenderContext->SetSamplerStatePS( 0, RS_FILTER_MIN_MAG_MIP_POINT );

	pRenderContext->SetConstantBufferData( m_hViewRelated, (void*)&viewConstants, sizeof( ViewRelatedConstants_t ) );
	pRenderContext->BindConstantBuffer( RENDER_VERTEX_SHADER, m_hViewRelated, 0, 0 );

	pRenderContext->SetConstantBufferData( m_hAerialPerspectivePSCB, (void*)&m_aerialPerspectiveData, sizeof( AerialPerspectiveConstants_t ) );
	pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hAerialPerspectivePSCB, 0, 0 );

	pRenderContext->BindVertexShader( m_hShadowFrustumVS[2], m_hQuadLayout );

	// Extinction
	pRenderContext->SetBlendState( m_hExtinctionBS );
	pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hAerialPerspectivePS[0] );
	RenderScreenQuad( pRenderContext, m_vEyeRays, "exinction" );

	// In-scattering
	pRenderContext->SetDepthStencilState( m_hStencilTestDS, g_nCanSeeSkyStencilRef );
	pRenderContext->SetBlendState( m_hInscatteringBS );
	pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hAerialPerspectivePS[1] );
	RenderScreenQuad( pRenderContext, m_vEyeRays, "inscattering" );

	// Submit
	m_pRenderViews[ RTB_AERIAL_PERSPECTIVE ].EndRender( pRenderContext );
}

void CWorldRendererTest::RenderSky()
{
	VPROF("RenderSky");

	CRenderContextPtr pRenderContext( g_pRenderDevice );

	// Update the camera
	m_pFrustum->SetNearFarPlanes( m_flNearPlane, m_flFarPlane );
	m_pFrustum->UpdateFrustumFromCamera();

	if ( m_bDeferred )
	{
		m_pRenderViews[ RTB_SKY ].BeginRender( pRenderContext );
	}
	else
	{
		m_pRenderViews[ RTB_FORWARD ].BeginRender( pRenderContext );
	}

	// Sky
	pRenderContext->SetBlendMode( RENDER_BLEND_NONE );
	pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_FRONTFACING );

	if ( m_bDeferred )
	{
		pRenderContext->SetDepthStencilState( m_hZTestAndStencilTestDS, g_nNothingRenderedStencilRef );
	}
	else
	{
		pRenderContext->SetZBufferMode( RENDER_ZBUFFER_ZTEST_NO_WRITE );
	}
	SkyVSCB_t skyVSCB;

	VMatrix mTrans;
	mTrans.Identity();
	mTrans.SetTranslation( m_pFrustum->GetCameraPosition() );
	skyVSCB.m_mViewProj = mTrans.Transpose() * m_pFrustum->GetViewProj();
	skyVSCB.m_vSkyScale = Vector4D( 17000.0f, 17000.0f, 3000.0f, 0.0f );
	m_skyData.m_vEyePt = Vector4D( 0,0,0,0 );
	m_skyData.m_vLightDir = Vector4D( m_vLightDir.x, m_vLightDir.y, m_vLightDir.z, 1 );

	pRenderContext->SetConstantBufferData( m_hSkyVSCB, (void*)&skyVSCB, sizeof( SkyVSCB_t ) );
	pRenderContext->SetConstantBufferData( m_hSkyPSCB, (void*)&m_skyData, sizeof( SkyPSCB_t ) );
	pRenderContext->BindConstantBuffer( RENDER_VERTEX_SHADER, m_hSkyVSCB, 0, 0 );
	pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hSkyPSCB, 0, 0 );
	pRenderContext->BindVertexShader( m_hSkyVS, m_hSphereLayout );
	pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hSkyPS );
	pRenderContext->BindVertexBuffer( 0, m_hSphereVB, 0, sizeof( SphereVertex_t ) );
	pRenderContext->BindIndexBuffer( m_hSphereIB, 0 );
	pRenderContext->DrawIndexed( RENDER_PRIM_TRIANGLES, 0, m_nNumTriangles * 3 );

	// Submit
	if ( m_bDeferred )
	{
		m_pRenderViews[ RTB_SKY ].EndRender( pRenderContext );
	}
	else
	{
		m_pRenderViews[ RTB_FORWARD ].EndRender( pRenderContext );
	}
}

void CWorldRendererTest::RenderFrame_Internal( const RenderViewport_t &viewport )
{
	VPROF("RenderFrame_Internal");
	if ( !m_bWorldLoaded )
		return;

	m_nWindowCenterX = viewport.m_nTopLeftX + (viewport.m_nWidth / 2);
	m_nWindowCenterY = viewport.m_nTopLeftY + (viewport.m_nHeight / 2);

	RenderViewport_t lowResViewport;
	lowResViewport = viewport;
	lowResViewport.m_nWidth = (int)( lowResViewport.m_nWidth * m_flLowResBufferScale );
	lowResViewport.m_nHeight = (int)( lowResViewport.m_nHeight * m_flLowResBufferScale );

	UpdateFrustum( viewport.m_nWidth, viewport.m_nHeight );

	CRenderContextPtr pRenderContext( g_pRenderDevice );
	
	VMatrix mWorld;
	mWorld.Identity();

	Vector vCameraPos = m_pFrustum->GetCameraPosition();

	float flFarPlane = m_pWorldRenderer->GetMaxVisibleDistance( vCameraPos );
	float flShiftedFar = m_flFarPlane;
	if ( m_bEnableVis )
		flShiftedFar = MIN( flFarPlane, m_flFarPlane );

	CWorldRenderFrustum *pCullFrustum = m_pFrustum;
	if ( m_bDropFrustum )
	{
		pCullFrustum = m_pDropFrustum;
		vCameraPos = m_vCullPos;
		flShiftedFar = m_flFarPlane;
	}

	// Update the camera
	m_pFrustum->SetNearFarPlanes( m_flNearPlane, flShiftedFar );
	m_pFrustum->UpdateFrustumFromCamera();
	VMatrix mViewProj = m_pFrustum->GetViewProj();

	// Shadow split frustums
	float flLightDistance = 5000.0f;
	float flLightFarPlane = 8000.0f;
	float flMaxShadowDistance = 5000.0f;
	m_pFrustum->CalculateLightFrusta( m_pSplitFrustums, m_nShadowSplits, m_vLightDir, flLightDistance, flLightFarPlane, flMaxShadowDistance );

	// Pull flashlight data from the camera
	UpdateFlashlightData();

	// Pull viewmodel data from the camera
	UpdateViewModelData();

	// Build renderables list
	GenerateRenderables( vCameraPos );

	// Update Shadow Data (do this before culling!!!)
	UpdateShadowData();

	// Culling
	if ( m_bDeferred )
	{
		for ( int v=0; v<RTB_FORWARD; ++v )
		{
			CullRenderablesAgainstView( m_pRenderViews[ v ], m_renderableList, m_dynRenderableList );
		}
	}
	else
	{
		for ( int v=RTB_SHADOW_DEPTH0; v<RTB_SHADOW_DEPTH_MULTIPLE_0; ++v )
		{
			CullRenderablesAgainstView( m_pRenderViews[ v ], m_renderableList, m_dynRenderableList );
		}

		CullRenderablesAgainstView( m_pRenderViews[ RTB_FORWARD ], m_renderableList, m_dynRenderableList );
	}

	// Update the camera to make sure we shift the far plane out enough to encompass any lights
	flShiftedFar = MAX( flShiftedFar, m_flMaxLightEncompassingFarPlane );
	m_pFrustum->SetNearFarPlanes( m_flNearPlane, flShiftedFar );
	m_pFrustum->UpdateFrustumFromCamera();
	mViewProj = m_pFrustum->GetViewProj();

	ViewRelatedConstants_t viewConstants = CreateViewConstantsForFrustum( m_pFrustum );
	m_forwardLightingData.m_vLightColor = m_vRenderLightColor;
	m_forwardLightingData.m_vLightDir = Vector4D( m_vLightDir.x, m_vLightDir.y, m_vLightDir.z, 1 );
	m_lightBufferData.m_vInvScreenExtents = Vector4D( 1.0f / viewport.m_nWidth, 1.0f / viewport.m_nHeight, 0, 0 );

	// Calculate eye rays
	CalculateEyeRays( flShiftedFar );

	//
	// Start of rendering
	//

	// Shadow depth buffers
	RenderShadowDepthBuffers( pRenderContext );

	if ( m_bDeferred )
	{
		m_deferredLightingData.m_vLightColor = m_vRenderLightColor;
		m_deferredLightingData.m_vLightDir = Vector4D( m_vLightDir.x, m_vLightDir.y, m_vLightDir.z, 1 );
		m_deferredLightingData.m_vInvScreenExtents = Vector4D( 1.0f / viewport.m_nWidth, 1.0f / viewport.m_nHeight, 0, 0 );
		m_deferredLightingData.m_vEyePt = Vector4D( vCameraPos.x, vCameraPos.y, vCameraPos.z, 1 );

		m_aerialPerspectiveData.m_vLightDir = m_deferredLightingData.m_vLightDir;
		m_aerialPerspectiveData.m_vLightColor = m_skyData.m_vLightColor;
		m_aerialPerspectiveData.m_vInvScreenExtents = m_deferredLightingData.m_vInvScreenExtents;
		m_aerialPerspectiveData.m_vBm = m_skyData.m_vBm;
		m_aerialPerspectiveData.m_flG = Vector4D( 0.7f, 0,0,0 );
		m_aerialPerspectiveData.m_vNearAndFar = Vector4D( m_flNearPlane, flShiftedFar, 0, 0 );
		m_aerialPerspectiveData.m_vEyePt = Vector4D( vCameraPos.x, vCameraPos.y, vCameraPos.z, 1 );

		m_sphereSampleData.m_mViewProj = viewConstants.m_mViewProjection;
		m_sphereSampleData.m_vRandSampleScale.Init( 1 / (float)m_nRandTextureSize, 1 / (float)m_nRandTextureSize, 
													0.5f + ( 0.5f / lowResViewport.m_nWidth ),
													0.5f + ( 0.5f / lowResViewport.m_nHeight ) );
		float flSSAOBias = 0.005f;
		float flSSAOStrenth = 5.0f;
		m_sphereSampleData.m_vSampleRadiusNBias.Init( m_flSampleRadius, flShiftedFar / ( m_flSampleRadius * flSSAOStrenth ), flShiftedFar, flSSAOBias * flShiftedFar );		
		m_blurParams.m_flFarPlane.Init( flShiftedFar, flShiftedFar, flShiftedFar, flShiftedFar );
		
		VMatrix mPosLookupViewProj = mViewProj;
		if ( IsPlatformX360() )
		{
			VMatrix mDepthFlip( 1.0f,    0.0f,     0.0f,      0.0f,
								0.0f,    1.0f,     0.0f,      0.0f,
								0.0f,    0.0f,     -1.0f,	  0.0f,
								0.0f,    0.0f,     1.0f,	  1.0f );
			mPosLookupViewProj = mPosLookupViewProj * mDepthFlip;
		}
		if ( !MatrixInverseGeneral( mPosLookupViewProj, m_deferredLightingData.m_mInvViewProj ) )
			return;

		m_decalScreenData.m_vInvScreenExtents = m_deferredLightingData.m_vInvScreenExtents;
		m_decalScreenData.m_mInvViewProj = m_deferredLightingData.m_mInvViewProj;
		m_decalScreenData.m_vEyePt = m_aerialPerspectiveData.m_vEyePt;
		m_decalScreenData.m_vEyeDir = viewConstants.m_vEyeDir;

		m_lowResScreenData.m_vInvScreenExtents = Vector4D( 1.0f / lowResViewport.m_nWidth, 1.0f / lowResViewport.m_nHeight, 0, 0 );
		m_lowResScreenData.m_mInvViewProj = m_deferredLightingData.m_mInvViewProj;
		m_lowResScreenData.m_vEyePt = m_aerialPerspectiveData.m_vEyePt;
		m_lowResScreenData.m_vEyeDir = viewConstants.m_vEyeDir;

		m_shadowScreenData.m_vInvScreenExtents = Vector4D( 1.0f / m_shadowViewport.m_nWidth, 1.0f / m_shadowViewport.m_nHeight, 0, 0 );
		m_shadowScreenData.m_mInvViewProj = m_deferredLightingData.m_mInvViewProj;
		m_shadowScreenData.m_vEyePt = m_aerialPerspectiveData.m_vEyePt;
		m_shadowScreenData.m_vEyeDir = viewConstants.m_vEyeDir;

		m_aerialPerspectiveData.m_mInvViewProj = m_deferredLightingData.m_mInvViewProj;;
		
		// Blur shadow buffers
		if ( m_bBlurShadows )
		{
			BlurShadowBuffers();
		}

		// Render depth and normal pass
		{
			// SetRenderTarget must be the first call in any command list
			Vector4D vNormalClear(1,1,1,1);
			m_pRenderViews[ RTB_DEFERRED_DEPTH_NORM_SPEC ].Clear( pRenderContext, vNormalClear, RENDER_CLEAR_FLAGS_CLEAR_DEPTH | RENDER_CLEAR_FLAGS_CLEAR_STENCIL );
			
			RenderView( m_pRenderViews[ RTB_DEFERRED_DEPTH_NORM_SPEC ] );

			// Render spheres
			m_pRenderViews[ RTB_DEFERRED_DEPTH_NORM_SPEC ].BeginRender( pRenderContext );

			VMatrix mViewRelated;
			mViewRelated = m_pFrustum->GetViewProj();
			pRenderContext->SetConstantBufferData( m_hViewRelated, (void*)&viewConstants, sizeof( ViewRelatedConstants_t ) );
			pRenderContext->BindConstantBuffer( RENDER_VERTEX_SHADER, m_hViewRelated, 0, 0 );

			pRenderContext->SetBlendMode( RENDER_BLEND_NONE );
			pRenderContext->SetZBufferMode( RENDER_ZBUFFER_ZTEST_AND_WRITE_STENCIL_SET1 );
			pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );

			int nParticleSystems = m_sphereSystemList.Count();
			for ( int p=0; p<nParticleSystems; ++p )
			{
				RenderParticleLights( pRenderContext, m_sphereSystemList[p], VARIATION_NORM_DEPTH_SPEC, false, true );
			}

			// Submit
			m_pRenderViews[ RTB_DEFERRED_DEPTH_NORM_SPEC ].EndRender( pRenderContext );
		}

		// Clear low -res lighting
		{
			Vector4D vLightingClear(0,0,0,1);
			m_pRenderViews[ RTB_LIGHTING_LOWRES ].Clear( pRenderContext, vLightingClear, 0 );
		}

		// Decals
		{
			m_pRenderViews[ RTB_DEFERRED_NORM_SPEC ].BeginRender( pRenderContext );

			pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );
			pRenderContext->SetBlendMode( RENDER_BLEND_NONE );
			pRenderContext->SetZBufferMode( RENDER_ZBUFFER_ZTEST_NO_WRITE );

			// Render decals into normal map... using depth
			if ( IsPlatformX360() )
			{
				pRenderContext->BindTexture( 0, m_pRenderTargets[ DS_DEPTH_HIGHRES ] );
			}
			else
			{
				pRenderContext->BindTexture( 0, m_pRenderTargets[ RT_VIEW_DEPTH_HIGHRES ] );
			}
			pRenderContext->SetSamplerStatePS( 0, RS_FILTER_MIN_MAG_MIP_POINT );

			RenderDecals( pRenderContext, 0 );

			// Submit
			m_pRenderViews[ RTB_DEFERRED_NORM_SPEC ].EndRender( pRenderContext );
		}

		// Scale depth and normal buffers
		ScaleDepthAndNormalBuffers();

		// SSAO only requires depth (and normal later)
		if ( m_bSSAO )
		{
			RenderSSAO();
		}
	
		// Low res lighting requires depth and normal
		{
			m_pRenderViews[ RTB_LIGHTING_LOWRES ].BeginRender( pRenderContext );

			if ( m_bDrawBouncedLight )
			{
				RenderBouncedLight( pRenderContext );
			}

			// Submit
			m_pRenderViews[ RTB_LIGHTING_LOWRES ].EndRender( pRenderContext );
		}

		// Upsample
		BilateralUpsample();
		
		// Clear specular buffer
		{
			Vector4D vSpecClear(0,0,0,0);
			m_pRenderViews[ RTB_CLEAR_SPEC_HIGHRES ].Clear( pRenderContext, vSpecClear, 0 );
		}

		// Do lighting
		{
			m_pRenderViews[ RTB_LIGHTING_HIGHRES ].BeginRender( pRenderContext );

			RenderSunShadowFrustums( pRenderContext );

			if ( m_bDrawDirectLight )
			{
				RenderDirectLight( pRenderContext );
			}

			// Submit
			m_pRenderViews[ RTB_LIGHTING_HIGHRES ].EndRender( pRenderContext );
		}

		// Blur the light buffer
		if ( m_bBlurLighting )
		{
			BlurLightBuffer();
		}

		if ( m_bLightingOnly )
		{
			m_pRenderViews[ RTB_SAMPLE_LIGHTING ].BeginRender( pRenderContext );

			pRenderContext->SetBlendMode( RENDER_BLEND_NONE );
			pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );
			pRenderContext->SetZBufferMode( RENDER_ZBUFFER_NONE );

			pRenderContext->BindTexture( 0, m_pRenderTargets[ m_nViewBuffer ] );
			pRenderContext->SetSamplerStatePS( 0, RS_FILTER_MIN_MAG_MIP_POINT, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );

			if ( m_nViewBuffer == RT_LIGHTING_HIGHRES )
			{
				pRenderContext->BindTexture( 1, m_pRenderTargets[ RT_SPECULAR_HIGHRES ] );
				pRenderContext->SetSamplerStatePS( 1, RS_FILTER_MIN_MAG_MIP_POINT, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP, RS_TEXTURE_ADDRESS_CLAMP );
			}

			pRenderContext->SetConstantBufferData( m_hViewRelated, (void*)&viewConstants, sizeof( ViewRelatedConstants_t ) );
			pRenderContext->BindConstantBuffer( RENDER_VERTEX_SHADER, m_hViewRelated, 0, 0 );

			pRenderContext->SetConstantBufferData( m_hDecalScreenData, &m_decalScreenData, sizeof( DecalScreenData_t ) );
			pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hDecalScreenData, 0, 0 );

			pRenderContext->BindVertexShader( m_hShadowFrustumVS[2], m_hQuadLayout );

			if ( m_nViewBuffer == RT_LIGHTING_LOWRES )
			{
				pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hCopyTexture[2] );
			}
			else if ( m_nViewBuffer == RT_LIGHTING_HIGHRES )
			{
				pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hCopyTexture[3] );
			}
			else
			{
				pRenderContext->BindShader( RENDER_PIXEL_SHADER, m_hCopyTexture[1] );
			}

			RenderScreenQuad( pRenderContext, m_vEyeRays, "lightingonly" );

			// Submit
			m_pRenderViews[ RTB_SAMPLE_LIGHTING ].EndRender( pRenderContext );
		}	
		// Render forward pass while sampling lighting
		else
		{
			Vector4D vForwardClear(0,0,0,0);
			m_pRenderViews[ RTB_SAMPLE_LIGHTING ].Clear( pRenderContext, vForwardClear, 0 );
			
			RenderView( m_pRenderViews[ RTB_SAMPLE_LIGHTING ] );

			// Render spheres
			m_pRenderViews[ RTB_SAMPLE_LIGHTING ].BeginRender( pRenderContext );

			pRenderContext->SetConstantBufferData( m_hViewRelated, (void*)&viewConstants, sizeof( ViewRelatedConstants_t ) );
			pRenderContext->BindConstantBuffer( RENDER_VERTEX_SHADER, m_hViewRelated, 0, 0 );

			int nParticleSystems = m_sphereSystemList.Count();
			
			pRenderContext->SetBlendMode( RENDER_BLEND_NONE );
			pRenderContext->SetZBufferMode( RENDER_ZBUFFER_ZTEST_EQUAL_NO_WRITE );
			pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );
			
			pRenderContext->BindTexture( 4, m_pRenderTargets[ RT_LIGHTING_HIGHRES ] );
			pRenderContext->SetSamplerStatePS( 4, RS_FILTER_MIN_MAG_MIP_POINT );

			pRenderContext->BindTexture( 5, m_pRenderTargets[ RT_SPECULAR_HIGHRES ] );
			pRenderContext->SetSamplerStatePS( 5, RS_FILTER_MIN_MAG_MIP_POINT );

			for ( int p=0; p<nParticleSystems; ++p )
			{
				RenderParticleLights( pRenderContext, m_sphereSystemList[p], VARIATION_SAMPLE_LIGHTING, false, false );
			}

			// Decals
			pRenderContext->SetZBufferMode( RENDER_ZBUFFER_ZTEST_NO_WRITE );
			if ( IsPlatformX360() )
			{
				pRenderContext->BindTexture( 0, m_pRenderTargets[ DS_DEPTH_HIGHRES ] );
			}
			else
			{
				pRenderContext->BindTexture( 0, m_pRenderTargets[ RT_VIEW_DEPTH_HIGHRES ] );
			}
			pRenderContext->SetSamplerStatePS( 0, RS_FILTER_MIN_MAG_MIP_POINT );
			pRenderContext->BindTexture( 2, m_pRenderTargets[ RT_LIGHTING_HIGHRES ] );
			pRenderContext->SetSamplerStatePS( 2, RS_FILTER_MIN_MAG_MIP_POINT );
			pRenderContext->BindTexture( 3, m_pRenderTargets[ RT_SPECULAR_HIGHRES ] );
			pRenderContext->SetSamplerStatePS( 3, RS_FILTER_MIN_MAG_MIP_POINT );
			RenderDecals( pRenderContext, 1 );

			// Render pointlights
			pRenderContext->SetBlendMode( RENDER_BLEND_NONE );
			pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );
			pRenderContext->SetZBufferMode( RENDER_ZBUFFER_ZTEST_AND_WRITE );

			nParticleSystems = m_lightSystemList.Count();
			for ( int p=0; p<nParticleSystems; ++p )
			{
				RenderParticleLights( pRenderContext, m_lightSystemList[p], 4, false, false );
			}

			// Submit
			m_pRenderViews[ RTB_SAMPLE_LIGHTING ].EndRender( pRenderContext );
		}
		

		// Render aerial perspective
		if ( m_bDrawAerialPerspective )
		{
			RenderAerialPerspective();
		}
	}
	else
	{
		VPROF_SCOPE_BEGIN("RenderWorldNodes");

		Vector4D c(0,1,0,0);
		m_pRenderViews[ RTB_FORWARD ].Clear( pRenderContext, c, RENDER_CLEAR_FLAGS_CLEAR_DEPTH );

		RenderView( m_pRenderViews[ RTB_FORWARD ] );

		// Submit
		m_pRenderViews[ RTB_FORWARD ].EndRender( pRenderContext );

		VPROF_SCOPE_END();
	}

	if ( m_bRenderSky )
	{
		RenderSky();
	}

	// Unbind the render targets
	for ( int s=0; s<NUM_SHADOW_SPLITS; ++s )
	{
		pRenderContext->BindTexture( 4 + s, RENDER_TEXTURE_HANDLE_INVALID );
	}
	pRenderContext->Submit();

	for ( int v=0; v<MAX_VIEW_BINDING_TYPES; ++v )
	{
		m_pRenderViews[ v ].EndRender( NULL );
	}

	// Update resources phase (arbitrarily only allow 10 resources to be updated)
	m_pWorldRenderer->UpdateResources( g_pRenderDevice, pRenderContext, 10 );

	m_nGlobalDecalPos3 = 0;
	m_nCurrentFrameNumber++;
}


void CWorldRendererTest::SimulateFrame( float flTimeStep )
{
	UpdateDroppedRenderables( flTimeStep );

	const float forwardSpeed = 500.0f;
	const float sideSpeed = 500.0f;
	const float yawSpeed = 90.0f;
	const float pitchSpeed = 45.0f;

#if defined( _X360 )
	const float flYawSensitivity = -0.04f;
	const float flPitchSensitivity = 0.04f;
#else
	const float flYawSensitivity = -0.2f;
	const float flPitchSensitivity = 0.2f;
#endif

	float flForward = forwardSpeed;
	float flSide = sideSpeed;
	if ( m_cmd.m_nKeys & FKEY_FAST )
	{
		flForward *= 5;
		flSide *= 5;
	}

	if ( m_cmd.m_nKeys & FKEY_ENABLE_VIS )
	{
		m_bEnableVis = true;
		Msg( "Vis enabled\n" );
	}
	else if( m_cmd.m_nKeys & FKEY_DISABLE_VIS )
	{
		m_bEnableVis = false;
		Msg( "Vis disabled\n" );
	}

	if ( m_cmd.m_nKeys & FKEY_DROP_FRUSTUM )
	{
		Q_memcpy( m_pDropFrustum, m_pFrustum, sizeof( CWorldRenderFrustum ) );
		m_bDropFrustum = !m_bDropFrustum;
		m_vCullPos = m_pFrustum->GetCameraPosition();
		if ( m_bDropFrustum )
			Msg( "Drop frustum\n" );
		else
			Msg( "no drop\n" );
		ThreadSleep( 200 );
	}

	if ( m_cmd.m_nKeys & FKEY_TOGGLE_AERIAL )
	{
		m_bDrawAerialPerspective = !m_bDrawAerialPerspective;
		if ( m_bDrawAerialPerspective )
			Msg( "Aerial Perspective: On\n" );
		else
			Msg( "Aerial Perspective: Off\n" );
		ThreadSleep( 200 );
	}

	if ( m_cmd.m_nKeys & FKEY_TOGGLE_BOUNCE )
	{
		m_bDrawBouncedLight = !m_bDrawBouncedLight;
		if ( m_bDrawBouncedLight )
			Msg( "Bounced light: On\n" );
		else
			Msg( "Bounced light: Off\n" );
		ThreadSleep( 200 );
	}

	if ( m_cmd.m_nKeys & FKEY_TOGGLE_DIRECT )
	{
		m_bDrawDirectLight = !m_bDrawDirectLight;
		if ( m_bDrawDirectLight )
			Msg( "Direct light: On\n" );
		else
			Msg( "Direct light: Off\n" );
		ThreadSleep( 200 );
	}

	if ( m_cmd.m_nKeys & FKEY_TOGGLE_LIGHTING_ONLY )
	{
		m_bLightingOnly = !m_bLightingOnly;
		if ( m_bLightingOnly )
			Msg( "Lighting Only: On\n" );
		else
			Msg( "Lighting Only: Off\n" );
		ThreadSleep( 200 );
	}

	if ( m_cmd.m_nKeys & FKEY_SSAO )
	{
		m_bSSAO = !m_bSSAO;
		if ( m_bSSAO )
			Msg( "SSAO: On\n" );
		else
			Msg( "SSAO: Off\n" );
		ThreadSleep( 200 );
	}

	if ( m_cmd.m_nKeys & FKEY_BLUR_LIGHTING )
	{
		m_bBlurLighting = !m_bBlurLighting;
		if ( m_bBlurLighting )
			Msg( "Blur Lighting: On\n" );
		else
			Msg( "Blur Lighting: Off\n" );
		ThreadSleep( 200 );
	}

	if ( m_cmd.m_nKeys & FKEY_BLUR_SHADOWS )
	{
		m_bBlurShadows = !m_bBlurShadows;
		if ( m_bBlurShadows )
			Msg( "Blur Shadows: On\n" );
		else
			Msg( "Blur Shadows: Off\n" );
		ThreadSleep( 200 );
	}

	m_cmd.m_flForwardMove = (m_cmd.m_nKeys & (FKEY_FORWARD|FKEY_BACK)) ? ( (m_cmd.m_nKeys & FKEY_FORWARD) ? flForward : -flForward) : 0;
	m_cmd.m_flRightMove = (m_cmd.m_nKeys & (FKEY_LEFT|FKEY_RIGHT)) ? ( (m_cmd.m_nKeys & FKEY_RIGHT) ? flSide : -flSide) : 0;
	float flYawMove = (m_cmd.m_nKeys & (FKEY_TURNLEFT|FKEY_TURNRIGHT)) ? ( (m_cmd.m_nKeys & FKEY_TURNLEFT) ? yawSpeed : -yawSpeed) : 0;
	float flPitchMove = (m_cmd.m_nKeys & (FKEY_TURNUP|FKEY_TURNDOWN)) ? ( (m_cmd.m_nKeys & FKEY_TURNDOWN) ? pitchSpeed : -pitchSpeed) : 0;
	
	if ( m_nCursorDeltaX || m_nCursorDeltaY )
	{
		m_cmd.m_flYawMove = m_nCursorDeltaX * flYawSensitivity;
		m_cmd.m_flPitchMove = m_nCursorDeltaY * flPitchSensitivity;
		m_nCursorDeltaX = m_nCursorDeltaResetX;
		m_nCursorDeltaY = m_nCursorDeltaResetY;
		if ( !IsPlatformX360() )
		{
			g_pInputStackSystem->SetCursorPosition( GetInputContext(), m_nWindowCenterX, m_nWindowCenterY );
		}
	}
	m_cmd.m_flPitchMove += flPitchMove * flTimeStep;
	m_cmd.m_flYawMove += flYawMove * flTimeStep;

	Vector vMoveAmount = ((m_pFrustum->Forward() * m_cmd.m_flForwardMove ) - ( m_pFrustum->Left() * m_cmd.m_flRightMove )) * flTimeStep;
	Vector eyePos = m_pFrustum->GetCameraPosition() + vMoveAmount;
	m_pFrustum->SetCameraPosition( eyePos );
	QAngle angles = m_pFrustum->GetCameraAngles();
	angles.y += m_cmd.m_flYawMove;
	angles.x += m_cmd.m_flPitchMove;
	angles.x = clamp( angles.x, -89.0f, 89.0f );
	m_cmd.m_flYawMove = 0;
	m_cmd.m_flPitchMove = 0;

	if ( angles.y > 180.0f )
	{
		angles.y -= 360.0f;
	}
	if ( angles.y < -180.0f )
	{
		angles.y += 360.0f;
	}
	m_pFrustum->SetCameraAngles( angles );

	// Update light
	VMatrix mLight,mLightAngle, mLightElevation;
	mLightAngle.Identity();
	mLightElevation.Identity();
	mLight.Identity();
	MatrixRotate( mLightElevation, Vector(1,0,0), m_vLightAngleElevation.y );
	MatrixRotate( mLightAngle, Vector(0,0,1), m_vLightAngleElevation.x );
	mLight = mLightElevation * mLightAngle;
	Vector vLightStart(1,0,0);
	matrix3x4_t mLight3x4 = mLight.As3x4();
	VectorRotate( vLightStart, mLight3x4, m_vLightDir );
	m_vLightDir.NormalizeInPlace();

	float flLerp = sinf( DEG2RAD( m_vLightAngleElevation.x ) );
	Vector4D vColorRed( 1.0, 0.7, 0.6, 1 );
	Vector4D vColorYellow( 1.0, 0.9, 0.7, 1 );
	m_skyData.m_vLightColor = Lerp( flLerp, vColorRed, vColorYellow );

	Vector4D vRenderColorRed( 1.0, 0.6, 0.4, 1 );
	Vector4D vRenderColorYellow( 1.0, 0.9, 0.7, 1 );
	m_vRenderLightColor = Lerp( flLerp, vRenderColorRed, vRenderColorYellow );

	Vector4D vBmRed( 1.0e-4, 0.4e-4, 0.3e-4, 1 );
	Vector4D vBmYellow( 1.0e-4, 0.7e-4, 0.3e-4, 1 );
	m_skyData.m_vBm = Lerp( flLerp, vBmRed, vBmYellow );

	float flGRed = 0.90f;
	float flGYellow = 0.99f;
	m_skyData.m_flG.x = Lerp( flLerp, flGRed, flGYellow );

	if ( m_cmd.m_nKeys & FKEY_LIGHTANG_POS )
	{
		m_vLightAngleElevation.x += m_flLightAngSpeed * flTimeStep;
	}
	else if ( m_cmd.m_nKeys & FKEY_LIGHTANG_NEG )
	{
		m_vLightAngleElevation.x -= m_flLightAngSpeed * flTimeStep;
	}

	if ( m_cmd.m_nKeys & FKEY_LIGHTELV )
	{
		m_vLightAngleElevation.y += m_flLightElvSpeed * flTimeStep;
		if ( m_vLightAngleElevation.y > 88.0f || m_vLightAngleElevation.y < 30.0f )
		{
			m_flLightElvSpeed = -m_flLightElvSpeed;
		}
	}

	// Shooting decals
	if ( m_cmd.m_nKeys & FKEY_SHOOTDECAL )
	{
		if ( m_flDecalCountdown <= 0 )
		{
			Vector vEye = m_pFrustum->GetCameraPosition();
			Vector vDir = m_pFrustum->Forward();
			Vector vSurfaceNormal;
			float flDistance = m_pWorldRenderer->CastRay( &vSurfaceNormal, vEye, vDir );
			
			if ( flDistance > 0 )
			{
				float flSize = RPercentABS() * 40.0f + 70.0f;
				CRenderContextPtr pRenderContext( g_pRenderDevice );
				Vector vPos = vEye + vDir * flDistance;
				AddDecal( pRenderContext, vPos, vSurfaceNormal, 
						  flSize, flSize, //size x,y
						  6.0f, 12.0f, false ); // intersection, length
			}
			m_flDecalCountdown = 0.1f;
		}
		m_flDecalCountdown -= flTimeStep;
	}

	// Shooting blood decals
	if ( m_cmd.m_nKeys & FKEY_SHOOTDECAL2 )
	{
		if ( m_flDecalCountdown <= 0 )
		{
			Vector vEye = m_pFrustum->GetCameraPosition();
			Vector vDir = m_pFrustum->Forward();
			Vector vSurfaceNormal;
			float flDistance = m_pWorldRenderer->CastRay( &vSurfaceNormal, vEye, vDir );
			
			if ( flDistance > 0 )
			{
				float flSize = RPercentABS() * 50.0f + 80.0f;
				CRenderContextPtr pRenderContext( g_pRenderDevice );
				Vector vPos = vEye + vDir * flDistance;
				AddDecal( pRenderContext, vPos, vSurfaceNormal, 
						  flSize, flSize, //size x,y
						  20.0f, 40.0f, true ); // intersection, length
			}
			m_flDecalCountdown = 0.05f;
		}
		m_flDecalCountdown -= flTimeStep;
	}

	// Shooting the wall-monster decal
	if ( m_cmd.m_nKeys & FKEY_SHOOTWALLMONSTER )
	{
		Vector vEye = m_pFrustum->GetCameraPosition();
		Vector vDir = m_pFrustum->Forward();
		Vector vSurfaceNormal;
		float flDistance = m_pWorldRenderer->CastRay( &vSurfaceNormal, vEye, vDir );
		
		if ( flDistance > 0 )
		{
			float flSize = 100.0f;
			CRenderContextPtr pRenderContext( g_pRenderDevice );
			Vector vPos = vEye + vDir * flDistance;

			Vector vMonsterNormal = m_vPreviousMonsterNormal + vSurfaceNormal * 4;
			vMonsterNormal.NormalizeInPlace();
			AddWallMonster( pRenderContext, vPos, vMonsterNormal, 
					  flSize, flSize, //size x,y
					  50.0f, 100.0f ); // intersection, length

			m_vPreviousMonsterNormal = vMonsterNormal;

			if ( m_flWallMonsterTimer < 0 )
			{
				m_nWallMonsterTexture = ( m_nWallMonsterTexture + 1 ) % 3;
				m_flWallMonsterTimer = 0.05f;
			}
			else
			{
				m_flWallMonsterTimer -= MAX( 0.01f, flTimeStep );
			}
		}
	}

	if ( !( m_cmd.m_nKeys & FKEY_SHOOTDECAL || m_cmd.m_nKeys & FKEY_SHOOTDECAL2 ) )
	{
		m_flDecalCountdown = 0.0f;
	}

	// shoot a particle system
	if ( m_cmd.m_nKeys & FKEY_SHOOTPSYSTEM || m_cmd.m_nKeys & FKEY_SHOOTSSYSTEM )
	{
		if ( m_flParticleCountdown <= 0 )
		{
			bool bSphereSystem = ( m_cmd.m_nKeys & FKEY_SHOOTSSYSTEM ) != 0;
			Vector vEye = m_pFrustum->GetCameraPosition();
			Vector vDir = m_pFrustum->Forward();
			Vector vSurfaceNormal;

			float flDistance = m_pWorldRenderer->CastRay( &vSurfaceNormal, vEye, vDir );
				
			if ( flDistance > 0 )
			{
				Msg( "psystem distance = %f\n", flDistance );

				CParticleCollection *pParticleSystem = g_pSceneSystem->CreateParticleCollection( "wonderinglights" );
				if ( !pParticleSystem )
					Error( "No wondering lights particle system!\n" );

				Vector vPos = vEye + vDir * flDistance;

				vPos += vSurfaceNormal * 100;
				pParticleSystem->SetControlPoint( 0, vPos );
				pParticleSystem->SetControlPointOrientation( 0, Vector(1,0,0), Vector(0,1,0), Vector(0,0,1) );

				if ( bSphereSystem )
					m_sphereSystemList.AddToTail( pParticleSystem );
				else
					m_lightSystemList.AddToTail( pParticleSystem );

				SimulateWorkUnitWorldRender_t workUnit;
				workUnit.m_nNumSystems = 1;
				workUnit.m_pParticles = pParticleSystem;
				m_particleWorkUnits.AddToTail( workUnit );
			}
			m_flParticleCountdown = 0.5f;
		}
		m_flParticleCountdown -= flTimeStep;
	}
	else
	{
		m_flParticleCountdown = 0.0f;
	}


	// Sim particles
	SimulateParticles( flTimeStep );
}

void CWorldRendererTest::AddDecal( IRenderContext *pRenderContext, Vector &vHit, Vector &vDecalDir, float flDecalSizeU, float flDecalSizeV, float flDecalShift, float flDecalInfluenceLength, bool bPaint )
{
	if ( g_nPlatform == RST_PLATFORM_GL )
		return;

	Vector vUp(RPercent(),RPercent(),RPercent());
	vUp.NormalizeInPlace();

	Vector vNegUp = -vUp;
	if ( DotProduct( vDecalDir, vUp ) > 0.95f || DotProduct( vDecalDir, vNegUp ) > 0.95f  )
		vUp = Vector(0,1,0);

	Vector vRight;
	vRight = CrossProduct( vUp, vDecalDir );
	vUp = CrossProduct( vDecalDir, vRight );
	vRight.NormalizeInPlace();
	vUp.NormalizeInPlace();
	vRight *= flDecalSizeU;
	vUp *= flDecalSizeV;
	vDecalDir.NormalizeInPlace();

	Vector vStartCorner = vHit;
	vStartCorner -= vRight * 0.5f;
	vStartCorner -= vUp * 0.5f;
	vStartCorner -= vDecalDir * flDecalShift;
	vDecalDir *= flDecalInfluenceLength;

	// Create the 8 corners of a box surrounding our decal
	Vector vCorners[8];
	vCorners[0] = vStartCorner;
	vCorners[1] = vStartCorner + vRight;
	vCorners[2] = vStartCorner + vRight + vUp;
	vCorners[3] = vStartCorner + vUp;

	vCorners[4] = vStartCorner + vDecalDir;
	vCorners[5] = vCorners[4] + vRight;
	vCorners[6] = vCorners[4] + vRight + vUp;
	vCorners[7] = vCorners[4] + vUp;

	float fRMul = 1.0f / ( flDecalSizeU * flDecalSizeU );
	float fUMul = 1.0f / ( flDecalSizeV * flDecalSizeV );
	vRight = fRMul * vRight;
	vUp = fUMul * vUp;

	if ( bPaint )
	{
		DecalVertex_t *pVertices = &m_pDecalBackingStore2[ m_nGlobalDecalPos2 * 8 ];
		for ( int i=0; i<8; ++i )
		{
			pVertices[i].m_vPos = vCorners[i];
			pVertices[i].m_vDecalRight = vRight;
			pVertices[i].m_vDecalUpAndInfluence = Vector4D( vUp.x, vUp.y, vUp.z, flDecalInfluenceLength );
			pVertices[i].m_vDecalOrigin = vStartCorner;
		}

		LockDesc_t lockDesc;
		pRenderContext->LockVertexBuffer( m_hDecalVB2, m_nMaxDecals * 8 * sizeof( DecalVertex_t ), &lockDesc );
		Q_memcpy( lockDesc.m_pMemory, m_pDecalBackingStore2, m_nMaxDecals * 8 * sizeof( DecalVertex_t ) );
		pRenderContext->UnlockVertexBuffer( m_hDecalVB2, m_nMaxDecals * 8 * sizeof( DecalVertex_t ), &lockDesc );

		// Go to the next decal
		m_nGlobalDecalPos2 ++;
		if ( m_nGlobalDecalPos2 >= m_nMaxDecals )
		{
			m_bFullBuffer2 = true;
			m_nGlobalDecalPos2 = 0;
		}
	}
	else
	{
		DecalVertex_t *pVertices = &m_pDecalBackingStore[ m_nGlobalDecalPos * 8 ];
		for ( int i=0; i<8; ++i )
		{
			pVertices[i].m_vPos = vCorners[i];
			pVertices[i].m_vDecalRight = vRight;
			pVertices[i].m_vDecalUpAndInfluence = Vector4D( vUp.x, vUp.y, vUp.z, flDecalInfluenceLength );
			pVertices[i].m_vDecalOrigin = vStartCorner;
		}

		LockDesc_t lockDesc;
		pRenderContext->LockVertexBuffer( m_hDecalVB, m_nMaxDecals * 8 * sizeof( DecalVertex_t ), &lockDesc );
		Q_memcpy( lockDesc.m_pMemory, m_pDecalBackingStore, m_nMaxDecals * 8 * sizeof( DecalVertex_t ) );
		pRenderContext->UnlockVertexBuffer( m_hDecalVB, m_nMaxDecals * 8 * sizeof( DecalVertex_t ), &lockDesc );

		// Go to the next decal
		m_nGlobalDecalPos ++;
		if ( m_nGlobalDecalPos >= m_nMaxDecals )
		{
			m_bFullBuffer = true;
			m_nGlobalDecalPos = 0;
		}
	}
}

void CWorldRendererTest::AddWallMonster( IRenderContext *pRenderContext, Vector &vHit, Vector &vDecalDir, float flDecalSizeU, float flDecalSizeV, float flDecalShift, float flDecalInfluenceLength )
{
	if ( g_nPlatform == RST_PLATFORM_GL )
		return;

	Vector vUp(0,0,1);
	Vector vNegUp = -vUp;
	if ( DotProduct( vDecalDir, vUp ) > 0.95f || DotProduct( vDecalDir, vNegUp ) > 0.95f  )
		vUp = m_pFrustum->Up();

	Vector vRight;
	vRight = CrossProduct( vUp, vDecalDir );
	vUp = CrossProduct( vDecalDir, vRight );
	vRight.NormalizeInPlace();
	vUp.NormalizeInPlace();
	vRight *= flDecalSizeU;
	vUp *= flDecalSizeV;
	vDecalDir.NormalizeInPlace();

	Vector vStartCorner = vHit;
	vStartCorner -= vRight * 0.5f;
	vStartCorner -= vUp * 0.5f;
	vStartCorner -= vDecalDir * flDecalShift;
	vDecalDir *= flDecalInfluenceLength;

	// Create the 8 corners of a box surrounding our decal
	Vector vCorners[8];
	vCorners[0] = vStartCorner;
	vCorners[1] = vStartCorner + vRight;
	vCorners[2] = vStartCorner + vRight + vUp;
	vCorners[3] = vStartCorner + vUp;

	vCorners[4] = vStartCorner + vDecalDir;
	vCorners[5] = vCorners[4] + vRight;
	vCorners[6] = vCorners[4] + vRight + vUp;
	vCorners[7] = vCorners[4] + vUp;

	float fRMul = 1.0f / ( flDecalSizeU * flDecalSizeU );
	float fUMul = 1.0f / ( flDecalSizeV * flDecalSizeV );
	vRight = fRMul * vRight;
	vUp = fUMul * vUp;

	DecalVertex_t pVertices[8];
	for ( int i=0; i<8; ++i )
	{
		pVertices[i].m_vPos = vCorners[i];
		pVertices[i].m_vDecalRight = vRight;
		pVertices[i].m_vDecalUpAndInfluence = Vector4D( vUp.x, vUp.y, vUp.z, flDecalInfluenceLength );
		pVertices[i].m_vDecalOrigin = vStartCorner;
	}

	LockDesc_t lockDesc;
	pRenderContext->LockVertexBuffer( m_hDecalVB3, 8 * sizeof( DecalVertex_t ), &lockDesc );
	Q_memcpy( lockDesc.m_pMemory, pVertices, 8 * sizeof( DecalVertex_t ) );
	pRenderContext->UnlockVertexBuffer( m_hDecalVB3, 8 * sizeof( DecalVertex_t ), &lockDesc );

	// Go to the next decal
	m_nGlobalDecalPos3 = 1;
}

void CWorldRendererTest::DropRenderable()
{
	Vector vOrigin = m_pFrustum->GetCameraPosition();
	vOrigin.z -= 32.0f;

	int index = m_dynRenderableList.AddToTail();

	VMatrix mRot;
	Vector vAxis( 0, 0, 1 );
	MatrixBuildRotationAboutAxis( mRot, vAxis, 90.0f );
	vAxis.Init( 1, 0, 0 );
	MatrixRotate( mRot, vAxis, 90.0f );

	m_dynRenderableList[ index ].m_vOrigin = vOrigin;
	m_dynRenderableList[ index ].m_mWorld = mRot;
	m_dynRenderableList[ index ].m_hRenderable = g_pMeshSystem->FindOrCreateFileRenderable( g_pRenderableList[ g_nCurrentModel ] );
	g_nCurrentModel ++;
	if ( g_nCurrentModel >= MAX_MESH_SYSTEM_MODELS )
		g_nCurrentModel = 0;
}

Vector Evaluate( float flU, float flV, Vector vRadius )
{
	flU *= 2.0 * M_PI;
	flV *= 2.0 * M_PI;
	return Vector( 
		vRadius.x * cos( flU ) * sin( flV ),
		vRadius.y * sin( flU ) * sin( flV ),
		vRadius.z * cos ( flV ) );
}

void CWorldRendererTest::CreateSphere( int nTessellationRes )
{
	Vector vRadius(1,1,1);
	CRenderContextPtr pRenderContext( g_pRenderDevice );

	// create the static index buffer
	BufferDesc_t indexDesc;
	indexDesc.m_nElementSizeInBytes = sizeof(uint16);
	indexDesc.m_nElementCount = 2 * 3 * ( nTessellationRes * nTessellationRes );
	indexDesc.m_pDebugName = "sphereib";
	indexDesc.m_pBudgetGroupName = "shapes";
	m_hSphereIB = g_pRenderDevice->CreateIndexBuffer( RENDER_BUFFER_TYPE_STATIC, indexDesc );

	// fill in the index buffer
	CIndexData<uint16> ib( pRenderContext, m_hSphereIB );
	ib.Lock( indexDesc.m_nElementCount );
	m_nNumTriangles = 0;
	// generate the fixed tesselation
	for( int u = 0; u < nTessellationRes; u += 1 )
	{
		int nu = ( u + 1 ) % nTessellationRes;
		for( int v = 0; v < nTessellationRes; v++ )
		{
			int nv = ( v + 1 ) % nTessellationRes;
			ib.Index2( u * nTessellationRes + v, nu * nTessellationRes + v );
			ib.Index2( u * nTessellationRes + nv, nu * nTessellationRes + v);
			ib.Index2( nu * nTessellationRes + nv, u * nTessellationRes + nv );
			m_nNumTriangles += 2;
		}
	}
	ib.Unlock( );

	m_nSphereIndices = indexDesc.m_nElementCount;

	// VB
	int nVertices = ( nTessellationRes ) * ( nTessellationRes );

	BufferDesc_t vertexDesc;
	vertexDesc.m_nElementSizeInBytes = sizeof(SphereVertex_t);
	vertexDesc.m_nElementCount = nVertices;
	vertexDesc.m_pDebugName = "spherevb";
	vertexDesc.m_pBudgetGroupName = "shapes";
	m_hSphereVB = g_pRenderDevice->CreateVertexBuffer( RENDER_BUFFER_TYPE_STATIC, vertexDesc );

	CVertexData<SphereVertex_t> vb( pRenderContext, m_hSphereVB );
	vb.Lock( nVertices );

	for( int u = 0 ; u < nTessellationRes; u++ )
	{
		float flU = u * ( 1.0 / nTessellationRes );
		for( int v = 0; v < nTessellationRes; v++ )
		{
			float flV = v * ( 1.0 / nTessellationRes );
			Vector pos1 = Evaluate( flU + 0.5 / nTessellationRes, flV, vRadius );
			vb->m_vPos = pos1;
			vb.AdvanceVertex();
		}
	}
	vb.Unlock( );

	static RenderInputLayoutField_t sphereLayout[] =
	{
		DEFINE_PER_VERTEX_FIELD( 0, "position", 0, SphereVertex_t, m_vPos )
	};

	m_hSphereLayout = g_pRenderDevice->CreateInputLayout( "spherelayout", ARRAYSIZE( sphereLayout ), sphereLayout );

	pRenderContext->Submit();
}


void CWorldRendererTest::CreateHemi( int nTessellationRes )
{
	Vector vRadius(1,1,1);
	CRenderContextPtr pRenderContext( g_pRenderDevice );

	// create the static index buffer
	BufferDesc_t indexDesc;
	indexDesc.m_nElementSizeInBytes = sizeof(uint16);
	indexDesc.m_nElementCount = 2 * 3 * ( nTessellationRes * nTessellationRes );
	indexDesc.m_pDebugName = "hemiIB";
	indexDesc.m_pBudgetGroupName = "shapes";
	m_hHemiIB = g_pRenderDevice->CreateIndexBuffer( RENDER_BUFFER_TYPE_STATIC, indexDesc );

	// fill in the index buffer
	CIndexData<uint16> ib( pRenderContext, m_hHemiIB );
	ib.Lock( indexDesc.m_nElementCount );
	// generate the fixed tesselation
	for( int u = 0; u < nTessellationRes; u += 1 )
	{
		int nu = ( u + 1 ) % nTessellationRes;
		for( int v = 0; v < nTessellationRes; v++ )
		{
			int nv = ( v + 1 ) % nTessellationRes;
			ib.Index2( u * nTessellationRes + v, nu * nTessellationRes + v );
			ib.Index2( u * nTessellationRes + nv, nu * nTessellationRes + v);
			ib.Index2( nu * nTessellationRes + nv, u * nTessellationRes + nv );

		}
	}
	ib.Unlock( );

	m_nHemiIndices = indexDesc.m_nElementCount;

	// VB
	int nVertices = ( nTessellationRes ) * ( nTessellationRes );

	BufferDesc_t vertexDesc;
	vertexDesc.m_nElementSizeInBytes = sizeof(SphereVertex_t);
	vertexDesc.m_nElementCount = nVertices;
	vertexDesc.m_pDebugName = "hemiVB";
	vertexDesc.m_pBudgetGroupName = "shapes";
	m_hHemiVB = g_pRenderDevice->CreateVertexBuffer( RENDER_BUFFER_TYPE_STATIC, vertexDesc );

	CVertexData<SphereVertex_t> vb( pRenderContext, m_hHemiVB );
	vb.Lock( nVertices );

	for( int u = 0 ; u < nTessellationRes; u++ )
	{
		float flU = u * ( 1.0 / nTessellationRes );
		for( int v = 0; v < nTessellationRes; v++ )
		{
			float flV = v * ( 1.0 / nTessellationRes );
			Vector pos1 = Evaluate( flU + 0.5 / nTessellationRes, flV, vRadius );
			if ( pos1.z < 0 )
				pos1.z = 0;
			vb->m_vPos = pos1;
			vb.AdvanceVertex();
		}
	}
	vb.Unlock( );

	pRenderContext->Submit();
}

void CWorldRendererTest::CreateCone( int nTessellationRes )
{
	CRenderContextPtr pRenderContext( g_pRenderDevice );

	Vector vTop(0,0,0);

	int nVertices = nTessellationRes + 1;
	int nIndices = ( nTessellationRes + nTessellationRes - 2 ) * 3;

	// create the static index buffer
	BufferDesc_t indexDesc;
	indexDesc.m_nElementSizeInBytes = sizeof(uint16);
	indexDesc.m_nElementCount = nIndices;
	indexDesc.m_pDebugName = "coneib";
	indexDesc.m_pBudgetGroupName = "shapes";
	m_hConeIB = g_pRenderDevice->CreateIndexBuffer( RENDER_BUFFER_TYPE_STATIC, indexDesc );

	// create the static vertex buffer
	BufferDesc_t vertexDesc;
	vertexDesc.m_nElementSizeInBytes = sizeof(SphereVertex_t);
	vertexDesc.m_nElementCount = nVertices;
	vertexDesc.m_pDebugName = "conevb";
	vertexDesc.m_pBudgetGroupName = "shapes";
	m_hConeVB = g_pRenderDevice->CreateVertexBuffer( RENDER_BUFFER_TYPE_STATIC, vertexDesc );

	m_nConeIndices = nIndices;

	CVertexData<SphereVertex_t> vb( pRenderContext, m_hConeVB );
	vb.Lock( nVertices );

	vb->m_vPos = vTop;
	vb.AdvanceVertex();

	float flTesRes = (float)nTessellationRes;
	for ( int i=0; i<nTessellationRes; ++i )
	{
		float flU = ( i / flTesRes ) * (2.0 * M_PI);

		Vector vPos = Vector( 1.1f * cos( flU ), 1.1f * sin( flU ), 1 );

		vb->m_vPos = vPos;
		vb.AdvanceVertex();
	}

	vb.Unlock();

	CIndexData<uint16> ib( pRenderContext, m_hConeIB );
	ib.Lock( indexDesc.m_nElementCount );

	// Cone
	for ( int i=1; i<nTessellationRes+1; ++i )
	{
		ib.Index( 0 );
		ib.Index( i );
		ib.Index( ( i % nTessellationRes ) + 1 );
	}

	// Cap
	for ( int i=2; i<nTessellationRes; ++i )
	{
		ib.Index( ( i + 1 ) );
		ib.Index( i );
		ib.Index( 1 );
	}

	ib.Unlock();
}

bool LoadFile( char *pFileName, CUtlBuffer &buffer, const char *pShaderVersion )
{
	Assert( pFileName && pShaderVersion );

	char pLocalFileName[260];
	Q_snprintf( pLocalFileName, 260, "%s.%s", pFileName, pShaderVersion );

	if ( !g_pFullFileSystem->ReadFile( pLocalFileName, NULL, buffer ) )
	{
		Error( "Couldn't load %s!\n", pFileName );
		return false;
	}
	return true;
}

RenderShaderHandle_t CWorldRendererTest::GetVertexShader( char *pShaderName, IRenderDevice *pDevice, const char *pShaderVersion, const char *pDefineText )
{
	CUtlBuffer buffer;

	char pLevelText[100];
	if ( 0 == Q_strncmp( pShaderVersion, "vs_3_0", 6 ) ||
		 0 == Q_strncmp( pShaderVersion, "ps_3_0", 6 ) )
		Q_snprintf( pLevelText, 100, "#define SHADER_LEVEL 3\n" );
	else
		Q_snprintf( pLevelText, 100, "#define SHADER_LEVEL 4\n" );
	buffer.Put( pLevelText, strlen( pLevelText ) );

	if ( pDefineText )
		buffer.Put( pDefineText, strlen( pDefineText ) );

	if ( !LoadFile( pShaderName, buffer, "vs_3_0" ) )
	{
		return RENDER_SHADER_HANDLE_INVALID;
	}

	char *pText = (char*)buffer.Base();
	int nBytes = buffer.TellPut();
	if ( nBytes < 1 )
		return RENDER_SHADER_HANDLE_INVALID;

	// Create the shader
	return pDevice->CreateShader( RENDER_VERTEX_SHADER, pText, nBytes, pShaderVersion );
}

RenderShaderHandle_t CWorldRendererTest::GetPixelShader( char *pShaderName, IRenderDevice *pDevice, const char *pShaderVersion, const char *pDefineText )
{
	CUtlBuffer buffer;

	char pLevelText[100];
	if ( 0 == Q_strncmp( pShaderVersion, "ps_3_0", 6 ) )
		Q_snprintf( pLevelText, 100, "#define SHADER_LEVEL 3\n" );
	else
		Q_snprintf( pLevelText, 100, "#define SHADER_LEVEL 4\n" );
	buffer.Put( pLevelText, strlen( pLevelText ) );

	if ( pDefineText )
		buffer.Put( pDefineText, strlen( pDefineText ) );

	if ( !LoadFile( pShaderName, buffer, "ps_3_0" ) )
	{
		return RENDER_SHADER_HANDLE_INVALID;
	}

	char *pText = (char*)buffer.Base();
	int nBytes = buffer.TellPut();
	if ( nBytes < 1 )
		return RENDER_SHADER_HANDLE_INVALID;

	// Create the shader
	return pDevice->CreateShader( RENDER_PIXEL_SHADER, pText, nBytes, pShaderVersion );
}


intp g_nMagicNumber = 1234567;
HRenderTexture CWorldRendererTest::CreateRenderTarget( RenderTargetType_t type, const RenderViewport_t &viewport )
{
	HRenderTexture hRetHandle = RENDER_TEXTURE_HANDLE_INVALID;
	TextureHeader_t spec;
	
	spec.m_nNumMipLevels = 1;
	spec.m_nDepth = 1;
	spec.m_Reflectivity.Init( 1, 1, 1 );

	int nLowResWidth = (int)( viewport.m_nWidth * m_flLowResBufferScale );
	int nLowResHeight = (int)( viewport.m_nHeight * m_flLowResBufferScale );

	ImageFormat ssaoFormat = IMAGE_FORMAT_A8;
	if ( g_nPlatform == RST_PLATFORM_DX11 )
		ssaoFormat = IMAGE_FORMAT_RGBA8888;

	switch ( type )
	{
	case DS_SHADOW_DEPTH0:
	case DS_SHADOW_DEPTH1:
	case DS_SHADOW_DEPTH2:
		{
			spec.m_nWidth = m_nShadowSize;
			spec.m_nHeight = m_nShadowSize;
			spec.m_nFlags = TSPEC_UNFILTERABLE_OK | TSPEC_RENDER_TARGET_SAMPLEABLE;
			spec.m_nImageFormat = IMAGE_FORMAT_D24X8/*IMAGE_FORMAT_D16*/;
		}
		break;

	case DS_SHADOW_DEPTH_MULTIPLE:
		{
			spec.m_nWidth = m_nShadowSize;
			spec.m_nHeight = m_nShadowSize;
			spec.m_nFlags = TSPEC_UNFILTERABLE_OK | TSPEC_RENDER_TARGET_SAMPLEABLE;
			spec.m_nImageFormat = IMAGE_FORMAT_D24X8/*IMAGE_FORMAT_D16*/;
		}
		break;

	case RT_SHADOW_MULTIPLE_0:
	case RT_SHADOW_MULTIPLE_1:
	case RT_SHADOW_BLUR_TEMP:
		{
			spec.m_nWidth = m_nShadowSize;
			spec.m_nHeight = m_nShadowSize;
			spec.m_nFlags = TSPEC_RENDER_TARGET;
			spec.m_nImageFormat = IMAGE_FORMAT_RG1616F;
		}
		break;

	case DS_DEPTH_HIGHRES:
		{
			spec.m_nWidth = viewport.m_nWidth;
			spec.m_nHeight = viewport.m_nHeight;
			spec.m_nFlags = TSPEC_UNFILTERABLE_OK | TSPEC_RENDER_TARGET_SAMPLEABLE;
			spec.m_nImageFormat = IMAGE_FORMAT_D24S8;
		}
		break;
	case RT_VIEW_DEPTH_HIGHRES:
		{
			spec.m_nWidth = viewport.m_nWidth;
			spec.m_nHeight = viewport.m_nHeight;
			spec.m_nFlags = TSPEC_RENDER_TARGET | TSPEC_UNFILTERABLE_OK | TSPEC_RENDER_TARGET_SAMPLEABLE;
			spec.m_nImageFormat = IMAGE_FORMAT_R32F;
		}
		break;
	case RT_VIEW_NORMAL_HIGHRES:
		{
			spec.m_nWidth = viewport.m_nWidth;
			spec.m_nHeight = viewport.m_nHeight;
			spec.m_nFlags = TSPEC_RENDER_TARGET | TSPEC_UNFILTERABLE_OK | TSPEC_RENDER_TARGET_SAMPLEABLE;
			spec.m_nImageFormat = IMAGE_FORMAT_RGBA1010102;
		}
		break;
	case RT_VIEW_SPEC_HIGHRES:
		{
			spec.m_nWidth = viewport.m_nWidth;
			spec.m_nHeight = viewport.m_nHeight;
			spec.m_nFlags = TSPEC_RENDER_TARGET | TSPEC_UNFILTERABLE_OK | TSPEC_RENDER_TARGET_SAMPLEABLE;
			spec.m_nImageFormat = IMAGE_FORMAT_BGRA8888;
			if ( g_nPlatform == RST_PLATFORM_DX11 )
			{
				spec.m_nImageFormat = IMAGE_FORMAT_RGBA8888;
			}
		}
		break;
	case RT_LIGHTING_HIGHRES:
		{
			spec.m_nWidth = viewport.m_nWidth;
			spec.m_nHeight = viewport.m_nHeight;
			spec.m_nFlags = TSPEC_RENDER_TARGET | TSPEC_UNFILTERABLE_OK | TSPEC_RENDER_TARGET_SAMPLEABLE;
			spec.m_nImageFormat = IMAGE_FORMAT_RGBA16161616F;
			/*
			if ( g_nPlatform == RST_PLATFORM_DX11 )
			{
				spec.m_nImageFormat = IMAGE_FORMAT_RGBA8888;
			}
			*/
		}
		break;
	case RT_SPECULAR_HIGHRES:
		{
			spec.m_nWidth = viewport.m_nWidth;
			spec.m_nHeight = viewport.m_nHeight;
			spec.m_nFlags = TSPEC_RENDER_TARGET | TSPEC_UNFILTERABLE_OK | TSPEC_RENDER_TARGET_SAMPLEABLE;
			spec.m_nImageFormat = IMAGE_FORMAT_BGRA8888;
			if ( g_nPlatform == RST_PLATFORM_DX11 )
			{
				spec.m_nImageFormat = IMAGE_FORMAT_RGBA8888;
			}
		}
		break;
	case DS_DEPTH_LOWRES:
		{
			spec.m_nWidth = nLowResWidth;
			spec.m_nHeight = nLowResHeight;
			spec.m_nFlags = 0;
			spec.m_nImageFormat = IMAGE_FORMAT_D24S8;
		}
		break;
	case RT_VIEW_DEPTH_LOWRES:
		{
			spec.m_nWidth = nLowResWidth;
			spec.m_nHeight = nLowResHeight;
			spec.m_nFlags = TSPEC_RENDER_TARGET | TSPEC_UNFILTERABLE_OK | TSPEC_RENDER_TARGET_SAMPLEABLE;
			spec.m_nImageFormat = IMAGE_FORMAT_R32F;
		}
		break;
	case RT_VIEW_NORMAL_LOWRES:
		{
			spec.m_nWidth = nLowResWidth;
			spec.m_nHeight = nLowResHeight;
			spec.m_nFlags = TSPEC_RENDER_TARGET | TSPEC_UNFILTERABLE_OK | TSPEC_RENDER_TARGET_SAMPLEABLE;
			spec.m_nImageFormat = IMAGE_FORMAT_RGBA1010102;
		}
		break;
	case RT_LIGHTING_LOWRES:
		{
			spec.m_nWidth = nLowResWidth;
			spec.m_nHeight = nLowResHeight;
			spec.m_nFlags = TSPEC_RENDER_TARGET | TSPEC_UNFILTERABLE_OK | TSPEC_RENDER_TARGET_SAMPLEABLE;
			spec.m_nImageFormat = IMAGE_FORMAT_BGRA8888;
			if ( g_nPlatform == RST_PLATFORM_DX11 )
			{
				spec.m_nImageFormat = IMAGE_FORMAT_RGBA8888;
			}
		}
		break;
	case RT_LIGHTING_TEMP_LOWRES:
		{
			spec.m_nWidth = nLowResWidth;
			spec.m_nHeight = nLowResHeight;
			spec.m_nFlags = TSPEC_RENDER_TARGET | TSPEC_UNFILTERABLE_OK | TSPEC_RENDER_TARGET_SAMPLEABLE;
			spec.m_nImageFormat = IMAGE_FORMAT_BGRA8888;
			if ( g_nPlatform == RST_PLATFORM_DX11 )
			{
				spec.m_nImageFormat = IMAGE_FORMAT_RGBA8888;
			}
		}
		break;

	default:
		return RENDER_TEXTURE_HANDLE_INVALID;
	}

	char pResourceName[16];
	Q_snprintf( pResourceName, sizeof(pResourceName), "%d", g_nMagicNumber );
	++g_nMagicNumber;
	hRetHandle = g_pRenderDevice->FindOrCreateTexture( "worldrenderer", pResourceName, &spec );
	return hRetHandle;
}

RenderTargetBinding_t CWorldRendererTest::CreateRenderTargetBinding( ViewBindingType_t type, const RenderViewport_t &viewport )
{
	RenderTargetBinding_t hRetHandle = RENDER_TARGET_BINDING_INVALID;
	HRenderTexture pRenderTargets[ 4 ] = { RENDER_TEXTURE_HANDLE_INVALID, RENDER_TEXTURE_HANDLE_INVALID, RENDER_TEXTURE_HANDLE_INVALID, RENDER_TEXTURE_HANDLE_INVALID };
	HRenderTexture hDepthStencil;
	int nTargets = 0;
	int nFlags = 0;

	RenderViewport_t lowResViewport = viewport;
	lowResViewport.m_nWidth = (int)( viewport.m_nWidth * m_flLowResBufferScale );
	lowResViewport.m_nHeight = (int)( viewport.m_nHeight * m_flLowResBufferScale );

	CWorldRenderFrustum *pFrustum = NULL;
	RenderViewport_t targetViewport;
	int nViewFlags = VIEW_PLAYER_CAMERA;
	int nViewPass = 0;

	switch ( type )
	{
	case RTB_SHADOW_DEPTH0:
	case RTB_SHADOW_DEPTH1:
	case RTB_SHADOW_DEPTH2:
		{
			nTargets = 1;
			pRenderTargets[0] = m_pRenderTargets[ RT_SHADOW_MULTIPLE_0 ];
			hDepthStencil = m_pRenderTargets[ type - DS_SHADOW_DEPTH0 ];
			nFlags = DISCARD_CONTENTS;

			pFrustum = m_pSplitFrustums[ type - DS_SHADOW_DEPTH0 ];
			targetViewport = m_shadowViewport;
			nViewFlags = VIEW_LIGHT_SHADOW;
			nViewPass = VARIATION_DEPTH;
		}
		break;
	case RTB_SHADOW_DEPTH_MULTIPLE_0:
	case RTB_SHADOW_DEPTH_MULTIPLE_1:
	case RTB_SHADOW_DEPTH_MULTIPLE_2:
	case RTB_SHADOW_DEPTH_MULTIPLE_3:
	case RTB_SHADOW_DEPTH_MULTIPLE_4:
	case RTB_SHADOW_DEPTH_MULTIPLE_5:
	case RTB_SHADOW_DEPTH_MULTIPLE_6:
	case RTB_SHADOW_DEPTH_MULTIPLE_7:
	case RTB_SHADOW_DEPTH_MULTIPLE_8:
	case RTB_SHADOW_DEPTH_MULTIPLE_9:
	case RTB_SHADOW_DEPTH_MULTIPLE_10:
	case RTB_SHADOW_DEPTH_MULTIPLE_11:
	case RTB_SHADOW_DEPTH_MULTIPLE_12:
	case RTB_SHADOW_DEPTH_MULTIPLE_13:
	case RTB_SHADOW_DEPTH_MULTIPLE_14:
	case RTB_SHADOW_DEPTH_MULTIPLE_15:
	case RTB_SHADOW_DEPTH_MULTIPLE_16:
	case RTB_SHADOW_DEPTH_MULTIPLE_17:
	case RTB_SHADOW_DEPTH_MULTIPLE_18:
	case RTB_SHADOW_DEPTH_MULTIPLE_19:
	case RTB_SHADOW_DEPTH_MULTIPLE_20:
	case RTB_SHADOW_DEPTH_MULTIPLE_21:
	case RTB_SHADOW_DEPTH_MULTIPLE_22:
	case RTB_SHADOW_DEPTH_MULTIPLE_23:
	case RTB_SHADOW_DEPTH_MULTIPLE_24:
	case RTB_SHADOW_DEPTH_MULTIPLE_25:
	case RTB_SHADOW_DEPTH_MULTIPLE_26:
	case RTB_SHADOW_DEPTH_MULTIPLE_27:
	case RTB_SHADOW_DEPTH_MULTIPLE_28:
	case RTB_SHADOW_DEPTH_MULTIPLE_29:
	case RTB_SHADOW_DEPTH_MULTIPLE_30:
	case RTB_SHADOW_DEPTH_MULTIPLE_31:
		{
			int nFrustum = type - RTB_SHADOW_DEPTH_MULTIPLE_0;

			nTargets = 1;
			if ( nFrustum < NUM_HIGH_RES_SHADOWS )
				pRenderTargets[0] = m_pRenderTargets[ RT_SHADOW_MULTIPLE_0 ];
			else
				pRenderTargets[0] = m_pRenderTargets[ RT_SHADOW_MULTIPLE_1 ];

			hDepthStencil = m_pRenderTargets[ DS_SHADOW_DEPTH_MULTIPLE ];
			nFlags = PRESERVE_DEPTHSTENCIL;//DISCARD_CONTENTS;

			if ( nFrustum < NUM_MULTI_SHADOWS )
			{
				pFrustum = m_pMultiShadowFrustums[ nFrustum ];
				targetViewport = m_multiShadowViewport[ nFrustum ];
			}
			else
			{
				pFrustum = NULL;
				targetViewport = viewport;
			}
			nViewFlags = VIEW_LIGHT_SHADOW;
			nViewPass = VARIATION_DEPTH;
		}
		break;

	case RTB_DEFERRED_DEPTH_NORM_SPEC:
		{
			nTargets = 3;
			pRenderTargets[0] = m_pRenderTargets[ RT_VIEW_NORMAL_HIGHRES ];
			pRenderTargets[1] = m_pRenderTargets[ RT_VIEW_DEPTH_HIGHRES ];
			pRenderTargets[2] = m_pRenderTargets[ RT_VIEW_SPEC_HIGHRES ];
			hDepthStencil = m_pRenderTargets[ DS_DEPTH_HIGHRES ];
			nFlags = DISCARD_CONTENTS;

			pFrustum = m_pFrustum;
			targetViewport = viewport;
			nViewFlags = VIEW_PLAYER_CAMERA;
			nViewPass = VARIATION_NORM_DEPTH_SPEC;
		}
		break;
	case RTB_DEFERRED_SCALE_DOWN:
		{
			nTargets = 2;
			pRenderTargets[0] = m_pRenderTargets[ RT_VIEW_DEPTH_LOWRES ];
			pRenderTargets[1] = m_pRenderTargets[ RT_VIEW_NORMAL_LOWRES ];
			hDepthStencil = m_pRenderTargets[ DS_DEPTH_LOWRES ];
			nFlags = PRESERVE_DEPTHSTENCIL;

			pFrustum = m_pFrustum;
			targetViewport = lowResViewport;
			nViewFlags = VIEW_PLAYER_CAMERA | VIEW_POST_PROCESS;
			nViewPass = VARIATION_DEFAULT;
		}
		break;
	case RTB_DEFERRED_NORM_SPEC:
		{
			nTargets = 2;
			pRenderTargets[0] = m_pRenderTargets[ RT_VIEW_NORMAL_HIGHRES ];
			pRenderTargets[1] = m_pRenderTargets[ RT_VIEW_SPEC_HIGHRES ];
			hDepthStencil = m_pRenderTargets[ DS_DEPTH_HIGHRES ];
			nFlags = PRESERVE_CONTENTS;

			pFrustum = m_pFrustum;
			targetViewport = viewport;
			nViewFlags = VIEW_PLAYER_CAMERA | VIEW_DECALS;
			nViewPass = 0;
		}
		break;
	case RTB_CLEAR_SPEC_HIGHRES:
		{
			nTargets = 1;
			pRenderTargets[0] = m_pRenderTargets[ RT_SPECULAR_HIGHRES ];
			hDepthStencil = RENDER_TEXTURE_HANDLE_INVALID;
			nFlags = 0;

			pFrustum = m_pFrustum;
			targetViewport = viewport;
			nViewFlags = VIEW_PLAYER_CAMERA | VIEW_LIGHTING;
			nViewPass = VARIATION_DEFAULT;
		}
		break;
	case RTB_LIGHTING_HIGHRES:
		{
			nTargets = 2;
			pRenderTargets[0] = m_pRenderTargets[ RT_LIGHTING_HIGHRES ];
			pRenderTargets[1] = m_pRenderTargets[ RT_SPECULAR_HIGHRES ];
			hDepthStencil = m_pRenderTargets[ DS_DEPTH_HIGHRES ];
			nFlags = PRESERVE_DEPTHSTENCIL;

			pFrustum = m_pFrustum;
			targetViewport = viewport;
			nViewFlags = VIEW_PLAYER_CAMERA | VIEW_LIGHTING;
			nViewPass = VARIATION_DEFAULT;
		}
		break;
	case RTB_LIGHTING_LOWRES:
		{
			nTargets = 1;
			pRenderTargets[0] = m_pRenderTargets[ RT_LIGHTING_LOWRES ];
			hDepthStencil = m_pRenderTargets[ DS_DEPTH_LOWRES ];
			nFlags = PRESERVE_DEPTHSTENCIL;

			pFrustum = m_pFrustum;
			targetViewport = lowResViewport;
			nViewFlags = VIEW_PLAYER_CAMERA | VIEW_LIGHTING;
			nViewPass = VARIATION_DEFAULT;
		}
		break;
	case RTB_SSAO_LOWRES:
		{
			nTargets = 1;
			pRenderTargets[0] = m_pRenderTargets[ RT_LIGHTING_LOWRES ];
			hDepthStencil = RENDER_TEXTURE_HANDLE_INVALID;
			nFlags = 0;

			pFrustum = NULL;
			targetViewport = lowResViewport;
			nViewFlags = VIEW_PLAYER_CAMERA | VIEW_POST_PROCESS;
			nViewPass = VARIATION_DEFAULT;
		}
		break;
	case RTB_BILAT_UPSAMPLE_0:
		{
			nTargets = 1;
			pRenderTargets[0] = m_pRenderTargets[ RT_LIGHTING_TEMP_LOWRES ];
			hDepthStencil = RENDER_TEXTURE_HANDLE_INVALID;
			nFlags = 0;

			pFrustum = NULL;
			targetViewport = lowResViewport;
			nViewFlags = VIEW_PLAYER_CAMERA | VIEW_POST_PROCESS;
			nViewPass = VARIATION_DEFAULT;
		}
		break;
	case RTB_BILAT_UPSAMPLE_1:
		{
			nTargets = 1;
			pRenderTargets[0] = m_pRenderTargets[ RT_LIGHTING_HIGHRES ];
			hDepthStencil = RENDER_TEXTURE_HANDLE_INVALID;
			nFlags = 0;

			pFrustum = NULL;
			targetViewport = viewport;
			nViewFlags = VIEW_PLAYER_CAMERA | VIEW_POST_PROCESS;
			nViewPass = VARIATION_DEFAULT;
		}
		break;
	case RTB_LIGHT_BLUR_0:
		{
			nTargets = 1;
			pRenderTargets[0] = m_pRenderTargets[ RT_VIEW_SPEC_HIGHRES ];
			hDepthStencil = RENDER_TEXTURE_HANDLE_INVALID;
			nFlags = 0;

			pFrustum = NULL;
			targetViewport = viewport;
			nViewFlags = VIEW_PLAYER_CAMERA | VIEW_POST_PROCESS;
			nViewPass = VARIATION_DEFAULT;
		}
		break;
	case RTB_LIGHT_BLUR_1:
		{
			nTargets = 1;
			pRenderTargets[0] = m_pRenderTargets[ RT_LIGHTING_HIGHRES ];
			hDepthStencil = RENDER_TEXTURE_HANDLE_INVALID;
			nFlags = 0;

			pFrustum = NULL;
			targetViewport = viewport;
			nViewFlags = VIEW_PLAYER_CAMERA | VIEW_POST_PROCESS;
			nViewPass = VARIATION_DEFAULT;
		}
		break;
	case RTB_SHADOW_BLUR_0:
		{
			nTargets = 1;
			pRenderTargets[0] = m_pRenderTargets[ RT_SHADOW_BLUR_TEMP ];
			hDepthStencil = RENDER_TEXTURE_HANDLE_INVALID;
			nFlags = 0;

			pFrustum = NULL;
			targetViewport = m_shadowViewport;
			nViewFlags = VIEW_LIGHT_SHADOW | VIEW_POST_PROCESS;
			nViewPass = VARIATION_DEFAULT;
		}
		break;
	case RTB_SHADOW_BLUR_1:
		{
			nTargets = 1;
			pRenderTargets[0] = m_pRenderTargets[ RT_SHADOW_MULTIPLE_0 ];
			hDepthStencil = RENDER_TEXTURE_HANDLE_INVALID;
			nFlags = 0;

			pFrustum = NULL;
			targetViewport = m_shadowViewport;
			nViewFlags = VIEW_LIGHT_SHADOW | VIEW_POST_PROCESS;
			nViewPass = VARIATION_DEFAULT;
		}
		break;
	case RTB_SHADOW_BLUR_2:
		{
			nTargets = 1;
			pRenderTargets[0] = m_pRenderTargets[ RT_SHADOW_MULTIPLE_1 ];
			hDepthStencil = RENDER_TEXTURE_HANDLE_INVALID;
			nFlags = 0;

			pFrustum = NULL;
			targetViewport = m_shadowViewport;
			nViewFlags = VIEW_LIGHT_SHADOW | VIEW_POST_PROCESS;
			nViewPass = VARIATION_DEFAULT;
		}
		break;
	case RTB_SAMPLE_LIGHTING:
		{
			nTargets = 1;
			pRenderTargets[0] = RENDER_TEXTURE_DEFAULT_RENDER_TARGET;
			hDepthStencil = m_pRenderTargets[ DS_DEPTH_HIGHRES ];
			nFlags = PRESERVE_DEPTHSTENCIL;

			pFrustum = m_pFrustum;
			targetViewport = viewport;
			nViewFlags = VIEW_PLAYER_CAMERA;
			nViewPass = VARIATION_SAMPLE_LIGHTING;
		}
		break;
	case RTB_AERIAL_PERSPECTIVE:
		{
			nTargets = 1;
			pRenderTargets[0] = RENDER_TEXTURE_DEFAULT_RENDER_TARGET;
			hDepthStencil = m_pRenderTargets[ DS_DEPTH_HIGHRES ];
			nFlags = PRESERVE_DEPTHSTENCIL;

			pFrustum = NULL;
			targetViewport = viewport;
			nViewFlags = VIEW_PLAYER_CAMERA | VIEW_POST_PROCESS;
			nViewPass = VARIATION_DEFAULT;
		}
		break;
	case RTB_SKY:
		{
			nTargets = 1;
			pRenderTargets[0] = RENDER_TEXTURE_DEFAULT_RENDER_TARGET;
			hDepthStencil = m_pRenderTargets[ DS_DEPTH_HIGHRES ];
			nFlags = PRESERVE_DEPTHSTENCIL;

			pFrustum = m_pFrustum;
			targetViewport = viewport;
			nViewFlags = VIEW_PLAYER_CAMERA | VIEW_POST_PROCESS;
			nViewPass = VARIATION_DEFAULT;
		}
		break;
	case RTB_FORWARD:
		{
			nTargets = 1;
			pRenderTargets[0] = RENDER_TEXTURE_DEFAULT_RENDER_TARGET;
			hDepthStencil = RENDER_TEXTURE_DEFAULT_RENDER_TARGET;
			nFlags = PRESERVE_DEPTHSTENCIL;

			pFrustum = m_pFrustum;
			targetViewport = viewport;
			nViewFlags = VIEW_PLAYER_CAMERA;
			nViewPass = VARIATION_DEFAULT;
		}
		break;

	default:
		return RENDER_TARGET_BINDING_INVALID;
	}

	hRetHandle = g_pRenderDevice->CreateRenderTargetBinding( nFlags, nTargets, pRenderTargets, hDepthStencil );
	m_pRenderViews[ type ].Init( g_pRenderDevice, pFrustum, hRetHandle, targetViewport, (RenderViewFlags_t)nViewFlags, nViewPass, type );

	return hRetHandle;
}

void CWorldRendererTest::SetStateForRenderViewType( IRenderContext *pRenderContext, int nRenderView )
{
	switch ( nRenderView )
	{
	case RTB_SHADOW_DEPTH0:
	case RTB_SHADOW_DEPTH1:
	case RTB_SHADOW_DEPTH2:
		{
			pRenderContext->SetBlendMode( RENDER_BLEND_NOPIXELWRITE );
			pRenderContext->SetZBufferMode( RENDER_ZBUFFER_ZTEST_AND_WRITE );
			pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_NONE );
		}
		break;
	case RTB_SHADOW_DEPTH_MULTIPLE_0:
	case RTB_SHADOW_DEPTH_MULTIPLE_1:
	case RTB_SHADOW_DEPTH_MULTIPLE_2:
	case RTB_SHADOW_DEPTH_MULTIPLE_3:
	case RTB_SHADOW_DEPTH_MULTIPLE_4:
	case RTB_SHADOW_DEPTH_MULTIPLE_5:
	case RTB_SHADOW_DEPTH_MULTIPLE_6:
	case RTB_SHADOW_DEPTH_MULTIPLE_7:
	case RTB_SHADOW_DEPTH_MULTIPLE_8:
	case RTB_SHADOW_DEPTH_MULTIPLE_9:
	case RTB_SHADOW_DEPTH_MULTIPLE_10:
	case RTB_SHADOW_DEPTH_MULTIPLE_11:
	case RTB_SHADOW_DEPTH_MULTIPLE_12:
	case RTB_SHADOW_DEPTH_MULTIPLE_13:
	case RTB_SHADOW_DEPTH_MULTIPLE_14:
	case RTB_SHADOW_DEPTH_MULTIPLE_15:
	case RTB_SHADOW_DEPTH_MULTIPLE_16:
	case RTB_SHADOW_DEPTH_MULTIPLE_17:
	case RTB_SHADOW_DEPTH_MULTIPLE_18:
	case RTB_SHADOW_DEPTH_MULTIPLE_19:
	case RTB_SHADOW_DEPTH_MULTIPLE_20:
	case RTB_SHADOW_DEPTH_MULTIPLE_21:
	case RTB_SHADOW_DEPTH_MULTIPLE_22:
	case RTB_SHADOW_DEPTH_MULTIPLE_23:
	case RTB_SHADOW_DEPTH_MULTIPLE_24:
	case RTB_SHADOW_DEPTH_MULTIPLE_25:
	case RTB_SHADOW_DEPTH_MULTIPLE_26:
	case RTB_SHADOW_DEPTH_MULTIPLE_27:
	case RTB_SHADOW_DEPTH_MULTIPLE_28:
	case RTB_SHADOW_DEPTH_MULTIPLE_29:
	case RTB_SHADOW_DEPTH_MULTIPLE_30:
	case RTB_SHADOW_DEPTH_MULTIPLE_31:
		{
			pRenderContext->SetBlendMode( RENDER_BLEND_NONE );
			pRenderContext->SetZBufferMode( RENDER_ZBUFFER_ZTEST_AND_WRITE );
			pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );
		}
		break;

	case RTB_DEFERRED_DEPTH_NORM_SPEC:
		{
			pRenderContext->SetBlendMode( RENDER_BLEND_NONE );
			pRenderContext->SetZBufferMode( RENDER_ZBUFFER_ZTEST_AND_WRITE_STENCIL_SET1 );
			pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );
		}
		break;
	case RTB_DEFERRED_SCALE_DOWN:
		{
		}
		break;
	case RTB_DEFERRED_NORM_SPEC:
		{
		}
		break;
	case RTB_LIGHTING_HIGHRES:
		{
		}
		break;
	case RTB_LIGHTING_LOWRES:
		{
		}
		break;
	case RTB_SSAO_LOWRES:
		{
		}
		break;
	case RTB_BILAT_UPSAMPLE_0:
		{
		}
		break;
	case RTB_BILAT_UPSAMPLE_1:
		{
		}
		break;
	case RTB_LIGHT_BLUR_0:
		{
		}
		break;
	case RTB_LIGHT_BLUR_1:
		{
		}
		break;
	case RTB_SAMPLE_LIGHTING:
		{
			pRenderContext->SetBlendMode( RENDER_BLEND_NONE );
			pRenderContext->SetZBufferMode( RENDER_ZBUFFER_ZTEST_EQUAL_NO_WRITE );
			pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );
			
			pRenderContext->BindTexture( 4, m_pRenderTargets[ RT_LIGHTING_HIGHRES ] );
			pRenderContext->SetSamplerStatePS( 4, RS_FILTER_MIN_MAG_MIP_POINT );
			pRenderContext->BindTexture( 5, m_pRenderTargets[ RT_SPECULAR_HIGHRES ] );
			pRenderContext->SetSamplerStatePS( 5, RS_FILTER_MIN_MAG_MIP_POINT );
			
		}
		break;
	case RTB_AERIAL_PERSPECTIVE:
		{
		}
		break;
	case RTB_SKY:
		{
		}
		break;
	case RTB_FORWARD:
		{
			// viewport and state
			pRenderContext->SetBlendMode( RENDER_BLEND_NONE );
			pRenderContext->SetZBufferMode( RENDER_ZBUFFER_ZTEST_AND_WRITE );
			pRenderContext->SetCullMode( RENDER_CULLMODE_CULL_BACKFACING );

			// Bind
			for ( int s=0; s<NUM_SHADOW_SPLITS; ++s )
			{
				m_forwardLightingData.m_mShadowMatrices[s] = m_pShadowMatrices[s];
				pRenderContext->BindTexture( 4 + s, m_pRenderTargets[ DS_SHADOW_DEPTH0 + s ] );
				pRenderContext->SetSamplerStatePS( 4 + s, RS_FILTER_MIN_MAG_MIP_POINT );
			}

			pRenderContext->SetConstantBufferData( m_hLightingRelated, (void*)&m_forwardLightingData, sizeof( LightingConstants_t ) );
			pRenderContext->BindConstantBuffer( RENDER_PIXEL_SHADER, m_hLightingRelated, 0, 0 );
		}
		break;
	}
}

void CWorldRendererTest::InitRenderTargetsAndViews( const RenderViewport_t &viewport )
{
	for ( int i=0; i<MAX_RENDER_TARGET_TYPES; ++i )
	{
		m_pRenderTargets[i] = CreateRenderTarget( (RenderTargetType_t)i, viewport );
	}

	for ( int i=0; i<MAX_VIEW_BINDING_TYPES; ++i )
	{
		m_pViewBindings[i] = CreateRenderTargetBinding( (ViewBindingType_t)i, viewport );
	}

	m_bRenderTargetsInit = true;
}

void CWorldRendererTest::GetDescription( char *pNameBufferOut, size_t nBufLen )
{
	if ( m_nVariant )
	{
		Q_snprintf( pNameBufferOut, nBufLen, "Render the world (deferred) (Press Space to Continue)" );
	}
	else
	{
		Q_snprintf( pNameBufferOut, nBufLen, "Render the world (forward) (Press Space to Continue)" );
	}
}

//-----------------------------------------------------------------------------
// Can this test be run?
//-----------------------------------------------------------------------------
bool CWorldRendererTest::CanBeRun()
{ 
	return ( g_pWorldRendererMgr != NULL ) && m_bWorldLoaded; 
}

//-----------------------------------------------------------------------------
// check for a keypress
//-----------------------------------------------------------------------------
bool CWorldRendererTest::ProcessUserInput( const InputEvent_t &ie )
{
	if ( ie.m_nType == IE_AnalogValueChanged )
	{
		switch( ie.m_nData )
		{
		case MOUSE_XY:
			if ( m_nWindowCenterX > 0 && m_nWindowCenterY > 0 )
			{
				m_nCursorDeltaX += ie.m_nData2 - m_nWindowCenterX;
				m_nCursorDeltaY += ie.m_nData3 - m_nWindowCenterY;
			}
			break;

		case JOYSTICK_AXIS( 0, JOY_AXIS_U ):
			m_nCursorDeltaResetX = ie.m_nData2 / 300;
			m_nCursorDeltaX += m_nCursorDeltaResetX;
			break;

		case JOYSTICK_AXIS( 0, JOY_AXIS_R ):
			m_nCursorDeltaResetY = -ie.m_nData2 / 300;
			m_nCursorDeltaY += m_nCursorDeltaResetY;
			break;

		case JOYSTICK_AXIS( 0, JOY_AXIS_X ):
			if ( abs( ie.m_nData2 ) < 2 )
			{
				m_cmd.m_nKeys &= ~FKEY_RIGHT;
				m_cmd.m_nKeys &= ~FKEY_LEFT;
			}
			else if ( ie.m_nData2 > 0 )
			{
				m_cmd.m_nKeys |= FKEY_RIGHT;
				m_cmd.m_nKeys &= ~FKEY_LEFT;
			}
			else
			{
				m_cmd.m_nKeys &= ~FKEY_RIGHT;
				m_cmd.m_nKeys |= FKEY_LEFT;
			}
			break;

		case JOYSTICK_AXIS( 0, JOY_AXIS_Y ):
			if ( abs( ie.m_nData2 ) < 2 )
			{
				m_cmd.m_nKeys &= ~FKEY_FORWARD;
				m_cmd.m_nKeys &= ~FKEY_BACK;
			}
			else if ( ie.m_nData2 > 0 )
			{
				m_cmd.m_nKeys |= FKEY_FORWARD;
				m_cmd.m_nKeys &= ~FKEY_BACK;
			}
			else
			{
				m_cmd.m_nKeys &= ~FKEY_FORWARD;
				m_cmd.m_nKeys |= FKEY_BACK;
			}
			break;
		}
	}
	else if ( ie.m_nType == IE_ButtonPressed || ie.m_nType == IE_ButtonReleased )
	{
		bool bDown = (ie.m_nType == IE_ButtonPressed) ? true : false;
		ButtonCode_t code = (ButtonCode_t)ie.m_nData;
		uint nFlag = 0;
		switch( code )
		{
		case KEY_W: nFlag = FKEY_FORWARD; break;
		case KEY_S: nFlag = FKEY_BACK; break;
		case KEY_A: nFlag = FKEY_LEFT; break;
		case KEY_D: nFlag = FKEY_RIGHT; break;
		case KEY_UP: nFlag = FKEY_TURNUP; break;
		case KEY_DOWN: nFlag = FKEY_TURNDOWN; break;
		case KEY_LEFT: nFlag = FKEY_TURNLEFT; break;
		case KEY_RIGHT: nFlag = FKEY_TURNRIGHT; break;
		case KEY_XBUTTON_X: case MOUSE_LEFT: nFlag = FKEY_SHOOTDECAL; break;
		case KEY_XBUTTON_B: case KEY_N: nFlag = FKEY_SHOOTPSYSTEM; break;
		case KEY_XBUTTON_Y: case KEY_M: nFlag = FKEY_SHOOTSSYSTEM; break;
		case KEY_O: nFlag = FKEY_LIGHTELV; break;
		case KEY_XBUTTON_UP: case KEY_K: nFlag = FKEY_LIGHTANG_POS; break;
		case KEY_XBUTTON_DOWN: case KEY_L: nFlag = FKEY_LIGHTANG_NEG; break;
		case KEY_XBUTTON_LEFT_SHOULDER: case KEY_LSHIFT: nFlag = FKEY_FAST; break;
		case KEY_HOME: nFlag = FKEY_ENABLE_VIS; break;
		case KEY_END: nFlag = FKEY_DISABLE_VIS; break;
		case KEY_RSHIFT: nFlag = FKEY_DROP_FRUSTUM; break;
		case KEY_P: nFlag = FKEY_TOGGLE_AERIAL; break;
		case KEY_V: nFlag = FKEY_TOGGLE_BOUNCE; break;
		case KEY_C: nFlag = FKEY_TOGGLE_DIRECT; break;
		case KEY_B: nFlag = FKEY_TOGGLE_LIGHTING_ONLY; break;
		case KEY_PAD_ENTER: nFlag = FKEY_SSAO; break;
		case KEY_PAD_8: nFlag = FKEY_BLUR_LIGHTING; break;
		case KEY_PAD_9: nFlag = FKEY_BLUR_SHADOWS; break;
		case MOUSE_RIGHT: nFlag = FKEY_SHOOTDECAL2; break;
		case MOUSE_MIDDLE: nFlag = FKEY_SHOOTWALLMONSTER; break;
		case KEY_X:
			{
				if ( !bDown )
				{
					m_bViewLowTexture = !m_bViewLowTexture;
					if ( m_bViewLowTexture )
						Msg( "Low Texture Mode: On\n" );
					else
						Msg( "Low Texture Mode: Off\n" );
				}
				break;
			}
		case KEY_F: 
			{
				if ( !bDown )
				{
					m_bFlashlight = !m_bFlashlight;
					if ( m_bFlashlight )
						Msg( "Flashlight: On\n" );
					else
						Msg( "Flashlight: Off\n" );
				}
				break;
			}
		case KEY_G:
			{
				if ( !bDown )
				{
					Msg( "Dropped Renderable\n" );
					DropRenderable();
				}
				break;
			}
		case KEY_0:
			{
				// Reload shaders
				if ( ie.m_nType == IE_ButtonPressed )
				{
					g_pMaterialSystem2->DynamicShaderCompile_ReloadAllShaders();
					return false;
				}
				break;
			}
		case KEY_PAD_PLUS: 
			{
				m_flSampleRadius += 1.0f; 
				Msg( "SSAO Sample Radius: %f\n", m_flSampleRadius );
				break;
			}
		case KEY_PAD_MINUS: 
			{
				m_flSampleRadius -= 1.0f; 
				m_flSampleRadius = MAX( 1, m_flSampleRadius ); 
				Msg( "SSAO Sample Radius: %f\n", m_flSampleRadius );
				break;
			}
		case KEY_PAD_DIVIDE:
			{
				if ( !bDown )
				{
					m_nViewBuffer = (RenderTargetType_t)( m_nViewBuffer + 1 );
					if ( m_nViewBuffer >= MAX_RENDER_TARGET_TYPES )
					{
						m_nViewBuffer = (RenderTargetType_t)0;
					}

					Msg( "%s\n", g_pRenderTargetName[ m_nViewBuffer ] );
				}
				break;
			}
		case KEY_PAD_MULTIPLY:
			{
				if ( !bDown )
				{
					m_nViewBuffer = (RenderTargetType_t)( m_nViewBuffer - 1 );
					if ( m_nViewBuffer < 0 )
					{
						m_nViewBuffer = (RenderTargetType_t)( MAX_RENDER_TARGET_TYPES - 1 );
					}

					Msg( "%s\n", g_pRenderTargetName[ m_nViewBuffer ] );
				}
				break;
			}
		case KEY_TAB: 
			{
				m_nReportLevel = bDown ? 1 : 3;
				break;
			}
		case KEY_Z:
			{
				if ( !bDown )
				{
					Vector vCameraOrigin( 100, 24975, 250 );
					QAngle vCameraAngles( 9.6, -27, 0 );

					m_pFrustum->SetCameraPosition( vCameraOrigin );
					m_pFrustum->SetCameraAngles( vCameraAngles );

					m_pWorldRenderer->ClearOutstandingLoadRequests();
				}
			}
			break;
		}
		if ( nFlag )
		{
			if ( bDown )
			{
				m_cmd.m_nKeys |= nFlag;
			}
			else
			{
				m_cmd.m_nKeys &= ~nFlag;
			}
			return false;
		}
	}

	return BaseClass::ProcessUserInput( ie );
}

static void PerformWorkUnit( SimulateWorkUnitWorldRender_t & job )
{
	for( int i =0; i < job.m_nNumSystems; i++ )
	{
		job.m_pParticles->Simulate( job.m_flTimeStep );
	}
}

void CWorldRendererTest::SimulateParticles( float flTimeStep )
{
	int nSystems = m_particleWorkUnits.Count();
	for( int i = 0; i < nSystems; i++ )
	{
		m_particleWorkUnits[i].m_flTimeStep = flTimeStep;
	}

	ParallelProcess( m_particleWorkUnits.Base(), nSystems, PerformWorkUnit );
}