mirror of
https://github.com/0TheSpy/Seaside.git
synced 2025-01-11 11:33:01 +08:00
724 lines
21 KiB
C++
724 lines
21 KiB
C++
#if !defined( VIEWRENDER_H )
|
|
#define VIEWRENDER_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "shareddefs.h"
|
|
#include "utlstack.h"
|
|
#include "tier2.h"
|
|
#include "iviewrender.h"
|
|
#include "ivrenderview.h"
|
|
#include "view_shared.h"
|
|
|
|
#if defined(_PS3)
|
|
#include "buildrenderables_ps3.h"
|
|
#endif
|
|
#include "volumeculler.h"
|
|
#include "jobthread.h"
|
|
|
|
#include "bspfile.h"
|
|
#include "const.h"
|
|
|
|
class ConVar;
|
|
class CClientRenderablesList;
|
|
class IClientVehicle;
|
|
class C_PointCamera;
|
|
class C_EnvProjectedTexture;
|
|
class IScreenSpaceEffect;
|
|
class CClientViewSetup;
|
|
class CViewRender;
|
|
struct ClientWorldListInfo_t;
|
|
class C_BaseEntity;
|
|
class CJob;
|
|
|
|
#ifdef HL2_EPISODIC
|
|
class CStunEffect;
|
|
#endif
|
|
|
|
struct IntroDataBlendPass_t
|
|
{
|
|
int m_BlendMode;
|
|
float m_Alpha;
|
|
};
|
|
|
|
struct IntroData_t
|
|
{
|
|
bool m_bDrawPrimary;
|
|
Vector m_vecCameraView;
|
|
QAngle m_vecCameraViewAngles;
|
|
float m_playerViewFOV;
|
|
CUtlVector<IntroDataBlendPass_t> m_Passes;
|
|
|
|
float m_flCurrentFadeColor[4];
|
|
};
|
|
|
|
extern IntroData_t* g_pIntroData;
|
|
|
|
enum view_id_t
|
|
{
|
|
VIEW_ILLEGAL = -2,
|
|
VIEW_NONE = -1,
|
|
VIEW_MAIN = 0,
|
|
VIEW_3DSKY = 1,
|
|
VIEW_MONITOR = 2,
|
|
VIEW_REFLECTION = 3,
|
|
VIEW_REFRACTION = 4,
|
|
VIEW_INTRO_PLAYER = 5,
|
|
VIEW_INTRO_CAMERA = 6,
|
|
VIEW_SHADOW_DEPTH_TEXTURE = 7,
|
|
VIEW_SSAO = 8,
|
|
VIEW_ID_COUNT
|
|
};
|
|
view_id_t CurrentViewID();
|
|
|
|
#if defined(_PS3)
|
|
#define PASS_BUILDLISTS_PS3 (1<<0)
|
|
#define PASS_DRAWLISTS_PS3 (1<<1)
|
|
#else
|
|
#define PASS_BUILDLISTS (1<<0)
|
|
#define PASS_DRAWLISTS (1<<1)
|
|
#endif
|
|
|
|
class CPitchDrift
|
|
{
|
|
public:
|
|
float pitchvel;
|
|
bool nodrift;
|
|
float driftmove;
|
|
double laststop;
|
|
};
|
|
|
|
|
|
|
|
struct ViewCustomVisibility_t
|
|
{
|
|
ViewCustomVisibility_t()
|
|
{
|
|
m_nNumVisOrigins = 0;
|
|
m_VisData.m_fDistToAreaPortalTolerance = FLT_MAX;
|
|
m_iForceViewLeaf = -1;
|
|
}
|
|
|
|
void AddVisOrigin(const Vector& origin)
|
|
{
|
|
AssertMsg(m_nNumVisOrigins < MAX_VIS_LEAVES, "Added more origins than will fit in the array!");
|
|
|
|
if (m_nNumVisOrigins >= MAX_VIS_LEAVES)
|
|
return;
|
|
|
|
m_rgVisOrigins[m_nNumVisOrigins++] = origin;
|
|
}
|
|
|
|
void ForceVisOverride(VisOverrideData_t& visData)
|
|
{
|
|
m_VisData = visData;
|
|
}
|
|
|
|
void ForceViewLeaf(int iViewLeaf)
|
|
{
|
|
m_iForceViewLeaf = iViewLeaf;
|
|
}
|
|
|
|
int m_nNumVisOrigins;
|
|
Vector m_rgVisOrigins[MAX_VIS_LEAVES];
|
|
|
|
VisOverrideData_t m_VisData;
|
|
|
|
int m_iForceViewLeaf;
|
|
};
|
|
|
|
struct WaterRenderInfo_t
|
|
{
|
|
bool m_bCheapWater : 1;
|
|
bool m_bReflect : 1;
|
|
bool m_bRefract : 1;
|
|
bool m_bReflectEntities : 1;
|
|
bool m_bReflectOnlyMarkedEntities : 1;
|
|
bool m_bDrawWaterSurface : 1;
|
|
bool m_bOpaqueWater : 1;
|
|
bool m_bPseudoTranslucentWater : 1;
|
|
bool m_bReflect2DSkybox : 1;
|
|
};
|
|
|
|
class CBase3dView : public CRefCounted<>,
|
|
protected CViewSetup
|
|
{
|
|
DECLARE_CLASS_NOBASE(CBase3dView);
|
|
public:
|
|
explicit CBase3dView(CViewRender* pMainView);
|
|
|
|
VPlane* GetFrustum();
|
|
virtual int GetDrawFlags() { return 0; }
|
|
|
|
#ifdef PORTAL
|
|
virtual void EnableWorldFog() {};
|
|
#endif
|
|
|
|
protected:
|
|
VPlane* m_Frustum;
|
|
CViewRender* m_pMainView;
|
|
int m_nSlot;
|
|
};
|
|
|
|
struct FrustumCache_t
|
|
{
|
|
int m_nFrameCount;
|
|
Frustum_t m_Frustums[MAX_SPLITSCREEN_PLAYERS];
|
|
|
|
FrustumCache_t() { m_nFrameCount = 0; }
|
|
|
|
bool IsValid(void);
|
|
void SetUpdated(void);
|
|
|
|
void Add(const CViewSetup* pView, int iSlot);
|
|
};
|
|
|
|
FrustumCache_t* FrustumCache(void);
|
|
|
|
class CRendering3dView : public CBase3dView
|
|
{
|
|
DECLARE_CLASS(CRendering3dView, CBase3dView);
|
|
public:
|
|
explicit CRendering3dView(CViewRender* pMainView);
|
|
virtual ~CRendering3dView() { ReleaseLists(); }
|
|
|
|
void Setup(const CViewSetup& setup);
|
|
|
|
virtual int GetDrawFlags();
|
|
virtual void Draw() {};
|
|
|
|
protected:
|
|
|
|
void EnableWorldFog(void);
|
|
void SetFogVolumeState(const VisibleFogVolumeInfo_t& fogInfo, bool bUseHeightFog);
|
|
|
|
void SetupRenderablesList(int viewID, bool bFastEntityRendering = false, bool bDrawDepthViewNonCachedObjectsOnly = false);
|
|
|
|
void BuildWorldRenderLists(bool bDrawEntities, int iForceViewLeaf = -1, bool bUseCacheIfEnabled = true, bool bShadowDepth = false, float* pReflectionWaterHeight = NULL);
|
|
|
|
#if defined(_PS3)
|
|
void SetupRenderablesList_PS3_Epilogue(void);
|
|
|
|
void BuildWorldRenderLists_PS3_Epilogue(bool bShadowDepth);
|
|
void BuildRenderableRenderLists_PS3_Epilogue(void);
|
|
#else
|
|
void BuildWorldRenderLists_Epilogue(bool bShadowDepth);
|
|
void BuildRenderableRenderLists_Epilogue(int viewID);
|
|
#endif
|
|
|
|
void BuildRenderableRenderLists(int viewID, bool bFastEntityRendering = false, bool bDrawDepthViewNonCachedObjectsOnly = false);
|
|
|
|
void BuildShadowDepthRenderableRenderLists();
|
|
|
|
void DrawWorld(IMatRenderContext* pRenderContext, float waterZAdjust);
|
|
|
|
enum RenderablesRenderPath_t
|
|
{
|
|
RENDERABLES_RENDER_PATH_NORMAL = 0,
|
|
RENDERABLES_RENDER_PATH_SHADOWDEPTH_DEFAULT = (1 << 0),
|
|
RENDERABLES_RENDER_PATH_SHADOWDEPTH_BUILD_GEOCACHE = (1 << 1),
|
|
RENDERABLES_RENDER_PATH_SHADOWDEPTH_USE_GEOCACHE = (1 << 2),
|
|
};
|
|
void DrawOpaqueRenderables(IMatRenderContext* pRenderContext, RenderablesRenderPath_t eRenderPath, ERenderDepthMode_t DepthMode, CUtlVector< CClientRenderablesList::CEntry* >* pDeferClippedOpaqueRenderables_Out, RenderGroup_t nGroup = RENDER_GROUP_OPAQUE);
|
|
void DrawDeferredClippedOpaqueRenderables(IMatRenderContext* pRenderContext, RenderablesRenderPath_t eRenderPath, ERenderDepthMode_t DepthMode, CUtlVector< CClientRenderablesList::CEntry* >* pDeferClippedOpaqueRenderables);
|
|
void DrawTranslucentRenderables(bool bInSkybox, bool bShadowDepth);
|
|
|
|
#if defined( PORTAL )
|
|
void DrawRecursivePortalViews(void);
|
|
#endif
|
|
|
|
void DrawTranslucentRenderablesNoWorld(bool bInSkybox);
|
|
|
|
void DrawNoZBufferTranslucentRenderables(void);
|
|
|
|
void DrawTranslucentWorldInLeaves(IMatRenderContext* pRenderContext, bool bShadowDepth);
|
|
|
|
void DrawTranslucentWorldAndDetailPropsInLeaves(IMatRenderContext* pRenderContext, int iCurLeaf, int iFinalLeaf, int nEngineDrawFlags, int& nDetailLeafCount, LeafIndex_t* pDetailLeafList, bool bShadowDepth);
|
|
|
|
void PruneWorldListInfo();
|
|
|
|
void BeginConsoleZPass();
|
|
void EndConsoleZPass();
|
|
|
|
|
|
#ifdef PORTAL
|
|
virtual bool ShouldDrawPortals() { return true; }
|
|
#endif
|
|
|
|
void ReleaseLists();
|
|
|
|
int m_DrawFlags;
|
|
int m_ClearFlags;
|
|
|
|
|
|
IWorldRenderList* m_pWorldRenderList;
|
|
|
|
#if defined( CSTRIKE15 ) && defined(_PS3)
|
|
CClientRenderablesList* m_pRenderablesList[MAX_CONCURRENT_BUILDVIEWS];
|
|
ClientWorldListInfo_t* m_pWorldListInfo[MAX_CONCURRENT_BUILDVIEWS];
|
|
#else
|
|
CClientRenderablesList* m_pRenderables;
|
|
ClientWorldListInfo_t* m_pWorldListInfo;
|
|
#endif
|
|
|
|
ViewCustomVisibility_t* m_pCustomVisibility;
|
|
};
|
|
|
|
|
|
class CRenderExecutor
|
|
{
|
|
DECLARE_CLASS_NOBASE(CRenderExecutor);
|
|
public:
|
|
|
|
virtual void AddView(CRendering3dView* pView) = 0;
|
|
|
|
virtual void Execute() = 0;
|
|
|
|
protected:
|
|
explicit CRenderExecutor(CViewRender* pMainView) : m_pMainView(pMainView) {}
|
|
CViewRender* m_pMainView;
|
|
};
|
|
|
|
class CSimpleRenderExecutor : public CRenderExecutor
|
|
{
|
|
DECLARE_CLASS(CSimpleRenderExecutor, CRenderExecutor);
|
|
public:
|
|
explicit CSimpleRenderExecutor(CViewRender* pMainView) : CRenderExecutor(pMainView) {}
|
|
|
|
void AddView(CRendering3dView* pView);
|
|
|
|
void Execute() {}
|
|
};
|
|
|
|
|
|
#if defined(_PS3)
|
|
class CConcurrentViewBuilderPS3
|
|
{
|
|
public:
|
|
|
|
CConcurrentViewBuilderPS3();
|
|
~CConcurrentViewBuilderPS3() { Purge(); };
|
|
|
|
void Init(void);
|
|
void Purge(void);
|
|
|
|
void ResetBuildViewID(void);
|
|
|
|
int GetBuildViewID(void);
|
|
|
|
void PushBuildView(void);
|
|
void PopBuildView(void);
|
|
|
|
void SyncViewBuilderJobs(void);
|
|
|
|
void SPUBuildRWJobsOn(bool jobOn) { m_bSPUBuildRWJobsOn = jobOn; };
|
|
bool IsSPUBuildRWJobsOn(void) { return m_bSPUBuildRWJobsOn; };
|
|
|
|
int GetPassFlags(void) { return m_passFlags; };
|
|
void SetPassFlags(int flags) { m_passFlags = flags; };
|
|
|
|
IWorldRenderList* GetWorldRenderListElement(void);
|
|
void SetWorldRenderListElement(IWorldRenderList* pRenderList);
|
|
|
|
int GetDrawFlags(void) { return m_drawFlags; };
|
|
void SetDrawFlags(int drawFlags) { m_drawFlags = drawFlags; };
|
|
|
|
unsigned int GetVisFlags(void);
|
|
void SetVisFlags(unsigned int visFlags);
|
|
|
|
void CacheFrustumData(Frustum_t* pFrustum, Frustum_t* pAreaFrustum, void* pRenderAreaBits, int numArea, bool bViewerInSolidSpace);
|
|
void CacheBuildViewVolumeCuller(void* pVC);
|
|
void* GetBuildViewVolumeCuller(void);
|
|
Frustum_t* GetBuildViewFrustum(void);
|
|
Frustum_t* GetBuildViewAreaFrustum(void);
|
|
unsigned char* GetBuildViewRenderAreaBits(void);
|
|
|
|
int GetNumAreaFrustum(void);
|
|
Frustum_t* GetBuildViewAreaFrustumID(int frustumID);
|
|
|
|
|
|
void PushBuildRenderableJobs(void);
|
|
|
|
private:
|
|
|
|
int m_buildViewID;
|
|
int m_nextFreeBuildViewID;
|
|
|
|
int* m_pBuildViewStack;
|
|
int m_buildViewStack[MAX_CONCURRENT_BUILDVIEWS];
|
|
|
|
int m_passFlags;
|
|
int m_drawFlags;
|
|
unsigned int m_visFlags[MAX_CONCURRENT_BUILDVIEWS];
|
|
|
|
|
|
IWorldRenderList* m_pWorldRenderListCache[MAX_CONCURRENT_BUILDVIEWS] ALIGN16;
|
|
|
|
Frustum_t m_gFrustum[MAX_CONCURRENT_BUILDVIEWS] ALIGN16;
|
|
CUtlVector<Frustum_t> m_gAreaFrustum[MAX_CONCURRENT_BUILDVIEWS] ALIGN16;
|
|
unsigned char m_gRenderAreaBits[MAX_CONCURRENT_BUILDVIEWS][32] ALIGN16;
|
|
bool m_bViewerInSolidSpace[MAX_CONCURRENT_BUILDVIEWS] ALIGN16;
|
|
|
|
CVolumeCuller m_volumeCullerCache[MAX_CONCURRENT_BUILDVIEWS] ALIGN16;
|
|
|
|
bool m_bSPUBuildRWJobsOn;
|
|
};
|
|
|
|
extern CConcurrentViewBuilderPS3 g_viewBuilder;
|
|
|
|
#else
|
|
|
|
class CConcurrentViewData
|
|
{
|
|
public:
|
|
|
|
void Init(void);
|
|
void Purge(void);
|
|
|
|
CVolumeCuller m_volumeCuller;
|
|
Frustum_t m_Frustum;
|
|
CUtlVector< Frustum_t, CUtlMemoryAligned< Frustum_t, 16 > > m_AreaFrustums;
|
|
Frustum_t* m_frustumList[MAX_MAP_AREAS];
|
|
|
|
IWorldRenderList* m_pWorldRenderList;
|
|
ClientWorldListInfo_t* m_pWorldListInfo;
|
|
CClientRenderablesList* m_pRenderablesList;
|
|
|
|
CJob* m_pBuildWorldListJob;
|
|
CJob* m_pBuildRenderablesListJob;
|
|
bool m_bWaitForWorldList;
|
|
};
|
|
|
|
class CConcurrentViewBuilder
|
|
{
|
|
public:
|
|
|
|
CConcurrentViewBuilder();
|
|
~CConcurrentViewBuilder();
|
|
|
|
void Init(void);
|
|
void Purge(void);
|
|
|
|
void SetBuildWRThreaded(bool bThreaded) { m_bThreaded = bThreaded; }
|
|
bool GetBuildWRThreaded(void) { return m_bThreaded; }
|
|
|
|
void ResetBuildViewID(void);
|
|
|
|
int GetBuildViewID(void);
|
|
|
|
void PushBuildView(void);
|
|
void PopBuildView(void);
|
|
|
|
int GetPassFlags(void) { return m_passFlags; };
|
|
void SetPassFlags(int flags) { m_passFlags = flags; };
|
|
|
|
void CacheBuildViewVolumeCuller(const CVolumeCuller* pVC);
|
|
const CVolumeCuller* GetBuildViewVolumeCuller(int buildViewID = -1) const;
|
|
|
|
void CacheFrustumData(const Frustum_t& frustum, const CUtlVector< Frustum_t, CUtlMemoryAligned< Frustum_t, 16 > >& aeraFrustums);
|
|
void CacheFrustumData(void);
|
|
const Frustum_t* GetBuildViewFrustum(int buildViewID = -1) const;
|
|
const CUtlVector< Frustum_t, CUtlMemoryAligned< Frustum_t, 16 > >* GetBuildViewAeraFrustums(int buildViewID = -1) const;
|
|
Frustum_t** GetBuildViewFrustumList(int buildViewID = -1);
|
|
|
|
IWorldRenderList* GetWorldRenderListElement(void);
|
|
void SetWorldRenderListElement(IWorldRenderList* pRenderList);
|
|
|
|
ClientWorldListInfo_t* GetClientWorldListInfoElement(int buildViewID = -1);
|
|
WorldListInfo_t* GetWorldListInfoElement(int buildViewID);
|
|
void SetWorldListInfoElement(ClientWorldListInfo_t* pWorldListInfo, int buildViewID = -1);
|
|
|
|
CClientRenderablesList* GetRenderablesListElement(int buildViewID = -1);
|
|
void SetRenderablesListElement(CClientRenderablesList* pRenderables);
|
|
|
|
void QueueBuildWorldListJob(CJob* pJob);
|
|
void WaitForBuildWorldListJob(void);
|
|
void FlushBuildWorldListJob(void);
|
|
|
|
void QueueBuildRenderablesListJob(CJob* pJob);
|
|
void WaitForBuildRenderablesListJob(void);
|
|
void FlushBuildRenderablesListJob(void);
|
|
void AddDependencyToWorldList(void);
|
|
|
|
private:
|
|
|
|
void AddJobToThreadPool(CJob* pJob);
|
|
void AddToSequentialJobs(CJob* pJob);
|
|
void TryRunSequentialJobs(void);
|
|
void WaitForCurrentSequentialJobAndRunPending();
|
|
void InternalWaitForBuildWorldListJob(int buildViewID);
|
|
|
|
class SequentialJobs : public CJob
|
|
{
|
|
public:
|
|
|
|
explicit SequentialJobs(CJob* pJob = NULL);
|
|
~SequentialJobs();
|
|
|
|
void AddJob(CJob* pJob);
|
|
|
|
virtual JobStatus_t DoExecute();
|
|
|
|
private:
|
|
|
|
CUtlVectorFixed<CJob*, 16> m_jobs;
|
|
};
|
|
|
|
bool m_bThreaded;
|
|
|
|
int m_buildViewID;
|
|
int m_nextFreeBuildViewID;
|
|
|
|
int* m_pBuildViewStack;
|
|
int m_buildViewStack[MAX_CONCURRENT_BUILDVIEWS];
|
|
|
|
int m_passFlags;
|
|
|
|
CConcurrentViewData m_viewData[MAX_CONCURRENT_BUILDVIEWS];
|
|
|
|
SequentialJobs* m_pCurrentSeqJobs;
|
|
SequentialJobs* m_pPendingSeqJobs;
|
|
|
|
CUtlVector<CJob*> mJobsAddedToThreadPool;
|
|
};
|
|
|
|
extern CConcurrentViewBuilder g_viewBuilder;
|
|
|
|
#endif
|
|
|
|
class CViewRender : public IViewRender
|
|
{
|
|
DECLARE_CLASS_NOBASE(CViewRender);
|
|
public:
|
|
virtual void Init(void);
|
|
virtual void Shutdown(void);
|
|
|
|
const CViewSetup* GetPlayerViewSetup(int nSlot = -1) const;
|
|
|
|
virtual void StartPitchDrift(void);
|
|
virtual void StopPitchDrift(void);
|
|
|
|
virtual float GetZNear();
|
|
virtual float GetZFar();
|
|
|
|
virtual void OnRenderStart();
|
|
void DriftPitch(void);
|
|
|
|
static CViewRender* GetMainView() { return assert_cast<CViewRender*>(view); }
|
|
|
|
void AddViewToScene(CRendering3dView* pView) { m_SimpleExecutor.AddView(pView); }
|
|
|
|
CMaterialReference& GetWhite();
|
|
|
|
virtual void InitFadeData(void);
|
|
|
|
protected:
|
|
void SetUpView();
|
|
|
|
void SetUpOverView();
|
|
void SetUpChaseOverview();
|
|
|
|
virtual void WriteSaveGameScreenshotOfSize(const char* pFilename, int width, int height);
|
|
void WriteSaveGameScreenshot(const char* filename);
|
|
|
|
CViewSetup& GetView(int nSlot = -1);
|
|
const CViewSetup& GetView(int nSlot = -1) const;
|
|
|
|
CViewSetup m_UserView[MAX_SPLITSCREEN_PLAYERS];
|
|
bool m_bAllowViewAccess;
|
|
CPitchDrift m_PitchDrift;
|
|
|
|
virtual void RenderPreScene(const CViewSetup& view) { }
|
|
virtual void PreViewDrawScene(const CViewSetup& view) {}
|
|
virtual void PostViewDrawScene(const CViewSetup& view) {}
|
|
|
|
float m_flOldChaseOverviewScale;
|
|
float m_flIdealChaseOverviewScale;
|
|
float m_flNextIdealOverviewScaleUpdate;
|
|
public:
|
|
CViewRender();
|
|
virtual ~CViewRender(void) {}
|
|
|
|
public:
|
|
|
|
void SetupVis(const CViewSetup& view, unsigned int& visFlags, ViewCustomVisibility_t* pCustomVisibility = NULL);
|
|
|
|
|
|
virtual void Render(vrect_t* rect);
|
|
virtual void RenderView(const CViewSetup& view, const CViewSetup& hudViewSetup, int nClearFlags, int whatToDraw);
|
|
virtual void RenderPlayerSprites();
|
|
virtual void Render2DEffectsPreHUD(const CViewSetup& view);
|
|
virtual void Render2DEffectsPostHUD(const CViewSetup& view);
|
|
virtual void RenderSmokeOverlay(bool bPreViewModel = true) {};
|
|
float GetLastRenderSmokeOverlayAmount() const { return m_flSmokeOverlayAmount; }
|
|
|
|
|
|
void DisableFog(void);
|
|
|
|
void LevelInit(void);
|
|
void LevelShutdown(void);
|
|
|
|
bool ShouldDrawEntities(void);
|
|
bool ShouldDrawBrushModels(void);
|
|
|
|
const CViewSetup* GetViewSetup() const;
|
|
|
|
void DisableVis(void);
|
|
|
|
void MoveViewModels();
|
|
|
|
void GetViewModelPosition(int nIndex, Vector* pPos, QAngle* pAngle);
|
|
|
|
void SetCheapWaterStartDistance(float flCheapWaterStartDistance);
|
|
void SetCheapWaterEndDistance(float flCheapWaterEndDistance);
|
|
|
|
void GetWaterLODParams(float& flCheapWaterStartDistance, float& flCheapWaterEndDistance);
|
|
|
|
virtual void QueueOverlayRenderView(const CViewSetup& view, int nClearFlags, int whatToDraw);
|
|
|
|
virtual void GetScreenFadeDistances(float* pMin, float* pMax, float* pScale);
|
|
|
|
virtual C_BaseEntity* GetCurrentlyDrawingEntity();
|
|
virtual void SetCurrentlyDrawingEntity(C_BaseEntity* pEnt);
|
|
|
|
virtual bool UpdateShadowDepthTexture(ITexture* pRenderTarget, ITexture* pDepthTexture, const CViewSetup& shadowView, bool bRenderWorldAndObjects = true, bool bRenderViewModels = false);
|
|
|
|
int GetBaseDrawFlags() { return m_BaseDrawFlags; }
|
|
virtual bool ShouldForceNoVis() { return m_bForceNoVis; }
|
|
int BuildRenderablesListsNumber() const { return m_BuildRenderableListsNumber; }
|
|
int IncRenderablesListsNumber() { return ++m_BuildRenderableListsNumber; }
|
|
|
|
int BuildWorldListsNumber() const;
|
|
int IncWorldListsNumber() { return ++m_BuildWorldListsNumber; }
|
|
|
|
virtual VPlane* GetFrustum() { return (m_pActiveRenderer) ? m_pActiveRenderer->GetFrustum() : m_Frustum; }
|
|
|
|
virtual int GetDrawFlags() { return (m_pActiveRenderer) ? m_pActiveRenderer->GetDrawFlags() : 0; }
|
|
|
|
CBase3dView* GetActiveRenderer() { return m_pActiveRenderer; }
|
|
CBase3dView* SetActiveRenderer(CBase3dView* pActiveRenderer) { CBase3dView* pPrevious = m_pActiveRenderer; m_pActiveRenderer = pActiveRenderer; return pPrevious; }
|
|
|
|
void FreezeFrame(float flFreezeTime);
|
|
|
|
void SetWaterOverlayMaterial(IMaterial* pMaterial)
|
|
{
|
|
m_UnderWaterOverlayMaterial.Init(pMaterial);
|
|
}
|
|
|
|
void DrawViewModelsShadowDepth(const CViewSetup& view);
|
|
|
|
protected:
|
|
int m_BuildWorldListsNumber;
|
|
|
|
|
|
void ViewDrawScene(bool bDrew3dSkybox, SkyboxVisibility_t nSkyboxVisible, const CViewSetup& view, int nClearFlags, view_id_t viewID, bool bDrawViewModel = false, int baseDrawFlags = 0, ViewCustomVisibility_t* pCustomVisibility = NULL);
|
|
|
|
void DrawMonitors(const CViewSetup& cameraView);
|
|
|
|
bool DrawOneMonitor(ITexture* pRenderTarget, int cameraNum, C_PointCamera* pCameraEnt, const CViewSetup& cameraView, void* localPlayer,
|
|
int x, int y, int width, int height);
|
|
|
|
bool ShouldDrawViewModel(bool drawViewmodel);
|
|
#ifdef IRONSIGHT
|
|
void DrawViewModels(const CViewSetup& view, bool drawViewmodel, bool bDrawScopeLensMask = false);
|
|
#else
|
|
void DrawViewModels(const CViewSetup& view, bool drawViewmodel);
|
|
#endif
|
|
|
|
void PerformScreenSpaceEffects(int x, int y, int w, int h);
|
|
|
|
void SetScreenOverlayMaterial(IMaterial* pMaterial);
|
|
IMaterial* GetScreenOverlayMaterial();
|
|
void PerformScreenOverlay(int x, int y, int w, int h);
|
|
|
|
void DrawUnderwaterOverlay(void);
|
|
|
|
void DrawWorldAndEntities(bool drawSkybox, const CViewSetup& view, int nClearFlags, ViewCustomVisibility_t* pCustomVisibility = NULL);
|
|
|
|
virtual void ViewDrawScene_Intro(const CViewSetup& view, int nClearFlags, const IntroData_t& introData);
|
|
|
|
#ifdef PORTAL
|
|
void ViewDrawScene_PortalStencil(const CViewSetup& view, ViewCustomVisibility_t* pCustomVisibility);
|
|
void Draw3dSkyboxworld_Portal(const CViewSetup& view, int& nClearFlags, bool& bDrew3dSkybox, SkyboxVisibility_t& nSkyboxVisible, ITexture* pRenderTarget = NULL);
|
|
#endif
|
|
|
|
#ifdef PORTAL2
|
|
void ViewDrawPhoto(ITexture* pRenderTarget, C_BaseEntity* pEnt);
|
|
#endif
|
|
|
|
void DetermineWaterRenderInfo(const VisibleFogVolumeInfo_t& fogVolumeInfo, WaterRenderInfo_t& info);
|
|
|
|
bool UpdateRefractIfNeededByList(CViewModelRenderablesList::RenderGroups_t& list);
|
|
void DrawRenderablesInList(CViewModelRenderablesList::RenderGroups_t& list, int flags = 0);
|
|
|
|
void SetupMain3DView(int nSlot, const CViewSetup& view, const CViewSetup& hudViewSetup, int& nClearFlags, ITexture* pRenderTarget);
|
|
void CleanupMain3DView(const CViewSetup& view);
|
|
|
|
void GetLetterBoxRectangles(int nSlot, const CViewSetup& view, CUtlVector< vrect_t >& vecLetterBoxRectangles);
|
|
void DrawLetterBoxRectangles(int nSlot, const CUtlVector< vrect_t >& vecLetterBoxRectangles);
|
|
|
|
void EnableWaterDepthFeathing(IMaterial* pWaterMaterial, bool bEnable);
|
|
|
|
#if defined(_PS3)
|
|
void InitSPUBuildRenderingJobs(void);
|
|
#endif
|
|
|
|
CViewSetup m_CurrentView;
|
|
|
|
bool m_bForceNoVis;
|
|
|
|
const ConVar* m_pDrawEntities;
|
|
const ConVar* m_pDrawBrushModels;
|
|
|
|
CMaterialReference m_TranslucentSingleColor;
|
|
CMaterialReference m_ModulateSingleColor;
|
|
CMaterialReference m_ScreenOverlayMaterial;
|
|
CMaterialReference m_UnderWaterOverlayMaterial;
|
|
|
|
Vector m_vecLastFacing;
|
|
float m_flCheapWaterStartDistance;
|
|
float m_flCheapWaterEndDistance;
|
|
|
|
CViewSetup m_OverlayViewSetup;
|
|
int m_OverlayClearFlags;
|
|
int m_OverlayDrawFlags;
|
|
bool m_bDrawOverlay;
|
|
|
|
int m_BaseDrawFlags;
|
|
C_BaseEntity* m_pCurrentlyDrawingEntity;
|
|
|
|
#ifdef PORTAL
|
|
friend class CPortalRender;
|
|
friend class CPortalRenderable;
|
|
#endif
|
|
int m_BuildRenderableListsNumber;
|
|
|
|
friend class CBase3dView;
|
|
|
|
Frustum m_Frustum;
|
|
|
|
CBase3dView* m_pActiveRenderer;
|
|
CSimpleRenderExecutor m_SimpleExecutor;
|
|
|
|
struct FreezeParams_t
|
|
{
|
|
FreezeParams_t() : m_bTakeFreezeFrame(false), m_flFreezeFrameUntil(0.0f) {}
|
|
|
|
bool m_bTakeFreezeFrame;
|
|
float m_flFreezeFrameUntil;
|
|
};
|
|
|
|
FreezeParams_t m_FreezeParams[MAX_SPLITSCREEN_PLAYERS];
|
|
|
|
FadeData_t m_FadeData;
|
|
|
|
CMaterialReference m_WhiteMaterial;
|
|
|
|
CON_COMMAND_MEMBER_F(CViewRender, "screenfademinsize", OnScreenFadeMinSize, "Modify global screen fade min size in pixels", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY);
|
|
CON_COMMAND_MEMBER_F(CViewRender, "screenfademaxsize", OnScreenFadeMaxSize, "Modify global screen fade max size in pixels", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY);
|
|
|
|
float m_flSmokeOverlayAmount;
|
|
};
|
|
|
|
#endif |