diff options
Diffstat (limited to 'hammer/render3dms.h')
| -rw-r--r-- | hammer/render3dms.h | 288 |
1 files changed, 288 insertions, 0 deletions
diff --git a/hammer/render3dms.h b/hammer/render3dms.h new file mode 100644 index 0000000..f5090d8 --- /dev/null +++ b/hammer/render3dms.h @@ -0,0 +1,288 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef RENDER3DMS_H +#define RENDER3DMS_H +#pragma once + + +#include "Render.h" +#include "mathlib/Vector4D.h" +#include "utlpriorityqueue.h" +#include "mapclass.h" +#include "lpreview_thread.h" +#include "shaderapi/ishaderapi.h" + +// +// Size of the buffer used for picking. See glSelectBuffer for documention on +// the contents of the selection buffer. +// +#define SELECTION_BUFFER_SIZE 50 + +// +// Size of the texture cache. THis is the maximum number of unique textures that +// a map can refer to and still render properly in the editor. +// +#define TEXTURE_CACHE_SIZE 2048 + +// +// Maximum number of objects that can be kept in the list of objects to render last. +// +#define MAX_RENDER_LAST_OBJECTS 256 + +// +// Maximum number of hits that can be returned by ObjectsAt. +// +#define MAX_PICK_HITS 512 + + +class BoundBox; +class CCamera; +class CCullTreeNode; +class CMapClass; +class CMapDoc; +class CMapFace; +class CMapInstance; +class CMapWorld; +class IMaterial; +class IMaterialVar; +template< class T, class A > +class CUtlVector; + +enum Visibility_t; +enum SelectionState_t; + + +typedef struct TranslucentObjects_s { + float depth; + CMapAtom *object; + + bool m_bInstanceSelected; + TInstanceState m_InstanceState; +} TranslucentObjects_t; + + +enum RenderState_t +{ + RENDER_CENTER_CROSSHAIR, // Whether to draw the crosshair in the center of the view. + RENDER_GRID, // Whether to draw a projected grid onto solid faces. + RENDER_FILTER_TEXTURES, // Whether to filter textures. + RENDER_POLYGON_OFFSET_FILL, // Whether to offset filled polygons (for decals) + RENDER_POLYGON_OFFSET_LINE, // Whether to offset line polygons (for wireframe selections) + RENDER_REVERSE_SELECTION, // Driver issue fix - whether to return the largest (rather than smallest) Z value when picking +}; + + +// +// Render state information set via RenderEnable: +// +typedef struct +{ + bool bCenterCrosshair; // Whether to render the center crosshair. + bool bDrawGrid; // Whether to render the grid. + float fGridSpacing; // Grid spacing in world units. + float fGridDistance; // Maximum distance from camera to draw grid. + bool bFilterTextures; // Whether to filter textures. + bool bReverseSelection; // Driver issue fix - whether to return the largest (rather than smallest) Z value when picking +} RenderStateInfo_t; + +static inline bool RenderingModeIsTextured(EditorRenderMode_t mode) +{ + return ( + (mode==RENDER_MODE_TEXTURED) || + (mode==RENDER_MODE_TEXTURED_SHADED) || + (mode==RENDER_MODE_LIGHT_PREVIEW_RAYTRACED) || + (mode==RENDER_MODE_LIGHT_PREVIEW2) ); +} + +// +// Picking state information used when called from ObjectsAt. +// +typedef struct +{ + bool bPicking; // Whether we are rendering in pick mode or not. + unsigned int m_nFlags; // flags + + float fX; // Leftmost coordinate of pick rectangle, passed in by caller. + float fY; // Topmost coordinate of pick rectangle, passed in by caller. + float fWidth; // Width of pick rectangle, passed in by caller. + float fHeight; // Height of pick rectangle, passed in by caller. + + HitInfo_t *pHitsDest; // Final array in which to place pick hits, passed in by caller. + int nMaxHits; // Maximum number of hits to place in the 'pHits' array, passed in by caller, must be <= MAX_PICK_HITS. + + HitInfo_t Hits[MAX_PICK_HITS]; // Temporary array in which to place unsorted pick hits. + int nNumHits; // Number of hits so far in this pick (number of hits in 'Hits' array). + + unsigned int uSelectionBuffer[SELECTION_BUFFER_SIZE]; + unsigned int uLastZ; +} PickInfo_t; + + +typedef struct +{ + IEditorTexture *pTexture; // Pointer to the texture object that implements this texture. + int nTextureID; // Unique ID of this texture across all renderers. + unsigned int uTexture; // The texture name as returned by OpenGL when the texture was uploaded in this renderer. +} TextureCache_t; + + +typedef struct +{ + HINSTANCE hInstance; + int iCmdShow; + HWND hWnd; + HDC hDC; + bool bActive; + bool bFullScreen; + ATOM wndclass; + WNDPROC wndproc; + bool bChangeBPP; + bool bAllowSoft; + char *szCmdLine; + int argc; + char **argv; + int iResCount; + int iVidMode; +} MatWinData_t; + + +class CRender3D : public CRender +{ +public: + + // Constructor / Destructor. + CRender3D(void); + virtual ~CRender3D(void); + + // Initialization & shutdown functions. + void ShutDown(void); + + float GetElapsedTime(void); + float GetGridDistance(void); + float GetGridSize(void); + + bool DeferRendering() const { return m_DeferRendering; } + bool IsEnabled(RenderState_t eRenderState); + bool IsPicking(void); + + virtual bool IsInLightingPreview(); + virtual void SetInLightingPreview( bool bLightingPreview ); + + // Operations. + + float LightPlane(Vector& Normal); + void UncacheAllTextures(); + + bool SetView( CMapView *pView ); + void StartRenderFrame(void); + void EndRenderFrame(void); + + virtual void PushInstanceData( CMapInstance *pInstanceClass, Vector &InstanceOrigin, QAngle &InstanceAngles ); + virtual void PopInstanceData( void ); + + void ResetFocus(); + + // Picking functions. + void BeginRenderHitTarget(CMapAtom *pObject, unsigned int uHandle = 0); + void EndRenderHitTarget(void); + + void Render(void); + void RenderEnable(RenderState_t eRenderState, bool bEnable); + + void RenderCrossHair(); + virtual void RenderWireframeBox(const Vector &Mins, const Vector &Maxs, unsigned char chRed, unsigned char chGreen, unsigned char chBlue); + void RenderBox(const Vector &Mins, const Vector &Maxs, unsigned char chRed, unsigned char chGreen, unsigned char chBlue, SelectionState_t eBoxSelectionState); + void RenderArrow(Vector const &vStartPt, Vector const &vEndPt, unsigned char chRed, unsigned char chGreen, unsigned char chBlue); + void RenderCone(Vector const &vBasePt, Vector const &vTipPt, float fRadius, int nSlices, + unsigned char chRed, unsigned char chGreen, unsigned char chBlue ); + void RenderSphere(Vector const &vCenter, float flRadius, int nTheta, int nPhi, + unsigned char chRed, unsigned char chGreen, unsigned char chBlue ); + void RenderWireframeSphere(Vector const &vCenter, float flRadius, int nTheta, int nPhi, + unsigned char chRed, unsigned char chGreen, unsigned char chBlue ); + void RenderInstanceMapClass( CMapInstance *pInstanceClass, CMapClass *pMapClass, Vector &InstanceOrigin, QAngle &InstanceAngles ); + + + int ObjectsAt( float x, float y, float fWidth, float fHeight, HitInfo_t *pObjects, int nMaxObjects, unsigned nFlags = 0 ); + + void DebugHook1(void *pData = NULL); + void DebugHook2(void *pData = NULL); + + // indicates we need to render an overlay pass... + bool NeedsOverlay() const; + + void BuildLightList( CUtlVector<CLightingPreviewLightDescription> *pList ) const; + + void SendLightList(); // send lighting list to lighting preview thread + + void SendShadowTriangles(); + void AddTranslucentDeferredRendering( CMapPoint *pMapPoint ); + +protected: + + inline void DispatchRender3D(CMapClass *pMapClass); + + // Rendering functions. + void RenderMapClass(CMapClass *pMapClass); + void RenderInstanceMapClass_r(CMapClass *pMapClass); + void RenderNode(CCullTreeNode *pNode, bool bForce); + void RenderOverlayElements(void); + void RenderTool(void); + void RenderTree( CMapWorld *pWorld ); + void RenderPointsAndPortals(void); + void RenderWorldAxes(); + void RenderTranslucentObjects( void ); + + // Utility functions. + void Preload(CMapClass *pParent); + Visibility_t IsBoxVisible(Vector const &BoxMins, Vector const &BoxMaxs); + + // Frustum methods + void ComputeFrustumRenderGeometry(CCamera * pCamera); + void RenderFrustum(); + + float m_fFrameRate; // Framerate in frames per second, calculated once per second. + int m_nFramesThisSample; // Number of frames rendered in the current sample period. + DWORD m_dwTimeLastSample; // Time when the framerate was last calculated. + + DWORD m_dwTimeLastFrame; // The time when the previous frame was rendered. + float m_fTimeElapsed; // Milliseconds elapsed since the last frame was rendered. + + // context for the last bitmap we sent to lighting preview for ray tracing. we do not send if + // nothing happens, even if we end up re-rendering + Vector m_LastLPreviewCameraPos; + float m_fLastLPreviewAngles[3]; // y,p,r + float m_fLastLPreviewZoom; + int m_nLastLPreviewWidth; + int m_nLastLPreviewHeight; + + Vector4D m_FrustumPlanes[6]; // Plane normals and constants for the current view frustum. + + MatWinData_t m_WinData; // Defines our render window parameters. + PickInfo_t m_Pick; // Contains information used when rendering in pick mode. + RenderStateInfo_t m_RenderState; // Render state set via RenderEnable. + + bool m_bDroppedCamera; // Whether we have dropped the camera for debugging. + bool m_DeferRendering; // Used when we want to sort lovely opaque objects + bool m_TranslucentSortRendering; // Used when we want to sort translucent objects + CCamera *m_pDropCamera; // Dropped camera to use for debugging. + + CUtlPriorityQueue<TranslucentObjects_t> m_TranslucentRenderObjects; // List of objects to render after all the other objects. + + IMaterial* m_pVertexColor[2]; // for selecting actual textures + + bool m_bLightingPreview; + + // for debugging... render the view frustum +#ifdef _DEBUG + Vector m_FrustumRenderPoint[8]; + bool m_bRenderFrustum; + bool m_bRecomputeFrustumRenderGeometry; +#endif +}; + +#endif // RENDER3DGL_H |