You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3417 lines
94 KiB
3417 lines
94 KiB
//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#include "stdafx.h"
|
|
#include <math.h>
|
|
#include <mmsystem.h>
|
|
#include "Camera.h"
|
|
#include "CullTreeNode.h"
|
|
#include "MapDefs.h"
|
|
#include "MapDoc.h"
|
|
#include "MapEntity.h"
|
|
#include "MapInstance.h"
|
|
#include "MapWorld.h"
|
|
#include "Render3DMS.h"
|
|
#include "SSolid.h"
|
|
#include "MapStudioModel.h"
|
|
#include "Material.h"
|
|
#include "materialsystem/IMaterialSystem.h"
|
|
#include "materialsystem/IMesh.h"
|
|
#include "TextureSystem.h"
|
|
#include "ToolInterface.h"
|
|
#include "StudioModel.h"
|
|
#include "ibsplighting.h"
|
|
#include "MapDisp.h"
|
|
#include "ToolManager.h"
|
|
#include "mapview.h"
|
|
#include "hammer.h"
|
|
#include "IStudioRender.h"
|
|
#include <renderparm.h>
|
|
#include "materialsystem/itexture.h"
|
|
#include "maplightcone.h"
|
|
#include "map_utils.h"
|
|
#include "bitmap/floatbitmap.h"
|
|
#include "lpreview_thread.h"
|
|
#include "hammer.h"
|
|
#include "mainfrm.h"
|
|
#include "mathlib/halton.h"
|
|
#include "Manifest.h"
|
|
#include "toolutils/enginetools_int.h"
|
|
#include "toolframework/ienginetool.h"
|
|
#include "..\FoW\FoW.h"
|
|
#include "..\fow\fow_trisoup.h"
|
|
#include "..\fow\fow_lineoccluder.h"
|
|
#include "gridnav.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include <tier0/memdbgon.h>
|
|
|
|
|
|
#define NUM_MIPLEVELS 4
|
|
|
|
#define CROSSHAIR_DIST_HORIZONTAL 5
|
|
#define CROSSHAIR_DIST_VERTICAL 6
|
|
|
|
#define TEXTURE_AXIS_LENGTH 10 // Texture axis length in world units
|
|
|
|
|
|
// dvs: experiment!
|
|
//extern int g_nClipPoints;
|
|
//extern Vector g_ClipPoints[4];
|
|
|
|
//
|
|
// Debugging / diagnostic stuff.
|
|
//
|
|
static bool g_bDrawWireFrameSelection = true;
|
|
static bool g_bShowStatistics = false;
|
|
static bool g_bUseCullTree = true;
|
|
static bool g_bRenderCullBoxes = false;
|
|
|
|
int g_nBitmapGenerationCounter = 1;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Callback comparison function for sorting objects clicked on while
|
|
// in selection mode.
|
|
// Input : pHit1 - First hit to compare.
|
|
// pHit2 - Second hit to compare.
|
|
// Output : Sorts by increasing depth value. Returns -1, 0, or 1 per qsort spec.
|
|
//-----------------------------------------------------------------------------
|
|
static int _CompareHits(const void *pHit1, const void *pHit2)
|
|
{
|
|
if (((HitInfo_t *)pHit1)->nDepth < ((HitInfo_t *)pHit2)->nDepth)
|
|
{
|
|
return(-1);
|
|
}
|
|
|
|
if (((HitInfo_t *)pHit1)->nDepth > ((HitInfo_t *)pHit2)->nDepth)
|
|
{
|
|
return(1);
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Callback comparison function for sorting objects clicked on while
|
|
// in selection mode. The reverse sort is used for cards that return
|
|
// depth values in reverse (larger numbers are closer to the camera).
|
|
// Input : pHit1 - First hit to compare.
|
|
// pHit2 - Second hit to compare.
|
|
// Output : Sorts by decreasing depth value. Returns -1, 0, or 1 per qsort spec.
|
|
//-----------------------------------------------------------------------------
|
|
static int _CompareHitsReverse(const void *pHit1, const void *pHit2)
|
|
{
|
|
if (((HitInfo_t *)pHit1)->nDepth > ((HitInfo_t *)pHit2)->nDepth)
|
|
{
|
|
return(-1);
|
|
}
|
|
|
|
if (((HitInfo_t *)pHit1)->nDepth < ((HitInfo_t *)pHit2)->nDepth)
|
|
{
|
|
return(1);
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
static bool TranslucentObjectsLessFunc( TranslucentObjects_t const&a, TranslucentObjects_t const&b )
|
|
{
|
|
return (a.depth < b.depth);
|
|
}
|
|
|
|
|
|
bool GetRequiredMaterial( const char *pName, IMaterial* &pMaterial )
|
|
{
|
|
pMaterial = NULL;
|
|
IEditorTexture *pTex = g_Textures.FindActiveTexture( pName );
|
|
if ( pTex )
|
|
pMaterial = pTex->GetMaterial();
|
|
|
|
if ( pMaterial )
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
char str[512];
|
|
Q_snprintf( str, sizeof( str ), "Missing material '%s'. Go to Tools | Options | Game Configurations and verify that your game directory is correct.", pName );
|
|
MessageBox( NULL, str, "FATAL ERROR", MB_OK );
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Calculates lighting for a given face.
|
|
// Input : Normal - vector that is normal to the face being lit.
|
|
// Output : Returns a number from [0.2, 1.0]
|
|
//-----------------------------------------------------------------------------
|
|
float CRender3D::LightPlane(Vector& Normal)
|
|
{
|
|
static Vector Light( 1.0f, 2.0f, 3.0f );
|
|
static bool bFirst = true;
|
|
|
|
if (bFirst)
|
|
{
|
|
VectorNormalize(Light);
|
|
bFirst = false;
|
|
}
|
|
|
|
float fShade = 0.65f + (0.35f * DotProduct(Normal, Light));
|
|
|
|
return(fShade);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CRender3D::CRender3D(void) :
|
|
CRender()
|
|
{
|
|
memset(&m_WinData, 0, sizeof(m_WinData));
|
|
m_WinData.bAllowSoft = true;
|
|
|
|
memset(m_FrustumPlanes, 0, sizeof(m_FrustumPlanes));
|
|
|
|
m_pDropCamera = new CCamera;
|
|
m_bDroppedCamera = false;
|
|
m_DeferRendering = false;
|
|
m_TranslucentSortRendering = false;
|
|
|
|
m_fFrameRate = 0;
|
|
m_nFramesThisSample = 0;
|
|
m_dwTimeLastSample = 0;
|
|
m_dwTimeLastFrame = 0;
|
|
m_fTimeElapsed = 0;
|
|
|
|
m_LastLPreviewCameraPos = Vector(1.0e22,1.0e22,1.0e22);
|
|
m_nLastLPreviewWidth = -1;
|
|
m_nLastLPreviewHeight = -1;
|
|
|
|
memset(&m_Pick, 0, sizeof(m_Pick));
|
|
m_Pick.bPicking = false;
|
|
|
|
memset(&m_RenderState, 0, sizeof(m_RenderState));
|
|
|
|
for (int i = 0; i < 2; ++i)
|
|
{
|
|
m_pVertexColor[i] = 0;
|
|
}
|
|
m_bLightingPreview = false;
|
|
|
|
m_TranslucentRenderObjects.SetLessFunc( TranslucentObjectsLessFunc );
|
|
|
|
#ifdef _DEBUG
|
|
m_bRenderFrustum = false;
|
|
m_bRecomputeFrustumRenderGeometry = false;
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CRender3D::~CRender3D(void)
|
|
{
|
|
if (m_pDropCamera != NULL)
|
|
{
|
|
delete m_pDropCamera;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called before rendering an object that should be hit tested when
|
|
// rendering in selection mode.
|
|
// Input : pObject - Map atom pointer that will be returned from the ObjectsAt
|
|
// routine if this rendered object is positively hit tested.
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::BeginRenderHitTarget(CMapAtom *pObject, unsigned int uHandle)
|
|
{
|
|
if ( m_Pick.bPicking == false )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if ( ( m_Pick.m_nFlags & FLAG_OBJECTS_AT_RESOLVE_INSTANCES ) == 0 && m_bInstanceRendering && !GetInstanceClass()->IsEditable() )
|
|
{
|
|
pObject = m_CurrentInstanceState.m_pTopInstanceClass; // GetInstanceClass();
|
|
uHandle = 0;
|
|
}
|
|
|
|
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
|
|
pRenderContext->PushSelectionName((unsigned int)pObject);
|
|
pRenderContext->PushSelectionName(uHandle);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called after rendering an object that should be hit tested when
|
|
// rendering in selection mode.
|
|
// Input : pObject - Map atom pointer that will be returned from the ObjectsAt
|
|
// routine if this rendered object is positively hit tested.
|
|
// Input : pObject -
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::EndRenderHitTarget(void)
|
|
{
|
|
if ( m_Pick.bPicking )
|
|
{
|
|
//
|
|
// Pop the name and the handle from the stack.
|
|
//
|
|
|
|
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
|
|
pRenderContext->PopSelectionName();
|
|
pRenderContext->PopSelectionName();
|
|
|
|
if ((pRenderContext->SelectionMode(true) != 0) && (m_Pick.nNumHits < MAX_PICK_HITS))
|
|
{
|
|
if (m_Pick.uSelectionBuffer[0] == 2)
|
|
{
|
|
m_Pick.Hits[m_Pick.nNumHits].pObject = (CMapClass *)m_Pick.uSelectionBuffer[3];
|
|
m_Pick.Hits[m_Pick.nNumHits].uData = m_Pick.uSelectionBuffer[4];
|
|
m_Pick.Hits[m_Pick.nNumHits].nDepth = m_Pick.uSelectionBuffer[1];
|
|
m_Pick.Hits[m_Pick.nNumHits].m_LocalMatrix = m_LocalMatrix.Head();
|
|
m_Pick.nNumHits++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output :
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::AddTranslucentDeferredRendering( CMapPoint *pMapPoint )
|
|
{
|
|
// object is translucent, render in 2nd batch
|
|
Vector direction = m_pView->GetViewAxis();
|
|
Vector center;
|
|
pMapPoint->GetOrigin(center);
|
|
|
|
TranslucentObjects_t entry;
|
|
if ( m_bInstanceRendering )
|
|
{
|
|
center += GetInstanceOrigin();
|
|
entry.m_InstanceState = m_CurrentInstanceState;
|
|
entry.m_bInstanceSelected = ( m_InstanceSelectionDepth != 0 );
|
|
}
|
|
else
|
|
{
|
|
entry.m_InstanceState.m_pInstanceClass = NULL;
|
|
}
|
|
|
|
entry.object = pMapPoint;
|
|
entry.depth = center.Dot( direction );
|
|
|
|
m_TranslucentRenderObjects.Insert(entry);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output :
|
|
//-----------------------------------------------------------------------------
|
|
float CRender3D::GetElapsedTime(void)
|
|
{
|
|
return(m_fTimeElapsed);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes us some geometry to render the frustum planes
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void CRender3D::ComputeFrustumRenderGeometry(CCamera *pCamera)
|
|
{
|
|
#ifdef _DEBUG
|
|
Vector viewPoint;
|
|
pCamera->GetViewPoint(viewPoint);
|
|
|
|
// Find lines along each of the plane intersections.
|
|
// We know these lines are perpendicular to both plane normals,
|
|
// so we can take the cross product to find them.
|
|
static int edgeIdx[4][2] =
|
|
{
|
|
{ 0, 2 }, { 0, 3 }, { 1, 3 }, { 1, 2 }
|
|
};
|
|
|
|
int i;
|
|
Vector edges[4];
|
|
for ( i = 0; i < 4; ++i)
|
|
{
|
|
CrossProduct( m_FrustumPlanes[edgeIdx[i][0]].AsVector3D(),
|
|
m_FrustumPlanes[edgeIdx[i][1]].AsVector3D(), edges[i] );
|
|
VectorNormalize( edges[i] );
|
|
}
|
|
|
|
// Figure out four near points by intersection lines with the near plane
|
|
// Figure out four far points by intersection with lines against far plane
|
|
for (i = 0; i < 4; ++i)
|
|
{
|
|
float t = (m_FrustumPlanes[4][3] - DotProduct(m_FrustumPlanes[4].AsVector3D(), viewPoint)) /
|
|
DotProduct(m_FrustumPlanes[4].AsVector3D(), edges[i]);
|
|
VectorMA( viewPoint, t, edges[i], m_FrustumRenderPoint[i] );
|
|
|
|
/*
|
|
t = (m_FrustumPlanes[5][3] - DotProduct(m_FrustumPlanes[5], viewPoint)) /
|
|
DotProduct(m_FrustumPlanes[5], edges[i]);
|
|
VectorMA( viewPoint, t, edges[i], m_FrustumRenderPoint[i + 4] );
|
|
*/
|
|
if (t < 0)
|
|
{
|
|
edges[i] *= -1;
|
|
}
|
|
|
|
VectorMA( m_FrustumRenderPoint[i], 200.0, edges[i], m_FrustumRenderPoint[i + 4] );
|
|
}
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// renders the frustum
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void CRender3D::RenderFrustum( )
|
|
{
|
|
#ifdef _DEBUG
|
|
static int indices[] =
|
|
{
|
|
0, 1, 1, 2, 2, 3, 3, 0, // near square
|
|
4, 5, 5, 6, 6, 7, 7, 4, // far square
|
|
0, 4, 1, 5, 2, 6, 3, 7 // connections between them
|
|
};
|
|
|
|
PushRenderMode( RENDER_MODE_WIREFRAME );
|
|
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
|
|
IMesh* pMesh = pRenderContext->GetDynamicMesh();
|
|
|
|
int numIndices = sizeof(indices) / sizeof(int);
|
|
CMeshBuilder meshBuilder;
|
|
meshBuilder.Begin( pMesh, MATERIAL_LINES, 8, numIndices );
|
|
|
|
int i;
|
|
for ( i = 0; i < 8; ++i )
|
|
{
|
|
meshBuilder.Position3fv( m_FrustumRenderPoint[i].Base() );
|
|
meshBuilder.Color4ub( 255, 255, 255, 255 );
|
|
meshBuilder.AdvanceVertex();
|
|
}
|
|
|
|
for ( i = 0; i < numIndices; ++i )
|
|
{
|
|
meshBuilder.Index( indices[i] );
|
|
meshBuilder.AdvanceIndex();
|
|
}
|
|
|
|
meshBuilder.End();
|
|
pMesh->Draw();
|
|
|
|
PopRenderMode();
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns the 3D grid spacing, in world units.
|
|
//-----------------------------------------------------------------------------
|
|
float CRender3D::GetGridDistance(void)
|
|
{
|
|
return(m_RenderState.fGridDistance);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns the 3D grid spacing, in world units.
|
|
//-----------------------------------------------------------------------------
|
|
float CRender3D::GetGridSize(void)
|
|
{
|
|
return(m_RenderState.fGridSpacing);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : hwnd -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CRender3D::SetView( CMapView *pView )
|
|
{
|
|
if ( !CRender::SetView( pView ) )
|
|
return false;
|
|
|
|
HWND hwnd = pView->GetViewWnd()->GetSafeHwnd();
|
|
CMapDoc *pDoc = pView->GetMapDoc();
|
|
|
|
Assert(hwnd != NULL);
|
|
Assert(pDoc != NULL);
|
|
Assert(pDoc->GetMapWorld() != NULL);
|
|
|
|
if (!MaterialSystemInterface()->AddView( hwnd ))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
MaterialSystemInterface()->SetView( hwnd );
|
|
m_WinData.hWnd = hwnd;
|
|
|
|
if ((m_WinData.hDC = GetDCEx(m_WinData.hWnd, NULL, DCX_CACHE | DCX_CLIPSIBLINGS)) == NULL)
|
|
{
|
|
ChangeDisplaySettings(NULL, 0);
|
|
MessageBox(NULL, "GetDC on main window failed", "FATAL ERROR", MB_OK);
|
|
return(false);
|
|
}
|
|
|
|
// Preload all our stuff (textures, etc) for rendering.
|
|
Preload( pDoc->GetMapWorld() );
|
|
|
|
// Store off the three materials we use most often...
|
|
if ( !GetRequiredMaterial( "editor/vertexcolor", m_pVertexColor[0] ) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
m_pVertexColor[1] = m_pVertexColor[0];
|
|
|
|
return(true);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Determines the visibility of the given axis-aligned bounding box.
|
|
// Input : pBox - Bounding box to evaluate.
|
|
// Output : VIS_TOTAL if the box is entirely within the view frustum.
|
|
// VIS_PARTIAL if the box is partially within the view frustum.
|
|
// VIS_NONE if the box is entirely outside the view frustum.
|
|
//-----------------------------------------------------------------------------
|
|
Visibility_t CRender3D::IsBoxVisible(Vector const &BoxMins, Vector const &BoxMaxs)
|
|
{
|
|
Vector NearVertex;
|
|
Vector FarVertex;
|
|
|
|
//
|
|
// Build the near and far vertices based on the octant of the plane normal.
|
|
//
|
|
int nInPlanes = 0;
|
|
for ( int i = 0; i < 6; i++ )
|
|
{
|
|
if (m_FrustumPlanes[i][0] > 0)
|
|
{
|
|
NearVertex[0] = BoxMins[0];
|
|
FarVertex[0] = BoxMaxs[0];
|
|
}
|
|
else
|
|
{
|
|
NearVertex[0] = BoxMaxs[0];
|
|
FarVertex[0] = BoxMins[0];
|
|
}
|
|
|
|
if (m_FrustumPlanes[i][1] > 0)
|
|
{
|
|
NearVertex[1] = BoxMins[1];
|
|
FarVertex[1] = BoxMaxs[1];
|
|
}
|
|
else
|
|
{
|
|
NearVertex[1] = BoxMaxs[1];
|
|
FarVertex[1] = BoxMins[1];
|
|
}
|
|
|
|
if (m_FrustumPlanes[i][2] > 0)
|
|
{
|
|
NearVertex[2] = BoxMins[2];
|
|
FarVertex[2] = BoxMaxs[2];
|
|
}
|
|
else
|
|
{
|
|
NearVertex[2] = BoxMaxs[2];
|
|
FarVertex[2] = BoxMins[2];
|
|
}
|
|
|
|
if (DotProduct(m_FrustumPlanes[i].AsVector3D(), NearVertex) >= m_FrustumPlanes[i][3])
|
|
{
|
|
return(VIS_NONE);
|
|
}
|
|
|
|
if (DotProduct(m_FrustumPlanes[i].AsVector3D(), FarVertex) < m_FrustumPlanes[i][3])
|
|
{
|
|
nInPlanes++;
|
|
}
|
|
}
|
|
|
|
if (nInPlanes == 6)
|
|
{
|
|
return(VIS_TOTAL);
|
|
}
|
|
|
|
return(VIS_PARTIAL);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : eRenderState -
|
|
// Output : Returns true if the render state is enabled, false if it is disabled.
|
|
//-----------------------------------------------------------------------------
|
|
bool CRender3D::IsEnabled(RenderState_t eRenderState)
|
|
{
|
|
switch (eRenderState)
|
|
{
|
|
case RENDER_CENTER_CROSSHAIR:
|
|
{
|
|
return(m_RenderState.bCenterCrosshair);
|
|
}
|
|
|
|
case RENDER_GRID:
|
|
{
|
|
return(m_RenderState.bDrawGrid);
|
|
}
|
|
|
|
case RENDER_REVERSE_SELECTION:
|
|
{
|
|
return(m_RenderState.bReverseSelection);
|
|
}
|
|
}
|
|
|
|
return(false);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Determines whether we are rendering for for selection or not.
|
|
// Output : Returns true if we are rendering for selection, false if rendering normally.
|
|
//-----------------------------------------------------------------------------
|
|
bool CRender3D::IsPicking(void)
|
|
{
|
|
return(m_Pick.bPicking);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns the map objects within the rectangle whose upper left corner
|
|
// is at the client coordinates (x, y) and whose width and height are
|
|
// fWidth and fHeight.
|
|
// Input : x - Leftmost point in the rectangle, in client coordinates.
|
|
// y - Topmost point in the rectangle, in client coordinates.
|
|
// fWidth - Width of rectangle, in client coordinates.
|
|
// fHeight - Height of rectangle, in client coordinates.
|
|
// pObjects - Pointer to buffer to receive objects intersecting the rectangle.
|
|
// nMaxObjects - Maximum number of object pointers to place in the buffer.
|
|
// Output : Returns the number of object pointers placed in the buffer pointed to
|
|
// by 'pObjects'.
|
|
//-----------------------------------------------------------------------------
|
|
int CRender3D::ObjectsAt( float x, float y, float fWidth, float fHeight, HitInfo_t *pObjects, int nMaxObjects, unsigned int nFlags )
|
|
{
|
|
int width, height;
|
|
|
|
GetCamera()->GetViewPort(width,height);
|
|
|
|
m_Pick.fX = x;
|
|
m_Pick.fY = height - (y + 1);
|
|
m_Pick.fWidth = fWidth;
|
|
m_Pick.fHeight = fHeight;
|
|
m_Pick.pHitsDest = pObjects;
|
|
m_Pick.nMaxHits = min(nMaxObjects, MAX_PICK_HITS);
|
|
m_Pick.nNumHits = 0;
|
|
|
|
if (!m_RenderState.bReverseSelection)
|
|
{
|
|
m_Pick.uLastZ = 0xFFFFFFFF;
|
|
}
|
|
else
|
|
{
|
|
m_Pick.uLastZ = 0;
|
|
}
|
|
|
|
m_Pick.m_nFlags = nFlags;
|
|
m_Pick.bPicking = true;
|
|
|
|
EditorRenderMode_t eOldMode = GetDefaultRenderMode();
|
|
SetDefaultRenderMode( RENDER_MODE_TEXTURED );
|
|
|
|
bool bOldLightPreview = IsInLightingPreview();
|
|
SetInLightingPreview( false );
|
|
|
|
Render( false );
|
|
|
|
SetDefaultRenderMode( eOldMode );
|
|
SetInLightingPreview( bOldLightPreview );
|
|
|
|
m_Pick.bPicking = false;
|
|
|
|
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
|
|
pRenderContext->SelectionMode(false);
|
|
|
|
return(m_Pick.nNumHits);
|
|
}
|
|
|
|
static ITexture *SetRenderTargetNamed(int nWhichTarget, char const *pRtName)
|
|
{
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
ITexture *dest_rt=materials->FindTexture(pRtName, TEXTURE_GROUP_RENDER_TARGET );
|
|
pRenderContext->SetRenderTargetEx(nWhichTarget,dest_rt);
|
|
return dest_rt;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::StartRenderFrame( bool bRenderingOverEngine )
|
|
{
|
|
CRender::StartRenderFrame( bRenderingOverEngine );
|
|
|
|
CCamera *pCamera = GetCamera();
|
|
|
|
//
|
|
// Determine the elapsed time since the last frame was rendered.
|
|
//
|
|
DWORD dwTimeNow = timeGetTime();
|
|
if (m_dwTimeLastFrame == 0)
|
|
{
|
|
m_dwTimeLastFrame = dwTimeNow;
|
|
}
|
|
DWORD dwTimeElapsed = dwTimeNow - m_dwTimeLastFrame;
|
|
m_fTimeElapsed = (float)dwTimeElapsed / 1000.0;
|
|
m_dwTimeLastFrame = dwTimeNow;
|
|
|
|
//
|
|
// Animate the models based on elapsed time.
|
|
//
|
|
CMapStudioModel::AdvanceAnimation( GetElapsedTime() );
|
|
|
|
// view materialsystem viewport
|
|
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
|
|
|
|
// We're drawing to this view now
|
|
if ( !m_bRenderingOverEngine )
|
|
{
|
|
MaterialSystemInterface()->SetView( m_WinData.hWnd );
|
|
|
|
int width, height;
|
|
pCamera->GetViewPort( width, height );
|
|
if (
|
|
(m_eCurrentRenderMode == RENDER_MODE_LIGHT_PREVIEW2) ||
|
|
(m_eCurrentRenderMode == RENDER_MODE_LIGHT_PREVIEW_RAYTRACED)
|
|
)
|
|
{
|
|
AllocateLightingPreviewtextures();
|
|
|
|
ITexture *first_rt=SetRenderTargetNamed(0,"_rt_albedo");
|
|
SetRenderTargetNamed(1,"_rt_normal");
|
|
SetRenderTargetNamed(2,"_rt_position");
|
|
int nTargetWidth = max( 32, min( width, first_rt->GetActualWidth() ) );
|
|
int nTargetHeight = max( 32, min( height, first_rt->GetActualHeight() ) );
|
|
pRenderContext->
|
|
Viewport(0, 0, nTargetWidth, nTargetHeight );
|
|
pRenderContext->ClearColor3ub(0,1,0);
|
|
pRenderContext->ClearBuffers( true, true );
|
|
}
|
|
else
|
|
pRenderContext->Viewport(0, 0, width, height);
|
|
|
|
//
|
|
// Setup the camera position, orientation, and FOV.
|
|
//
|
|
//
|
|
// Set up our perspective transformation.
|
|
//
|
|
|
|
// if picking, setup extra perspective matrix
|
|
if ( m_Pick.bPicking )
|
|
{
|
|
pRenderContext->MatrixMode(MATERIAL_PROJECTION);
|
|
pRenderContext->LoadIdentity();
|
|
|
|
pRenderContext->PickMatrix(m_Pick.fX, m_Pick.fY, m_Pick.fWidth, m_Pick.fHeight);
|
|
pRenderContext->SelectionBuffer(m_Pick.uSelectionBuffer, ARRAYSIZE(m_Pick.uSelectionBuffer));
|
|
pRenderContext->SelectionMode(true);
|
|
pRenderContext->ClearSelectionNames();
|
|
|
|
float aspect = (float)width / (float)height;
|
|
|
|
pRenderContext->PerspectiveX( pCamera->GetFOV(),
|
|
aspect, pCamera->GetNearClip(), pCamera->GetFarClip() );
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Clear the frame buffer and Z buffer.
|
|
//
|
|
|
|
pRenderContext->ClearColor3ub( 0,0,0 );
|
|
pRenderContext->ClearBuffers( true, true, true );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Build the frustum planes for view volume culling.
|
|
//
|
|
CCamera *pTempCamera = NULL;
|
|
|
|
if (m_bDroppedCamera)
|
|
{
|
|
pTempCamera = pCamera;
|
|
pCamera = m_pDropCamera;
|
|
}
|
|
|
|
pCamera->GetFrustumPlanes( m_FrustumPlanes);
|
|
|
|
// For debugging frustum planes
|
|
#ifdef _DEBUG
|
|
if (m_bRecomputeFrustumRenderGeometry)
|
|
{
|
|
ComputeFrustumRenderGeometry( pCamera );
|
|
m_bRecomputeFrustumRenderGeometry = false;
|
|
}
|
|
#endif
|
|
|
|
if (m_bDroppedCamera)
|
|
{
|
|
pCamera = pTempCamera;
|
|
}
|
|
|
|
//
|
|
// Cache per-frame information from the doc.
|
|
//
|
|
m_RenderState.fGridSpacing = m_pView->GetMapDoc()->GetGridSpacing();
|
|
m_RenderState.fGridDistance = m_RenderState.fGridSpacing * 10;
|
|
if (m_RenderState.fGridDistance > 2048)
|
|
{
|
|
m_RenderState.fGridDistance = 2048;
|
|
}
|
|
else if (m_RenderState.fGridDistance < 64)
|
|
{
|
|
m_RenderState.fGridDistance = 64;
|
|
}
|
|
|
|
// We do bizarro reverse culling in WC
|
|
pRenderContext->CullMode( MATERIAL_CULLMODE_CCW );
|
|
|
|
Assert( m_TranslucentRenderObjects.Count() == 0 );
|
|
}
|
|
|
|
|
|
static void SetNamedMaterialVar(IMaterial *pMat, char const *pVName, float fValue)
|
|
{
|
|
IMaterialVar *pVar = pMat->FindVar( pVName, NULL );
|
|
pVar->SetFloatValue( fValue );
|
|
}
|
|
|
|
|
|
bool CompareLightPreview_Lights(CLightPreview_Light const &a, CLightPreview_Light const &b)
|
|
{
|
|
return (a.m_flDistanceToEye > b.m_flDistanceToEye);
|
|
}
|
|
|
|
#define MAX_PREVIEW_LIGHTS 20 // max # of lights to process.
|
|
|
|
|
|
void CRender3D::SendShadowTriangles( void )
|
|
{
|
|
static int LastSendTimeStamp=-1;
|
|
if ( GetUpdateCounter( EVTYPE_FACE_CHANGED ) != LastSendTimeStamp )
|
|
{
|
|
LastSendTimeStamp = GetUpdateCounter( EVTYPE_FACE_CHANGED );
|
|
CUtlVector<Vector> *tri_list=new CUtlVector<Vector>;
|
|
CMapDoc *pDoc = m_pView->GetMapDoc();
|
|
CMapWorld *pWorld = pDoc->GetMapWorld();
|
|
|
|
if ( !pWorld )
|
|
return;
|
|
|
|
if (g_pLPreviewOutputBitmap)
|
|
delete g_pLPreviewOutputBitmap;
|
|
g_pLPreviewOutputBitmap = NULL;
|
|
EnumChildrenPos_t pos;
|
|
CMapClass *pChild = pWorld->GetFirstDescendent( pos );
|
|
while ( pChild )
|
|
{
|
|
if (pChild->IsVisible())
|
|
pChild->AddShadowingTriangles( *tri_list );
|
|
pChild = pWorld->GetNextDescendent( pos );
|
|
}
|
|
if ( tri_list->Count() )
|
|
{
|
|
MessageToLPreview msg( LPREVIEW_MSG_GEOM_DATA );
|
|
msg.m_pShadowTriangleList = tri_list;
|
|
g_HammerToLPreviewMsgQueue.QueueMessage( msg );
|
|
}
|
|
else
|
|
delete tri_list;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
static bool LightForString( char const *pLight, Vector& intensity )
|
|
{
|
|
double r, g, b, scaler;
|
|
|
|
VectorFill( intensity, 0 );
|
|
|
|
// scanf into doubles, then assign, so it is vec_t size independent
|
|
r = g = b = scaler = 0;
|
|
double r_hdr,g_hdr,b_hdr,scaler_hdr;
|
|
int argCnt = sscanf ( pLight, "%lf %lf %lf %lf %lf %lf %lf %lf",
|
|
&r, &g, &b, &scaler, &r_hdr,&g_hdr,&b_hdr,&scaler_hdr );
|
|
|
|
// This is a special case for HDR lights. If we have a vector of [-1, -1, -1, 1], then we
|
|
// need to fall back to the non-HDR lighting since the HDR lighting hasn't been defined
|
|
// for this light source.
|
|
if( ( argCnt == 3 && r == -1.0f && g == -1.0f && b == -1.0f ) ||
|
|
( argCnt == 4 && r == -1.0f && g == -1.0f && b == -1.0f && scaler == 1.0f ) )
|
|
{
|
|
intensity.Init( -1.0f, -1.0f, -1.0f );
|
|
return true;
|
|
}
|
|
|
|
if (argCnt==8) // 2 4-tuples
|
|
{
|
|
if (g_bHDR)
|
|
{
|
|
r=r_hdr;
|
|
g=g_hdr;
|
|
b=b_hdr;
|
|
scaler=scaler_hdr;
|
|
}
|
|
argCnt=4;
|
|
}
|
|
|
|
intensity[0] = pow( r / 255.0, 2.2 ) * 255; // convert to linear
|
|
|
|
switch( argCnt)
|
|
{
|
|
case 1:
|
|
// The R,G,B values are all equal.
|
|
intensity[1] = intensity[2] = intensity[0];
|
|
break;
|
|
|
|
case 3:
|
|
case 4:
|
|
// Save the other two G,B values.
|
|
intensity[1] = pow( g / 255.0, 2.2 ) * 255;
|
|
intensity[2] = pow( b / 255.0, 2.2 ) * 255;
|
|
|
|
// Did we also get an "intensity" scaler value too?
|
|
if ( argCnt == 4 )
|
|
{
|
|
// Scale the normalized 0-255 R,G,B values by the intensity scaler
|
|
VectorScale( intensity, scaler / 255.0, intensity );
|
|
}
|
|
break;
|
|
|
|
default:
|
|
printf("unknown light specifier type - %s\n",pLight);
|
|
return false;
|
|
}
|
|
// change light to 0..1
|
|
intensity *= (1.0/255);
|
|
return true;
|
|
}
|
|
|
|
// ugly code copied from vrad and munged. Should move into a lib
|
|
static bool LightForKey (CMapEntity *ent, char *key, Vector& intensity )
|
|
{
|
|
char const *pLight = ent->GetKeyValue( key );
|
|
|
|
return LightForString( pLight, intensity );
|
|
}
|
|
|
|
static void GetVectorForKey( CMapEntity *e, char const *kname, Vector *out )
|
|
{
|
|
Vector ret(-1,-1,-1);
|
|
char const *pk = e->GetKeyValue( kname );
|
|
if ( pk )
|
|
{
|
|
sscanf( pk, "%f %f %f", &(ret.x), &(ret.y), &(ret.z) );
|
|
}
|
|
*out=ret;
|
|
}
|
|
static float GetFloatForKey( CMapEntity *e, char const *kname)
|
|
{
|
|
char const *pk = e->GetKeyValue( kname );
|
|
if ( pk )
|
|
return atof( pk );
|
|
else
|
|
return 0.0;
|
|
}
|
|
|
|
static void SetLightFalloffParams( CMapEntity *e, CLightingPreviewLightDescription &l)
|
|
{
|
|
float d50=GetFloatForKey(e,"_fifty_percent_distance");
|
|
if (d50)
|
|
{
|
|
float d0=GetFloatForKey(e,"_zero_percent_distance");
|
|
l.SetupNewStyleAttenuation( d50, d0 );
|
|
}
|
|
else
|
|
{
|
|
float c = GetFloatForKey (e, "_constant_attn");
|
|
float b = GetFloatForKey (e, "_linear_attn");
|
|
float a = GetFloatForKey (e, "_quadratic_attn");
|
|
|
|
l.SetupOldStyleAttenuation( a, b, c );
|
|
}
|
|
}
|
|
|
|
static bool ParseLightAmbient( CMapEntity *e, CLightingPreviewLightDescription &out )
|
|
{
|
|
if( LightForKey( e, "_ambient", out.m_Color ) == 0 )
|
|
return false;
|
|
return true;
|
|
|
|
}
|
|
|
|
static bool ParseLightGeneric( CMapEntity *e, CLightingPreviewLightDescription &out )
|
|
{
|
|
// returns false if it doesn't like the light
|
|
|
|
// get intensity
|
|
if( g_bHDR )
|
|
{
|
|
if( LightForKey( e, "_lightHDR", out.m_Color ) == 0 ||
|
|
( out.m_Color.x == -1.0f &&
|
|
out.m_Color.y == -1.0f &&
|
|
out.m_Color.z == -1.0f ) )
|
|
{
|
|
LightForKey( e, "_light", out.m_Color );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LightForKey( e, "_light", out.m_Color );
|
|
}
|
|
|
|
// handle spot falloffs
|
|
if ( out.m_Type == MATERIAL_LIGHT_SPOT )
|
|
{
|
|
out.m_Theta=GetFloatForKey(e, "_inner_cone");
|
|
out.m_Theta *= (M_PI/180.0);
|
|
out.m_Phi=GetFloatForKey(e,"_cone");
|
|
out.m_Phi *= (M_PI/180.0);
|
|
out.m_Falloff=GetFloatForKey(e,"_exponent");
|
|
}
|
|
|
|
|
|
// check angle, targets
|
|
#if 0 // !!bug!!
|
|
target = e->m_KeyValues.GetValue( "target");
|
|
if (target[0])
|
|
{ // point towards target
|
|
entity_t *e2;
|
|
char *target;
|
|
e2 = FindTargetEntity (target);
|
|
if (!e2)
|
|
Warning("WARNING: light at (%i %i %i) has missing target\n",
|
|
(int)dl->light.origin[0], (int)dl->light.origin[1], (int)dl->light.origin[2]);
|
|
else
|
|
{
|
|
Vector dest;
|
|
GetVectorForKey (e2, "origin", &dest);
|
|
VectorSubtract (dest, dl->light.origin, dl->light.normal);
|
|
VectorNormalize (dl->light.normal);
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
// point down angle
|
|
Vector angles;
|
|
GetVectorForKey( e, "angles", &angles );
|
|
float pitch = GetFloatForKey( e,"pitch");
|
|
float angle = GetFloatForKey( e,"angle" );
|
|
SetupLightNormalFromProps( QAngle( angles.x, angles.y, angles.z ), angle, pitch,
|
|
out.m_Direction );
|
|
}
|
|
if ( out.m_Type == MATERIAL_LIGHT_DIRECTIONAL )
|
|
{
|
|
out.m_Range = 0;
|
|
out.m_Attenuation2 = out.m_Attenuation1 = out.m_Attenuation0 = 0;
|
|
out.m_Direction *= -1;
|
|
}
|
|
else
|
|
SetLightFalloffParams( e, out );
|
|
return true;
|
|
}
|
|
|
|
// when there are multiple lighting environments, we are supposed to ignore but the first
|
|
static bool s_bAddedLightEnvironmentAlready;
|
|
|
|
|
|
|
|
|
|
static void AddEntityLightToLightList(
|
|
CMapEntity *e,
|
|
CUtlIntrusiveList<CLightingPreviewLightDescription> &listout )
|
|
{
|
|
char const *pszClassName=e->GetClassName();
|
|
if (pszClassName)
|
|
{
|
|
CLightingPreviewLightDescription new_l;
|
|
new_l.Init( e->m_nObjectID );
|
|
e->GetOrigin( new_l.m_Position );
|
|
new_l.m_Range = 0;
|
|
|
|
if ( (! s_bAddedLightEnvironmentAlready ) &&
|
|
(! stricmp( pszClassName, "light_environment" ) ))
|
|
{
|
|
const int N_FAKE_LIGHTS_FOR_AMBIENT = 100.0;
|
|
const float AMBIENT_LIGHT_DISTANCE = 100000;
|
|
const float AMBIENT_LIGHT_JITTER = 2.0 *
|
|
sqrt( AMBIENT_LIGHT_DISTANCE * AMBIENT_LIGHT_DISTANCE * 2 * M_PI / N_FAKE_LIGHTS_FOR_AMBIENT );
|
|
// lets add the sun to the list!
|
|
new_l.m_Type = MATERIAL_LIGHT_DIRECTIONAL;
|
|
if ( ParseLightGeneric(e,new_l) )
|
|
{
|
|
new_l.m_Position = new_l.m_Direction * AMBIENT_LIGHT_DISTANCE;
|
|
new_l.RecalculateDerivedValues();
|
|
CLightingPreviewLightDescription *pNew = new CLightingPreviewLightDescription;
|
|
*pNew = new_l;
|
|
listout.AddToHead( pNew );
|
|
s_bAddedLightEnvironmentAlready = true;
|
|
}
|
|
// now, add the ambient sphere. We will approximate as "N" directional lights
|
|
if ( ParseLightAmbient( e, new_l ) )
|
|
{
|
|
DirectionalSampler_t sampler;
|
|
Vector color = new_l.m_Color;
|
|
for( int i = 0; i < N_FAKE_LIGHTS_FOR_AMBIENT; i++)
|
|
{
|
|
new_l.Init( 0x80000000 | i ); // special id for ambient
|
|
new_l.m_Type = MATERIAL_LIGHT_DIRECTIONAL;
|
|
Vector dir = sampler.NextValue();
|
|
if ( dir.z < 0 )
|
|
{
|
|
continue;
|
|
}
|
|
new_l.m_Direction = dir;
|
|
new_l.m_Position = new_l.m_Direction * AMBIENT_LIGHT_DISTANCE;
|
|
new_l.m_flJitterAmount = AMBIENT_LIGHT_JITTER;
|
|
new_l.m_Color = color * ( 1.0 / N_FAKE_LIGHTS_FOR_AMBIENT );
|
|
new_l.RecalculateDerivedValues();
|
|
CLightingPreviewLightDescription *pNew = new CLightingPreviewLightDescription;
|
|
*pNew = new_l;
|
|
listout.AddToHead( pNew );
|
|
}
|
|
}
|
|
}
|
|
else if ( (! stricmp( pszClassName, "light" ) ))
|
|
{
|
|
// add point light to list
|
|
new_l.m_Type = MATERIAL_LIGHT_POINT;
|
|
if ( ParseLightGeneric(e,new_l) )
|
|
{
|
|
new_l.RecalculateDerivedValues();
|
|
CLightingPreviewLightDescription *pNew = new CLightingPreviewLightDescription;
|
|
*pNew = new_l;
|
|
listout.AddToHead( pNew );
|
|
}
|
|
}
|
|
else if ( (! stricmp( pszClassName, "light_spot" ) ))
|
|
{
|
|
// add point light to list
|
|
new_l.m_Type = MATERIAL_LIGHT_SPOT;
|
|
if ( ParseLightGeneric(e,new_l) )
|
|
{
|
|
new_l.RecalculateDerivedValues();
|
|
CLightingPreviewLightDescription *pNew = new CLightingPreviewLightDescription;
|
|
*pNew = new_l;
|
|
listout.AddToHead( pNew );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
CUtlIntrusiveList<CLightingPreviewLightDescription> CRender3D::BuildLightList( void ) const
|
|
{
|
|
CUtlIntrusiveList<CLightingPreviewLightDescription> pRet;
|
|
CMapDoc *pDoc = m_pView->GetMapDoc();
|
|
CMapWorld *pWorld = pDoc->GetMapWorld();
|
|
|
|
if ( pWorld )
|
|
{
|
|
|
|
EnumChildrenPos_t pos;
|
|
CMapClass *pChild = pWorld->GetFirstDescendent( pos );
|
|
while ( pChild )
|
|
{
|
|
CMapEntity *pLightEntity=dynamic_cast<CMapEntity*>( pChild );
|
|
if (pLightEntity && (pLightEntity->m_EntityTypeFlags & ENTITY_FLAG_IS_LIGHT ) &&
|
|
(pLightEntity->IsVisible()) )
|
|
AddEntityLightToLightList( pLightEntity, pRet );
|
|
pChild = pWorld->GetNextDescendent( pos );
|
|
}
|
|
}
|
|
return pRet;
|
|
}
|
|
|
|
void CRender3D::SendLightList( void )
|
|
{
|
|
// send light list to lighting preview thread in priority order
|
|
|
|
static int LastSendTimeStamp=-1;
|
|
s_bAddedLightEnvironmentAlready = false;
|
|
if ( GetUpdateCounter( EVTYPE_LIGHTING_CHANGED ) != LastSendTimeStamp )
|
|
{
|
|
LastSendTimeStamp = GetUpdateCounter( EVTYPE_LIGHTING_CHANGED );
|
|
if (g_pLPreviewOutputBitmap)
|
|
delete g_pLPreviewOutputBitmap;
|
|
g_pLPreviewOutputBitmap = NULL;
|
|
// now, get list of lights
|
|
CUtlIntrusiveList<CLightingPreviewLightDescription> pList = BuildLightList( );
|
|
MessageToLPreview Msg( LPREVIEW_MSG_LIGHT_DATA );
|
|
Msg.m_LightList = pList; // thread deletes
|
|
CCamera *pCamera = GetCamera();
|
|
pCamera->GetViewPoint( Msg.m_EyePosition );
|
|
|
|
g_HammerToLPreviewMsgQueue.QueueMessage( Msg );
|
|
}
|
|
}
|
|
|
|
void DrawScreenSpaceLightRectangle(
|
|
CMeshBuilder &meshBuilder,
|
|
int nDestX, int nDestY, int nWidth, int nHeight, // Rect to draw into in screen space
|
|
float flSrcTextureX0, float flSrcTextureY0, // which texel you want to appear at destx/y
|
|
float flSrcTextureX1, float flSrcTextureY1, // which texel you want to appear at destx+width-1, desty+height-1
|
|
int nSrcTextureWidth, int nSrcTextureHeight, // needed for fixup
|
|
LightDesc_t const &light,
|
|
CMatRenderContextPtr &pRenderContext )
|
|
{
|
|
int nScreenWidth, nScreenHeight;
|
|
pRenderContext->GetRenderTargetDimensions( nScreenWidth, nScreenHeight );
|
|
float flLeftX = nDestX - 0.5f;
|
|
float flRightX = nDestX + nWidth - 0.5f;
|
|
|
|
float flTopY = nDestY - 0.5f;
|
|
float flBottomY = nDestY + nHeight - 0.5f;
|
|
|
|
float flSubrectWidth = flSrcTextureX1 - flSrcTextureX0;
|
|
float flSubrectHeight = flSrcTextureY1 - flSrcTextureY0;
|
|
|
|
float flTexelsPerPixelX = ( nWidth > 1 ) ? flSubrectWidth / ( nWidth - 1 ) : 0.0f;
|
|
float flTexelsPerPixelY = ( nHeight > 1 ) ? flSubrectHeight / ( nHeight - 1 ) : 0.0f;
|
|
|
|
float flLeftU = flSrcTextureX0 + 0.5f - ( 0.5f * flTexelsPerPixelX );
|
|
float flRightU = flSrcTextureX1 + 0.5f + ( 0.5f * flTexelsPerPixelX );
|
|
float flTopV = flSrcTextureY0 + 0.5f - ( 0.5f * flTexelsPerPixelY );
|
|
float flBottomV = flSrcTextureY1 + 0.5f + ( 0.5f * flTexelsPerPixelY );
|
|
|
|
float flOOTexWidth = 1.0f / nSrcTextureWidth;
|
|
float flOOTexHeight = 1.0f / nSrcTextureHeight;
|
|
flLeftU *= flOOTexWidth;
|
|
flRightU *= flOOTexWidth;
|
|
flTopV *= flOOTexHeight;
|
|
flBottomV *= flOOTexHeight;
|
|
|
|
// Get the current viewport size
|
|
int vx, vy, vw, vh;
|
|
pRenderContext->GetViewport( vx, vy, vw, vh );
|
|
|
|
// map from screen pixel coords to -1..1
|
|
flRightX = FLerp( -1, 1, 0, vw, flRightX );
|
|
flLeftX = FLerp( -1, 1, 0, vw, flLeftX );
|
|
flTopY = FLerp( 1, -1, 0, vh ,flTopY );
|
|
flBottomY = FLerp( 1, -1, 0, vh, flBottomY );
|
|
|
|
Vector color_intens = light.m_Color;
|
|
Vector spot_dir = light.m_Direction;
|
|
for ( int corner = 0; corner < 4; corner++ )
|
|
{
|
|
bool bLeft = (corner==0) || (corner==3);
|
|
meshBuilder.Position3f( (bLeft) ? flLeftX : flRightX, (corner & 2) ? flBottomY : flTopY, 0.0f );
|
|
meshBuilder.TexCoord2f( 0, (bLeft) ? flLeftU : flRightU, (corner & 2) ? flBottomV : flTopV );
|
|
float pdot = light.m_PhiDot;
|
|
float tdot = light.m_ThetaDot;
|
|
if ( light.m_Type == MATERIAL_LIGHT_POINT )
|
|
{
|
|
// model point light as a spot with infinite inner radius
|
|
pdot = 1.0e10;
|
|
tdot = 0.5;
|
|
}
|
|
meshBuilder.TexCoord4f( 1, color_intens.x, color_intens.y, color_intens.z, tdot );
|
|
meshBuilder.TexCoord4f( 2, spot_dir.x, spot_dir.y, spot_dir.z, pdot );
|
|
meshBuilder.TexCoord3fv( 3, light.m_Position.Base() );
|
|
meshBuilder.TexCoord4f( 4, light.m_Attenuation2, light.m_Attenuation1, light.m_Attenuation0, 1.0 );
|
|
meshBuilder.AdvanceVertex();
|
|
}
|
|
|
|
}
|
|
|
|
#define APPLYSIGN( posneg, incr ) ( ( posneg ) ? ( incr ) : ( - ( incr ) ) )
|
|
|
|
static int s_CubeIndices[]={
|
|
5, 4, 6, // front
|
|
6, 7, 5,
|
|
4, 0, 2, // rside
|
|
2, 6, 4,
|
|
2, 0, 1, // back
|
|
1, 3, 2,
|
|
1, 0, 4, // top
|
|
4, 5, 1,
|
|
6, 2, 3, // bot
|
|
3, 7, 6,
|
|
5, 7, 3, // lside
|
|
3, 1, 5
|
|
};
|
|
|
|
int DrawWorldSpaceLightCube(
|
|
CMeshBuilder &meshBuilder,
|
|
CMatRenderContextPtr &pRenderContext,
|
|
LightDesc_t const &light,
|
|
int nIndex )
|
|
{
|
|
Vector color_intens = light.m_Color;
|
|
Vector spot_dir = light.m_Direction;
|
|
float rad = light.DistanceAtWhichBrightnessIsLessThan( 1.0/ 255 );
|
|
|
|
Vector vecProjectionPlane0 = CrossProduct( spot_dir, Vector( 0, 1, 0 ) ) + CrossProduct( spot_dir, Vector( 1, 0, 0 ) );
|
|
vecProjectionPlane0.NormalizeInPlace();
|
|
Vector vecProjectionPlane1 = CrossProduct( spot_dir, vecProjectionPlane0 );
|
|
Assert( fabs( DotProduct( spot_dir, vecProjectionPlane0 ) ) < 0.01 );
|
|
Assert( fabs( DotProduct( spot_dir, vecProjectionPlane1 ) ) < 0.01 );
|
|
Assert( fabs( DotProduct( vecProjectionPlane0, vecProjectionPlane1 ) ) < 0.01 );
|
|
|
|
for ( int corner = 0; corner < 8; corner++ )
|
|
{
|
|
Vector vecPnt = light.m_Position;
|
|
vecPnt.x += APPLYSIGN( corner & 1, rad );
|
|
vecPnt.y += APPLYSIGN( corner & 2, rad );
|
|
vecPnt.z += APPLYSIGN( corner & 4, rad );
|
|
|
|
meshBuilder.Position3fv( vecPnt.Base() );
|
|
//meshBuilder.TexCoord2f( 0, (bLeft) ? flLeftU : flRightU, (corner & 2) ? flBottomV : flTopV );
|
|
float pdot = light.m_PhiDot;
|
|
float tdot = light.m_ThetaDot;
|
|
if ( light.m_Type == MATERIAL_LIGHT_POINT )
|
|
{
|
|
// model point light as a spot with infinite inner radius
|
|
pdot = 1.0e10;
|
|
tdot = 0.5;
|
|
}
|
|
meshBuilder.TexCoord4f( 1, color_intens.x, color_intens.y, color_intens.z, tdot );
|
|
meshBuilder.TexCoord4f( 2, spot_dir.x, spot_dir.y, spot_dir.z, pdot );
|
|
meshBuilder.TexCoord3fv( 3, light.m_Position.Base() );
|
|
meshBuilder.TexCoord4f( 4, light.m_Attenuation2, light.m_Attenuation1, light.m_Attenuation0, 1.0 );
|
|
meshBuilder.AdvanceVertex();
|
|
}
|
|
// now, output indices
|
|
for( int i = 0; i < ARRAYSIZE( s_CubeIndices ); i++ )
|
|
{
|
|
meshBuilder.FastIndex( s_CubeIndices[i] + nIndex );
|
|
}
|
|
return 8;
|
|
|
|
}
|
|
|
|
int DrawWorldSpaceLightPyramid(
|
|
CMeshBuilder &meshBuilder,
|
|
CMatRenderContextPtr &pRenderContext,
|
|
LightDesc_t const &light,
|
|
int nIndex )
|
|
{
|
|
if ( light.m_PhiDot < 0.0001 )
|
|
return DrawWorldSpaceLightCube( meshBuilder, pRenderContext, light, nIndex );
|
|
Vector color_intens = light.m_Color;
|
|
Vector spot_dir = light.m_Direction;
|
|
// now, we need to find two vectors perpendicular to each other and the ray direction
|
|
Vector vecProjectionPlane0 = CrossProduct( spot_dir, Vector( 0, 1, 0 ) ) + CrossProduct( spot_dir, Vector( 1, 0, 0 ) );
|
|
vecProjectionPlane0.NormalizeInPlace();
|
|
Vector vecProjectionPlane1 = CrossProduct( spot_dir, vecProjectionPlane0 );
|
|
Assert( fabs( DotProduct( spot_dir, vecProjectionPlane0 ) ) < 0.01 );
|
|
Assert( fabs( DotProduct( spot_dir, vecProjectionPlane1 ) ) < 0.01 );
|
|
Assert( fabs( DotProduct( vecProjectionPlane0, vecProjectionPlane1 ) ) < 0.01 );
|
|
|
|
|
|
float dist = light.DistanceAtWhichBrightnessIsLessThan( 1.0/ 255 );
|
|
|
|
float flSpreadPerDistance = sqrt( 1.0 / ( light.m_PhiDot * light.m_PhiDot ) -1 );
|
|
|
|
float flEndRad = 2.0 * dist * flSpreadPerDistance;
|
|
|
|
for ( int corner = 0; corner < 5; corner++ )
|
|
{
|
|
Vector vecPnt = light.m_Position;
|
|
Vector Color(1,1,1);
|
|
switch( corner )
|
|
{
|
|
case 0:
|
|
vecPnt += dist * spot_dir - flEndRad * vecProjectionPlane0 + flEndRad * vecProjectionPlane1;
|
|
Color.Init( 1, 0, 0 );
|
|
break;
|
|
|
|
case 1:
|
|
vecPnt += dist * spot_dir + flEndRad * vecProjectionPlane0 + flEndRad * vecProjectionPlane1;
|
|
Color.Init( 0, 1, 0 );
|
|
break;
|
|
|
|
case 2:
|
|
vecPnt += dist * spot_dir - flEndRad * vecProjectionPlane0 - flEndRad * vecProjectionPlane1;
|
|
Color.Init( 0, 0, 1 );
|
|
break;
|
|
|
|
case 3:
|
|
vecPnt += dist * spot_dir + flEndRad * vecProjectionPlane0 - flEndRad * vecProjectionPlane1;
|
|
Color.Init( 1, 0, 1 );
|
|
break;
|
|
}
|
|
meshBuilder.TexCoord3fv( 5, Color.Base() );
|
|
meshBuilder.Position3fv( vecPnt.Base() );
|
|
//meshBuilder.TexCoord2f( 0, (bLeft) ? flLeftU : flRightU, (corner & 2) ? flBottomV : flTopV );
|
|
float pdot = light.m_PhiDot;
|
|
float tdot = light.m_ThetaDot;
|
|
if ( light.m_Type == MATERIAL_LIGHT_POINT )
|
|
{
|
|
// model point light as a spot with infinite inner radius
|
|
pdot = 1.0e10;
|
|
tdot = 0.5;
|
|
}
|
|
meshBuilder.TexCoord4f( 1, color_intens.x, color_intens.y, color_intens.z, tdot );
|
|
meshBuilder.TexCoord4f( 2, spot_dir.x, spot_dir.y, spot_dir.z, pdot );
|
|
meshBuilder.TexCoord3fv( 3, light.m_Position.Base() );
|
|
meshBuilder.TexCoord4f( 4, light.m_Attenuation2, light.m_Attenuation1, light.m_Attenuation0, 1.0 );
|
|
meshBuilder.AdvanceVertex();
|
|
}
|
|
meshBuilder.FastIndex( nIndex + 1 ); // top
|
|
meshBuilder.FastIndex( nIndex + 0 );
|
|
meshBuilder.FastIndex( nIndex + 4 );
|
|
|
|
meshBuilder.FastIndex( nIndex + 2 ); // bottom
|
|
meshBuilder.FastIndex( nIndex + 3 );
|
|
meshBuilder.FastIndex( nIndex + 4 );
|
|
|
|
meshBuilder.FastIndex( nIndex + 3 ); // right
|
|
meshBuilder.FastIndex( nIndex + 1 );
|
|
meshBuilder.FastIndex( nIndex + 4 );
|
|
|
|
meshBuilder.FastIndex( nIndex + 0 ); // right
|
|
meshBuilder.FastIndex( nIndex + 2 );
|
|
meshBuilder.FastIndex( nIndex + 4 );
|
|
|
|
|
|
meshBuilder.FastIndex( nIndex + 0 ); // end cap
|
|
meshBuilder.FastIndex( nIndex + 1 );
|
|
meshBuilder.FastIndex( nIndex + 3 );
|
|
meshBuilder.FastIndex( nIndex + 3 );
|
|
meshBuilder.FastIndex( nIndex + 2 );
|
|
meshBuilder.FastIndex( nIndex + 0 );
|
|
|
|
return 5;
|
|
|
|
}
|
|
|
|
static Vector s_pCornerPoints[4]={
|
|
Vector( -1, -1, 0 ),
|
|
Vector( 1, -1, 0 ),
|
|
Vector( 1, 1, 0 ),
|
|
Vector( -1, 1, 0 )
|
|
};
|
|
|
|
int DrawWorldSpaceLightFullScreenQuad(
|
|
int nWidth, int nHeight,
|
|
CMeshBuilder &meshBuilder,
|
|
CMatRenderContextPtr &pRenderContext,
|
|
LightDesc_t const &light,
|
|
int nIndex )
|
|
{
|
|
Vector color_intens = light.m_Color;
|
|
Vector spot_dir = light.m_Direction;
|
|
for ( int corner = 0; corner < 4; corner++ )
|
|
{
|
|
Vector vecPnt = s_pCornerPoints[corner];
|
|
meshBuilder.Position3fv( vecPnt.Base() );
|
|
float pdot = light.m_PhiDot;
|
|
float tdot = light.m_ThetaDot;
|
|
if ( light.m_Type == MATERIAL_LIGHT_POINT )
|
|
{
|
|
// model point light as a spot with infinite inner radius
|
|
pdot = 1.0e10;
|
|
tdot = 0.5;
|
|
}
|
|
meshBuilder.TexCoord4f( 1, color_intens.x, color_intens.y, color_intens.z, tdot );
|
|
meshBuilder.TexCoord4f( 2, spot_dir.x, spot_dir.y, spot_dir.z, pdot );
|
|
meshBuilder.TexCoord3fv( 3, light.m_Position.Base() );
|
|
meshBuilder.TexCoord4f( 4, light.m_Attenuation2, light.m_Attenuation1, light.m_Attenuation0, 1.0 );
|
|
meshBuilder.AdvanceVertex();
|
|
}
|
|
// now, output indices
|
|
meshBuilder.FastIndex( 2 + nIndex );
|
|
meshBuilder.FastIndex( 1 + nIndex );
|
|
meshBuilder.FastIndex( 0 + nIndex );
|
|
|
|
meshBuilder.FastIndex( 0 + nIndex );
|
|
meshBuilder.FastIndex( 3 + nIndex );
|
|
meshBuilder.FastIndex( 2 + nIndex );
|
|
return 4;
|
|
}
|
|
|
|
void CRender3D::AccumulateLights( CUtlPriorityQueue<CLightPreview_Light> &light_queue,
|
|
CMatRenderContextPtr &pRenderContext,
|
|
int nTargetWidth, int nTargetHeight,
|
|
ITexture *dest_rt )
|
|
{
|
|
|
|
IMaterial *add_0_to_1=materials->FindMaterial( "editor/addlight0",
|
|
TEXTURE_GROUP_OTHER,true);
|
|
|
|
ITexture *dest_rt_current=materials->FindTexture( "_rt_accbuf", TEXTURE_GROUP_RENDER_TARGET );
|
|
|
|
pRenderContext->SetRenderTarget( dest_rt_current );
|
|
|
|
pRenderContext->ClearColor3ub( 0, 0, 0);
|
|
pRenderContext->ClearBuffers( true, true );
|
|
// pRenderContext->Viewport(0, 0, nTargetWidth, nTargetHeight );
|
|
|
|
|
|
pRenderContext->Bind( add_0_to_1 );
|
|
|
|
int nlights = min( MAX_PREVIEW_LIGHTS, light_queue.Count() );
|
|
|
|
// now, lets build up a vertex buffer of lights
|
|
CMeshBuilder meshBuilder;
|
|
IMesh* pMesh = pRenderContext->GetDynamicMesh( true );
|
|
meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, 8 * nlights, 6 * 3 * 2 * nlights );
|
|
|
|
int nIndex = 0;
|
|
for(int i=0; i < nlights ; i++)
|
|
{
|
|
LightDesc_t light = light_queue.ElementAtHead().m_Light;
|
|
light.RecalculateDerivedValues();
|
|
light_queue.RemoveAtHead();
|
|
|
|
nIndex += DrawWorldSpaceLightFullScreenQuad( nTargetWidth, nTargetHeight,
|
|
meshBuilder, pRenderContext, light, nIndex );
|
|
// if ( light.m_Type == MATERIAL_LIGHT_SPOT )
|
|
// nIndex += DrawWorldSpaceLightPyramid( meshBuilder, pRenderContext, light, nIndex );
|
|
// else
|
|
// nIndex += DrawWorldSpaceLightCube( meshBuilder, pRenderContext, light, nIndex );
|
|
// DrawScreenSpaceLightRectangle(
|
|
// meshBuilder,
|
|
// 0, 0, nTargetWidth, nTargetHeight,
|
|
// 0,0,
|
|
// nTargetWidth - 1, nTargetHeight -1,
|
|
// dest_rt->GetActualWidth(),
|
|
// dest_rt->GetActualHeight(),
|
|
// light,
|
|
// pRenderContext
|
|
// );
|
|
}
|
|
meshBuilder.End();
|
|
pMesh->Draw();
|
|
|
|
pRenderContext->SetRenderTarget( NULL );
|
|
|
|
}
|
|
|
|
void CRender3D::SendGBuffersToLightingThread( int nTargetWidth, int nTargetHeight )
|
|
{
|
|
static bool did_dump=false;
|
|
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
|
|
static char const *rts_to_transmit[]={"_rt_albedo","_rt_normal","_rt_position",
|
|
"_rt_flags" };
|
|
MessageToLPreview Msg(LPREVIEW_MSG_G_BUFFERS);
|
|
for(int i=0; i < NELEMS( rts_to_transmit ); i++)
|
|
{
|
|
SetRenderTargetNamed(0,rts_to_transmit[i]);
|
|
FloatBitMap_t *fbm = new FloatBitMap_t( nTargetWidth, nTargetHeight );
|
|
Msg.m_pDefferedRenderingBMs[i]=fbm;
|
|
|
|
if ( i != 3 )
|
|
{
|
|
// we have to reformat the data for the planar mode used by floatbm now
|
|
float *pTmpData = new float[ nTargetWidth * nTargetHeight * 4 ];
|
|
pRenderContext->ReadPixels( 0, 0, nTargetWidth, nTargetHeight, (uint8 *) pTmpData,
|
|
IMAGE_FORMAT_RGBA32323232F );
|
|
|
|
// reformat data
|
|
for( int nY = 0 ; nY < nTargetHeight; nY++ )
|
|
for( int nX = 0; nX < nTargetWidth; nX++ )
|
|
for( int nComp = 0 ; nComp < 4; nComp++ )
|
|
fbm->Pixel( nX, nY, 0, nComp ) = pTmpData[ nComp + 4 * ( nX + nTargetWidth * nY ) ];
|
|
delete[] pTmpData;
|
|
}
|
|
if ( ( i == 0 ) && ( ! did_dump ) )
|
|
{
|
|
fbm->RaiseToPower( 1.0/ 2.2 );
|
|
fbm->WriteTGAFile("albedo.tga");
|
|
fbm->RaiseToPower( 2.2 );
|
|
}
|
|
if ( ( i == 1 ) && ( ! did_dump ) )
|
|
{
|
|
fbm->WriteTGAFile("normal.tga");
|
|
}
|
|
}
|
|
did_dump = true;
|
|
n_gbufs_queued++;
|
|
GetCamera()->GetViewPoint( Msg.m_EyePosition );
|
|
Msg.m_nBitmapGenerationCounter = g_nBitmapGenerationCounter;
|
|
g_HammerToLPreviewMsgQueue.QueueMessage( Msg );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::EndRenderFrame(void)
|
|
{
|
|
CRender::EndRenderFrame();
|
|
|
|
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
|
|
if (m_Pick.bPicking)
|
|
{
|
|
pRenderContext->Flush();
|
|
|
|
//
|
|
// Some OpenGL drivers, such as the ATI Rage Fury Max, return selection buffer Z values
|
|
// in reverse order. For these cards, we must reverse the selection order.
|
|
//
|
|
if (m_Pick.nNumHits > 1)
|
|
{
|
|
if (!m_RenderState.bReverseSelection)
|
|
{
|
|
qsort(m_Pick.Hits, m_Pick.nNumHits, sizeof(m_Pick.Hits[0]), _CompareHits);
|
|
}
|
|
else
|
|
{
|
|
qsort(m_Pick.Hits, m_Pick.nNumHits, sizeof(m_Pick.Hits[0]), _CompareHitsReverse);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Copy the requested number of nearest hits into the destination buffer.
|
|
//
|
|
int nHitsToCopy = min(m_Pick.nNumHits, m_Pick.nMaxHits);
|
|
if (nHitsToCopy != 0)
|
|
{
|
|
memcpy(m_Pick.pHitsDest, m_Pick.Hits, sizeof(m_Pick.Hits[0]) * nHitsToCopy);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Copy the GL buffer contents to our window's device context unless we're in pick mode.
|
|
//
|
|
if (!m_Pick.bPicking)
|
|
{
|
|
if (
|
|
(m_eCurrentRenderMode == RENDER_MODE_LIGHT_PREVIEW2) ||
|
|
(m_eCurrentRenderMode == RENDER_MODE_LIGHT_PREVIEW_RAYTRACED)
|
|
)
|
|
{
|
|
pRenderContext->Flush();
|
|
pRenderContext->SetRenderTarget( NULL );
|
|
pRenderContext->SetRenderTargetEx( 1,NULL );
|
|
pRenderContext->SetRenderTargetEx( 2,NULL );
|
|
pRenderContext->SetRenderTargetEx( 3,NULL );
|
|
|
|
|
|
ITexture *pRT = SetRenderTargetNamed(0,"_rt_accbuf");
|
|
pRenderContext->ClearColor3ub(0,0,0);
|
|
pRenderContext->ClearBuffers( true, true );
|
|
|
|
CCamera *pCamera = GetCamera();
|
|
int width, height;
|
|
pCamera->GetViewPort( width, height );
|
|
|
|
int nTargetWidth = min( width, pRT->GetActualWidth() );
|
|
int nTargetHeight = min( height, pRT->GetActualHeight() );
|
|
|
|
bool view_changed = false;
|
|
|
|
Vector new_vp;
|
|
pCamera->GetViewPoint( new_vp );
|
|
|
|
if ( (pCamera->GetYaw() != m_fLastLPreviewAngles[0] ) ||
|
|
(pCamera->GetPitch() != m_fLastLPreviewAngles[1] ) ||
|
|
(pCamera->GetRoll() != m_fLastLPreviewAngles[2] ) ||
|
|
(m_nLastLPreviewHeight != height ) ||
|
|
(m_nLastLPreviewWidth != width ) ||
|
|
( new_vp != m_LastLPreviewCameraPos ) ||
|
|
(pCamera->GetZoom() != m_fLastLPreviewZoom ) )
|
|
view_changed = true;
|
|
if (m_pView->m_bUpdateView && (m_eCurrentRenderMode == RENDER_MODE_LIGHT_PREVIEW_RAYTRACED))
|
|
{
|
|
|
|
static float Last_SendTime=0;
|
|
// now, lets create floatbms with the deferred rendering data, so we can pass it to the lpreview thread
|
|
float newtime=Plat_FloatTime();
|
|
if (( n_gbufs_queued < 1 ) && ( newtime-Last_SendTime > 1.0) )
|
|
{
|
|
SendShadowTriangles();
|
|
SendLightList(); // send light list to render thread
|
|
if ( view_changed )
|
|
{
|
|
m_fLastLPreviewAngles[0] = pCamera->GetYaw();
|
|
m_fLastLPreviewAngles[1] = pCamera->GetPitch();
|
|
m_fLastLPreviewAngles[2] = pCamera->GetRoll();
|
|
m_LastLPreviewCameraPos = new_vp;
|
|
m_fLastLPreviewZoom = pCamera->GetZoom();
|
|
m_nLastLPreviewHeight = height;
|
|
m_nLastLPreviewWidth = width;
|
|
|
|
|
|
g_nBitmapGenerationCounter++;
|
|
Last_SendTime=newtime;
|
|
if (g_pLPreviewOutputBitmap)
|
|
delete g_pLPreviewOutputBitmap;
|
|
g_pLPreviewOutputBitmap = NULL;
|
|
SendGBuffersToLightingThread( nTargetWidth, nTargetHeight );
|
|
|
|
pRenderContext->SetRenderTarget( NULL );
|
|
}
|
|
}
|
|
}
|
|
|
|
// only update non-ray traced lpreview if we have no ray traced one or if the scene has changed
|
|
if (m_pView->m_bUpdateView || (m_eCurrentRenderMode != RENDER_MODE_LIGHT_PREVIEW_RAYTRACED) ||
|
|
(! g_pLPreviewOutputBitmap) )
|
|
{
|
|
SetRenderTargetNamed(0,"_rt_accbuf");
|
|
pRenderContext->ClearColor3ub( 0, 0, 0 );
|
|
MaterialSystemInterface()->ClearBuffers( true, true );
|
|
|
|
|
|
pRenderContext->Viewport(0, 0, nTargetWidth, nTargetHeight );
|
|
pRenderContext->ClearColor3ub(0,0,0);
|
|
pRenderContext->ClearBuffers( true, true );
|
|
// now, copy albedo to screen
|
|
ITexture *dest_rt=materials->FindTexture("_rt_albedo", TEXTURE_GROUP_RENDER_TARGET );
|
|
int xl,yl,dest_width,dest_height;
|
|
pRenderContext->GetViewport( xl,yl,dest_width,dest_height);
|
|
|
|
CMapDoc *pDoc = m_pView->GetMapDoc();
|
|
CMapWorld *pWorld = pDoc->GetMapWorld();
|
|
|
|
if ( !pWorld )
|
|
return;
|
|
|
|
// now, get list of lights
|
|
CUtlIntrusiveList<CLightingPreviewLightDescription> lightList = BuildLightList();
|
|
|
|
CUtlPriorityQueue<CLightPreview_Light> light_queue( 0, 0, CompareLightPreview_Lights);
|
|
|
|
Vector eye_pnt;
|
|
pCamera->GetViewPoint(eye_pnt);
|
|
// now, add lights in priority order
|
|
for( CLightingPreviewLightDescription *pLight = lightList.Head(); pLight; pLight = pLight->m_pNext )
|
|
{
|
|
if (
|
|
( pLight->m_Type == MATERIAL_LIGHT_SPOT ) ||
|
|
( pLight->m_Type == MATERIAL_LIGHT_POINT ) )
|
|
{
|
|
Vector lpnt;
|
|
CLightPreview_Light tmplight;
|
|
tmplight.m_Light = *pLight;
|
|
tmplight.m_flDistanceToEye = pLight->m_Position.DistTo( eye_pnt );
|
|
light_queue.Insert(tmplight);
|
|
}
|
|
}
|
|
if ( light_queue.Count() == 0 )
|
|
{
|
|
// no lights for gpu preview? lets add a fake one
|
|
CLightPreview_Light tmplight;
|
|
tmplight.m_Light.m_Type = MATERIAL_LIGHT_POINT;
|
|
tmplight.m_Light.m_Color = Vector( 10, 10, 10 );
|
|
tmplight.m_Light.m_Position = Vector( 0, 0, 30000 );
|
|
tmplight.m_Light.m_Range = 1.0e20;
|
|
tmplight.m_Light.m_Attenuation0 = 1.0;
|
|
tmplight.m_Light.m_Attenuation1 = 0.0;
|
|
tmplight.m_Light.m_Attenuation2 = 0.0;
|
|
tmplight.m_flDistanceToEye = 1;
|
|
light_queue.Insert(tmplight);
|
|
}
|
|
// because of no blend support on ati, we have to ping pong. This needs an nvidia-specifc
|
|
// path for perf
|
|
AccumulateLights( light_queue, pRenderContext, nTargetWidth, nTargetHeight, dest_rt );
|
|
IMaterial *sample_last=materials->FindMaterial("editor/sample_result_1",
|
|
TEXTURE_GROUP_OTHER,true);
|
|
pRenderContext->DrawScreenSpaceRectangle(
|
|
sample_last, xl, yl, dest_width, dest_height,
|
|
0,0,
|
|
nTargetWidth, nTargetHeight,
|
|
dest_rt->GetActualWidth(),
|
|
dest_rt->GetActualHeight());
|
|
}
|
|
}
|
|
if ( !m_bRenderingOverEngine )
|
|
{
|
|
MaterialSystemInterface()->SwapBuffers();
|
|
}
|
|
|
|
if ( (m_eCurrentRenderMode == RENDER_MODE_LIGHT_PREVIEW_RAYTRACED) &&
|
|
g_pLPreviewOutputBitmap )
|
|
{
|
|
// blit it
|
|
BITMAPINFOHEADER mybmh;
|
|
mybmh.biHeight=-g_pLPreviewOutputBitmap->Height();
|
|
mybmh.biSize=sizeof(BITMAPINFOHEADER);
|
|
// now, set up bitmapheader struct for StretchDIB
|
|
mybmh.biWidth=g_pLPreviewOutputBitmap->Width();
|
|
mybmh.biPlanes=1;
|
|
mybmh.biBitCount=32;
|
|
mybmh.biCompression=BI_RGB;
|
|
mybmh.biSizeImage=g_pLPreviewOutputBitmap->Width()*g_pLPreviewOutputBitmap->Height();
|
|
|
|
RECT wrect;
|
|
memset(&wrect,0,sizeof(wrect));
|
|
|
|
CCamera *pCamera = GetCamera();
|
|
int width, height;
|
|
pCamera->GetViewPort( width, height );
|
|
// StretchDIBits(
|
|
// m_WinData.hDC,0,0,width,height,
|
|
// 0,0,g_pLPreviewOutputBitmap->Width(), g_pLPreviewOutputBitmap->Height(),
|
|
// g_pLPreviewOutputBitmap->m_pBits, (BITMAPINFO *) &mybmh,
|
|
// DIB_RGB_COLORS, SRCCOPY);
|
|
|
|
// remember that we blitted it
|
|
m_pView->m_nLastRaytracedBitmapRenderTimeStamp =
|
|
GetUpdateCounter( EVTYPE_BITMAP_RECEIVED_FROM_LPREVIEW );
|
|
}
|
|
|
|
if (g_bShowStatistics)
|
|
{
|
|
//
|
|
// Calculate frame rate.
|
|
//
|
|
if (m_dwTimeLastSample != 0)
|
|
{
|
|
DWORD dwTimeNow = timeGetTime();
|
|
DWORD dwTimeElapsed = dwTimeNow - m_dwTimeLastSample;
|
|
if ((dwTimeElapsed > 1000) && (m_nFramesThisSample > 0))
|
|
{
|
|
float fTimeElapsed = (float)dwTimeElapsed / 1000.0;
|
|
m_fFrameRate = m_nFramesThisSample / fTimeElapsed;
|
|
m_nFramesThisSample = 0;
|
|
m_dwTimeLastSample = dwTimeNow;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_dwTimeLastSample = timeGetTime();
|
|
}
|
|
|
|
m_nFramesThisSample++;
|
|
|
|
//
|
|
// Display the frame rate and camera position.
|
|
//
|
|
char szText[100];
|
|
Vector ViewPoint;
|
|
GetCamera()->GetViewPoint(ViewPoint);
|
|
int nLen = sprintf(szText, "FPS=%3.2f Pos=[%.f %.f %.f]", m_fFrameRate, ViewPoint[0], ViewPoint[1], ViewPoint[2]);
|
|
TextOut(m_WinData.hDC, 2, 18, szText, nLen);
|
|
}
|
|
}
|
|
|
|
if ( enginetools )
|
|
MaterialSystemInterface()->SetView( enginetools->GetEngineHwnd() );
|
|
}
|
|
|
|
|
|
void CRender3D::PushInstanceData( CMapInstance *pInstanceClass, Vector &InstanceOrigin, QAngle &InstanceAngles )
|
|
{
|
|
__super::PushInstanceData( pInstanceClass, InstanceOrigin, InstanceAngles );
|
|
|
|
if ( m_bInstanceRendering )
|
|
{
|
|
CMapFace::PushFaceQueue();
|
|
}
|
|
}
|
|
|
|
void CRender3D::PopInstanceData( void )
|
|
{
|
|
if ( m_bInstanceRendering )
|
|
{
|
|
CMapFace::PopFaceQueue();
|
|
}
|
|
|
|
__super::PopInstanceData();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Renders the world axes
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::RenderWorldAxes()
|
|
{
|
|
// Render the world axes.
|
|
PushRenderMode( RENDER_MODE_WIREFRAME );
|
|
|
|
CMeshBuilder meshBuilder;
|
|
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
|
|
IMesh* pMesh = pRenderContext->GetDynamicMesh( );
|
|
meshBuilder.Begin( pMesh, MATERIAL_LINES, 3 );
|
|
|
|
meshBuilder.Color3ub(255, 0, 0);
|
|
meshBuilder.Position3f(0, 0, 0);
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Color3ub(255, 0, 0);
|
|
meshBuilder.Position3f(100, 0, 0);
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Color3ub(0, 255, 0);
|
|
meshBuilder.Position3f(0, 0, 0);
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Color3ub(0, 255, 0);
|
|
meshBuilder.Position3f(0, 100, 0);
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Color3ub(0, 0, 255);
|
|
meshBuilder.Position3f(0, 0, 0);
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Color3ub(0, 0, 255);
|
|
meshBuilder.Position3f(0, 0, 100);
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.End();
|
|
pMesh->Draw();
|
|
|
|
PopRenderMode();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: this will handle all translucent rendering, including local transforms for instance items
|
|
// Input : none
|
|
// Output : none
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::RenderTranslucentObjects( void )
|
|
{
|
|
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
|
|
bool bAddedTransform = false;
|
|
CMapInstance *pInstanceClass = NULL;
|
|
TInstanceState SaveInstanceState = m_CurrentInstanceState;
|
|
|
|
m_bInstanceRendering = false;
|
|
|
|
// render translucent objects after all opaque objects
|
|
while ( m_TranslucentRenderObjects.Count() > 0 )
|
|
{
|
|
TranslucentObjects_t current = m_TranslucentRenderObjects.ElementAtHead();
|
|
m_TranslucentRenderObjects.RemoveAtHead();
|
|
|
|
if ( current.m_InstanceState.m_pInstanceClass )
|
|
{
|
|
if ( pInstanceClass != current.m_InstanceState.m_pInstanceClass || !m_bInstanceRendering || current.m_InstanceState.m_InstanceMatrix != m_CurrentInstanceState.m_InstanceMatrix )
|
|
{
|
|
if ( bAddedTransform )
|
|
{
|
|
EndLocalTransfrom();
|
|
}
|
|
bAddedTransform = true;
|
|
BeginLocalTransfrom( current.m_InstanceState.m_InstanceRenderMatrix, false );
|
|
m_CurrentInstanceState = current.m_InstanceState;
|
|
pInstanceClass = m_CurrentInstanceState.m_pInstanceClass;
|
|
m_bInstanceRendering = true;
|
|
|
|
if ( pInstanceClass->IsEditable() )
|
|
{
|
|
SetInstanceRendering( INSTANCE_STATE_OFF );
|
|
}
|
|
else
|
|
{
|
|
SetInstanceRendering( current.m_bInstanceSelected ? INSTANCE_STACE_SELECTED : INSTANCE_STATE_ON );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( m_bInstanceRendering )
|
|
{
|
|
if ( bAddedTransform )
|
|
{
|
|
EndLocalTransfrom();
|
|
bAddedTransform = false;
|
|
}
|
|
|
|
SetInstanceRendering( INSTANCE_STATE_OFF );
|
|
m_bInstanceRendering = false;
|
|
}
|
|
}
|
|
|
|
current.object->Render3D( this );
|
|
}
|
|
|
|
m_bInstanceRendering = false;
|
|
if ( bAddedTransform )
|
|
{
|
|
EndLocalTransfrom();
|
|
}
|
|
|
|
m_CurrentInstanceState = SaveInstanceState;
|
|
}
|
|
|
|
#define MAX_SLICE_COLORS 5
|
|
|
|
static unsigned char nVerticalColors[ MAX_SLICE_COLORS ][ 3 ] =
|
|
{
|
|
{ 127, 127, 127 },
|
|
{ 255, 255, 255 },
|
|
{ 255, 0, 0 },
|
|
{ 0, 255, 0 },
|
|
{ 255, 255, 0 }
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: horribly inefficient rendering mechanism for FoW. Demonstration purposes only!
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::RenderFoW( void )
|
|
{
|
|
CFoW *pFoW = m_pView->GetMapDoc()->GetFoW();
|
|
|
|
PushRenderMode( RENDER_MODE_FLAT_NOZ );
|
|
|
|
for( int i = 0; i < pFoW->GetNumTriSoups(); i++ )
|
|
{
|
|
CFoW_TriSoupCollection *pSoup = pFoW->GetTriSoup( i );
|
|
if ( pSoup == NULL )
|
|
{
|
|
continue;
|
|
}
|
|
for( int j = 0; j < pSoup->GetNumOccluders(); j++ )
|
|
{
|
|
CFoW_LineOccluder *pOccluder = pSoup->GetOccluder( j );
|
|
|
|
if ( pOccluder )
|
|
{
|
|
float flZPos;
|
|
Vector2D vStart, vEnd;
|
|
int nSliceNum = pOccluder->GetSliceNum();
|
|
|
|
flZPos = pFoW->GetSliceZPosition( nSliceNum ) + 16.0f;
|
|
|
|
if ( nSliceNum != 1 && 0 )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if ( nSliceNum < MAX_SLICE_COLORS )
|
|
{
|
|
SetDrawColor( nVerticalColors[ nSliceNum ][ 0 ], nVerticalColors[ nSliceNum ][ 1 ], nVerticalColors[ nSliceNum ][ 2 ] );
|
|
}
|
|
else
|
|
{
|
|
SetDrawColor( 255, 255, 255 );
|
|
}
|
|
|
|
vStart = pOccluder->GetStart();
|
|
vEnd = pOccluder->GetEnd();
|
|
|
|
Vector vRealStart( vStart.x, vStart.y, flZPos );
|
|
Vector vRealEnd( vEnd.x, vEnd.y, flZPos );
|
|
|
|
DrawLine( vRealStart, vRealEnd );
|
|
}
|
|
}
|
|
}
|
|
|
|
PopRenderMode();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::Render( bool bRenderingOverEngine )
|
|
{
|
|
CMapDoc *pDoc = m_pView->GetMapDoc();
|
|
CMapWorld *pMapWorld = pDoc->GetMapWorld();
|
|
CManifest *pManifest = pDoc->GetManifest();
|
|
|
|
bool view_changed = false;
|
|
|
|
CCamera *pCamera = GetCamera();
|
|
Vector new_vp;
|
|
pCamera->GetViewPoint( new_vp );
|
|
int width, height;
|
|
pCamera->GetViewPort( width, height );
|
|
|
|
if ( GetMainWnd()->m_pLightingPreviewOutputWindow)
|
|
{
|
|
SendLightList(); // nop if nothing changed
|
|
SendShadowTriangles(); // nop if nothing changed
|
|
}
|
|
if ( (pCamera->GetYaw() != m_fLastLPreviewAngles[0] ) ||
|
|
(pCamera->GetPitch() != m_fLastLPreviewAngles[1] ) ||
|
|
(pCamera->GetRoll() != m_fLastLPreviewAngles[2] ) ||
|
|
(m_nLastLPreviewHeight != height ) ||
|
|
(m_nLastLPreviewWidth != width ) ||
|
|
( new_vp != m_LastLPreviewCameraPos ) ||
|
|
(pCamera->GetZoom() != m_fLastLPreviewZoom ) )
|
|
view_changed = true;
|
|
|
|
if ( (m_eCurrentRenderMode == RENDER_MODE_LIGHT_PREVIEW_RAYTRACED) &&
|
|
g_pLPreviewOutputBitmap &&
|
|
(! view_changed ) )
|
|
{
|
|
// blit it
|
|
BITMAPINFOHEADER mybmh;
|
|
mybmh.biHeight=-g_pLPreviewOutputBitmap->Height();
|
|
mybmh.biSize=sizeof(BITMAPINFOHEADER);
|
|
// now, set up bitmapheader struct for StretchDIB
|
|
mybmh.biWidth=g_pLPreviewOutputBitmap->Width();
|
|
mybmh.biPlanes=1;
|
|
mybmh.biBitCount=32;
|
|
mybmh.biCompression=BI_RGB;
|
|
mybmh.biSizeImage=g_pLPreviewOutputBitmap->Width()*g_pLPreviewOutputBitmap->Height();
|
|
|
|
RECT wrect;
|
|
memset(&wrect,0,sizeof(wrect));
|
|
|
|
int width, height;
|
|
pCamera->GetViewPort( width, height );
|
|
// StretchDIBits(
|
|
// m_WinData.hDC,0,0,width,height,
|
|
// 0,0,g_pLPreviewOutputBitmap->Width(), g_pLPreviewOutputBitmap->Height(),
|
|
// g_pLPreviewOutputBitmap->m_pBits, (BITMAPINFO *) &mybmh,
|
|
// DIB_RGB_COLORS, SRCCOPY);
|
|
m_pView->m_nLastRaytracedBitmapRenderTimeStamp =
|
|
GetUpdateCounter( EVTYPE_BITMAP_RECEIVED_FROM_LPREVIEW );
|
|
// return;
|
|
}
|
|
|
|
StartRenderFrame( bRenderingOverEngine );
|
|
|
|
if (
|
|
( m_eCurrentRenderMode != RENDER_MODE_LIGHT_PREVIEW2 ) &&
|
|
( m_eCurrentRenderMode != RENDER_MODE_LIGHT_PREVIEW_RAYTRACED )
|
|
)
|
|
RenderWorldAxes();
|
|
|
|
//
|
|
// Deferred rendering lets us sort everything here by material.
|
|
//
|
|
if (!IsPicking())
|
|
{
|
|
m_DeferRendering = true;
|
|
}
|
|
|
|
m_TranslucentSortRendering = true;
|
|
|
|
// if (IsInLightingPreview())
|
|
// {
|
|
// // Lighting preview?
|
|
// IBSPLighting *pBSPLighting = pDoc->GetBSPLighting();
|
|
// if (pBSPLighting)
|
|
// {
|
|
// pBSPLighting->Draw();
|
|
// }
|
|
// }
|
|
|
|
//
|
|
// Render the world using octree culling.
|
|
//
|
|
|
|
PrepareInstanceStencil();
|
|
|
|
if ( pManifest )
|
|
{
|
|
pMapWorld = pManifest->GetManifestWorld();
|
|
}
|
|
|
|
if (g_bUseCullTree)
|
|
{
|
|
RenderTree( pMapWorld );
|
|
}
|
|
//
|
|
// Render the world without octree culling.
|
|
//
|
|
else
|
|
{
|
|
RenderMapClass( pMapWorld );
|
|
}
|
|
|
|
if ( m_DeferRendering )
|
|
{
|
|
m_DeferRendering = false;
|
|
|
|
// An optimization... render tree doesn't actually render anythung
|
|
// This here will do the rendering, sorted by material by pass
|
|
CMapFace::RenderOpaqueFaces(this);
|
|
}
|
|
|
|
RenderTranslucentObjects();
|
|
|
|
DrawInstanceStencil();
|
|
|
|
if ( pDoc->GetFoW() )
|
|
{
|
|
RenderFoW();
|
|
}
|
|
|
|
CGridNav *pGridNav = pDoc->GetGridNav();
|
|
if ( pGridNav && pGridNav->IsEnabled() && pGridNav->IsPreviewActive() )
|
|
{
|
|
Vector vViewForward;
|
|
pCamera->GetViewForward( vViewForward );
|
|
pGridNav->Render( this, new_vp, vViewForward );
|
|
}
|
|
|
|
m_TranslucentSortRendering = false;
|
|
pDoc->RenderDocument( this );
|
|
|
|
RenderTool();
|
|
|
|
RenderPointsAndPortals();
|
|
|
|
|
|
#ifdef _DEBUG
|
|
if (m_bRenderFrustum)
|
|
{
|
|
RenderFrustum();
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// Render any 2D elements that overlay the 3D view, like a center crosshair.
|
|
//
|
|
RenderOverlayElements();
|
|
|
|
EndRenderFrame();
|
|
|
|
// Purge any translucent detail objects that were added AFTER the translucent rendering loop
|
|
if ( m_TranslucentRenderObjects.Count() )
|
|
m_TranslucentRenderObjects.Purge();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: render an arrow of a given color at a given position (start and end)
|
|
// in world space
|
|
// Input : vStartPt - the arrow starting point
|
|
// vEndPt - the arrow ending point (the head of the arrow)
|
|
// chRed, chGree, chBlue - the arrow color
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::RenderArrow( Vector const &vStartPt, Vector const &vEndPt,
|
|
unsigned char chRed, unsigned char chGreen, unsigned char chBlue )
|
|
{
|
|
//
|
|
// render the stick portion of the arrow
|
|
//
|
|
|
|
// set to a flat shaded render mode
|
|
PushRenderMode( RENDER_MODE_FLAT );
|
|
SetDrawColor( chRed, chGreen, chBlue );
|
|
DrawLine( vStartPt, vEndPt );
|
|
PopRenderMode();
|
|
|
|
//
|
|
// render the tip of the arrow
|
|
//
|
|
Vector coneAxis = vEndPt - vStartPt;
|
|
float length = VectorNormalize( coneAxis );
|
|
float length8 = length * 0.125;
|
|
length -= length8;
|
|
|
|
Vector vBasePt;
|
|
vBasePt = vStartPt + coneAxis * length;
|
|
|
|
RenderCone( vBasePt, vEndPt, ( length8 * 0.333 ), 6, chRed, chGreen, chBlue );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Renders a box in flat shaded or wireframe depending on our render mode.
|
|
// Input : chRed -
|
|
// chGreen -
|
|
// chBlue -
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::RenderBox(const Vector &Mins, const Vector &Maxs,
|
|
unsigned char chRed, unsigned char chGreen, unsigned char chBlue, SelectionState_t eBoxSelectionState)
|
|
{
|
|
Vector FacePoints[8];
|
|
|
|
PointsFromBox( Mins, Maxs, FacePoints );
|
|
|
|
int nFaces[6][4] =
|
|
{
|
|
{ 0, 2, 3, 1 },
|
|
{ 0, 1, 5, 4 },
|
|
{ 4, 5, 7, 6 },
|
|
{ 2, 6, 7, 3 },
|
|
{ 1, 3, 7, 5 },
|
|
{ 0, 4, 6, 2 }
|
|
};
|
|
|
|
EditorRenderMode_t eRenderModeThisPass;
|
|
int nPasses;
|
|
|
|
if ((eBoxSelectionState != SELECT_NONE) && (GetDefaultRenderMode() != RENDER_MODE_WIREFRAME))
|
|
{
|
|
nPasses = 2;
|
|
}
|
|
else
|
|
{
|
|
nPasses = 1;
|
|
}
|
|
|
|
for (int nPass = 1; nPass <= nPasses; nPass++)
|
|
{
|
|
if (nPass == 1)
|
|
{
|
|
eRenderModeThisPass = GetDefaultRenderMode();
|
|
|
|
// There's no texture for a bounding box.
|
|
if ((eRenderModeThisPass == RENDER_MODE_TEXTURED) ||
|
|
(eRenderModeThisPass == RENDER_MODE_TEXTURED_SHADED) ||
|
|
(eRenderModeThisPass == RENDER_MODE_LIGHT_PREVIEW2) ||
|
|
(eRenderModeThisPass == RENDER_MODE_LIGHT_PREVIEW_RAYTRACED) ||
|
|
(eRenderModeThisPass == RENDER_MODE_LIGHTMAP_GRID))
|
|
{
|
|
eRenderModeThisPass = RENDER_MODE_FLAT;
|
|
}
|
|
|
|
PushRenderMode(eRenderModeThisPass);
|
|
}
|
|
else
|
|
{
|
|
eRenderModeThisPass = RENDER_MODE_WIREFRAME;
|
|
PushRenderMode(eRenderModeThisPass);
|
|
}
|
|
|
|
for (int nFace = 0; nFace < 6; nFace++)
|
|
{
|
|
Vector Edge1, Edge2, Normal;
|
|
int nP1, nP2, nP3, nP4;
|
|
|
|
nP1 = nFaces[nFace][0];
|
|
nP2 = nFaces[nFace][1];
|
|
nP3 = nFaces[nFace][2];
|
|
nP4 = nFaces[nFace][3];
|
|
|
|
VectorSubtract(FacePoints[nP4], FacePoints[nP1], Edge1);
|
|
VectorSubtract(FacePoints[nP2], FacePoints[nP1], Edge2);
|
|
CrossProduct(Edge1, Edge2, Normal);
|
|
VectorNormalize(Normal);
|
|
|
|
//
|
|
// If we are rendering using one of the lit modes, calculate lighting.
|
|
//
|
|
unsigned char color[3];
|
|
|
|
assert( (eRenderModeThisPass != RENDER_MODE_TEXTURED) &&
|
|
(eRenderModeThisPass != RENDER_MODE_TEXTURED_SHADED) &&
|
|
(eRenderModeThisPass != RENDER_MODE_LIGHT_PREVIEW2) &&
|
|
(eRenderModeThisPass != RENDER_MODE_LIGHT_PREVIEW_RAYTRACED) &&
|
|
(eRenderModeThisPass != RENDER_MODE_LIGHTMAP_GRID) );
|
|
if ((eRenderModeThisPass == RENDER_MODE_FLAT))
|
|
{
|
|
float fShade = LightPlane(Normal);
|
|
|
|
//
|
|
// For flat and textured mode use the face color with lighting.
|
|
//
|
|
if (eBoxSelectionState != SELECT_NONE)
|
|
{
|
|
color[0] = SELECT_FACE_RED * fShade;
|
|
color[1] = SELECT_FACE_GREEN * fShade;
|
|
color[2] = SELECT_FACE_BLUE * fShade;
|
|
}
|
|
else
|
|
{
|
|
color[0] = chRed * fShade;
|
|
color[1] = chGreen * fShade;
|
|
color[2] = chBlue * fShade;
|
|
}
|
|
}
|
|
//
|
|
// For wireframe mode use the face color without lighting.
|
|
//
|
|
else
|
|
{
|
|
if (eBoxSelectionState != SELECT_NONE)
|
|
{
|
|
color[0] = SELECT_FACE_RED;
|
|
color[1] = SELECT_FACE_GREEN;
|
|
color[2] = SELECT_FACE_BLUE;
|
|
}
|
|
else
|
|
{
|
|
color[0] = chRed;
|
|
color[1] = chGreen;
|
|
color[2] = chBlue;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Draw the face.
|
|
//
|
|
bool wireframe = (eRenderModeThisPass == RENDER_MODE_WIREFRAME);
|
|
|
|
CMeshBuilder meshBuilder;
|
|
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
|
|
IMesh* pMesh = pRenderContext->GetDynamicMesh();
|
|
meshBuilder.DrawQuad( pMesh, FacePoints[nP1].Base(), FacePoints[nP2].Base(),
|
|
FacePoints[nP3].Base(), FacePoints[nP4].Base(), color, wireframe );
|
|
}
|
|
|
|
PopRenderMode();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: render a cone of a given color at a given position in world space
|
|
// Intput : vBasePt - the start point of the cone (the base point)
|
|
// vTipPt - the end point of the cone (the peak)
|
|
// fRadius - the radius (at the base) of the cone
|
|
// nSlices - the number of slices (segments) making up the cone
|
|
// chRed, chGreen, chBlue - the cone color
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::RenderCone( Vector const &vBasePt, Vector const &vTipPt, float fRadius, int nSlices,
|
|
unsigned char chRed, unsigned char chGreen, unsigned char chBlue )
|
|
{
|
|
// get the angle between slices (in radians)
|
|
float sliceAngle = ( 2 * M_PI ) / ( float )nSlices;
|
|
|
|
//
|
|
// allocate ALIGNED!!!!!!! vectors for cone base
|
|
//
|
|
int size = nSlices * sizeof( Vector );
|
|
size += 16 + sizeof( Vector* );
|
|
byte *ptr = ( byte* )_alloca( size );
|
|
long data = ( long )ptr;
|
|
|
|
data += 16 + sizeof( Vector* ) - 1;
|
|
data &= -16;
|
|
|
|
(( void** )data)[-1] = ptr;
|
|
|
|
Vector *pPts = ( Vector* )data;
|
|
if( !pPts )
|
|
return;
|
|
|
|
//
|
|
// calculate the cone's base points in a local space (x,y plane)
|
|
//
|
|
for( int i = 0; i < nSlices; i++ )
|
|
{
|
|
pPts[i].x = fRadius * cos( ( sliceAngle * -i ) );
|
|
pPts[i].y = fRadius * sin( ( sliceAngle * -i ) );
|
|
pPts[i].z = 0.0f;
|
|
}
|
|
|
|
//
|
|
// get cone tip in local space
|
|
//
|
|
Vector coneAxis = vTipPt - vBasePt;
|
|
float length = coneAxis.Length();
|
|
Vector tipPt( 0.0f, 0.0f, length );
|
|
|
|
//
|
|
// create cone faces
|
|
//
|
|
CMapFaceList m_Faces;
|
|
Vector ptList[3];
|
|
|
|
// triangulate the base
|
|
for( int i = 0; i < ( nSlices - 2 ); i++ )
|
|
{
|
|
ptList[0] = pPts[0];
|
|
ptList[1] = pPts[i+1];
|
|
ptList[2] = pPts[i+2];
|
|
|
|
// add face to list
|
|
CMapFace *pFace = new CMapFace;
|
|
if( !pFace )
|
|
return;
|
|
pFace->SetRenderColor( chRed, chGreen, chBlue );
|
|
pFace->CreateFace( ptList, 3 );
|
|
pFace->RenderUnlit( true );
|
|
m_Faces.AddToTail( pFace );
|
|
}
|
|
|
|
// triangulate the sides
|
|
for( int i = 0; i < nSlices; i++ )
|
|
{
|
|
ptList[0] = pPts[i];
|
|
ptList[1] = tipPt;
|
|
ptList[2] = pPts[(i+1)%nSlices];
|
|
|
|
// add face to list
|
|
CMapFace *pFace = new CMapFace;
|
|
if( !pFace )
|
|
return;
|
|
pFace->SetRenderColor( chRed, chGreen, chBlue );
|
|
pFace->CreateFace( ptList, 3 );
|
|
pFace->RenderUnlit( true );
|
|
m_Faces.AddToTail( pFace );
|
|
}
|
|
|
|
//
|
|
// rotate base points into world space as they are being rendered
|
|
//
|
|
VectorNormalize( coneAxis );
|
|
QAngle rotAngles;
|
|
VectorAngles( coneAxis, rotAngles );
|
|
rotAngles[PITCH] += 90;
|
|
|
|
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
|
|
pRenderContext->MatrixMode( MATERIAL_MODEL );
|
|
pRenderContext->PushMatrix();
|
|
pRenderContext->LoadIdentity();
|
|
|
|
pRenderContext->Translate( vBasePt.x, vBasePt.y, vBasePt.z );
|
|
|
|
pRenderContext->Rotate( rotAngles[YAW], 0, 0, 1 );
|
|
pRenderContext->Rotate( rotAngles[PITCH], 0, 1, 0 );
|
|
pRenderContext->Rotate( rotAngles[ROLL], 1, 0, 0 );
|
|
|
|
// set to a flat shaded render mode
|
|
PushRenderMode( RENDER_MODE_FLAT );
|
|
|
|
for ( int i = 0; i < m_Faces.Count(); i++ )
|
|
{
|
|
CMapFace *pFace = m_Faces.Element( i );
|
|
if( !pFace )
|
|
continue;
|
|
pFace->Render3D( this );
|
|
}
|
|
|
|
pRenderContext->PopMatrix();
|
|
|
|
// set back to default render mode
|
|
PopRenderMode();
|
|
|
|
//
|
|
// delete the faces in the list
|
|
//
|
|
for ( int i = 0; i < m_Faces.Count(); i++ )
|
|
{
|
|
CMapFace *pFace = m_Faces.Element( i );
|
|
delete pFace;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : vCenter -
|
|
// flRadius -
|
|
// nTheta - Number of vertical slices in the sphere.
|
|
// nPhi - Number of horizontal slices in the sphere.
|
|
// chRed -
|
|
// chGreen -
|
|
// chBlue -
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::RenderSphere(Vector const &vCenter, float flRadius, int nTheta, int nPhi,
|
|
unsigned char chRed, unsigned char chGreen, unsigned char chBlue )
|
|
{
|
|
PushRenderMode( RENDER_MODE_EXTERN );
|
|
|
|
int nTriangles = 2 * nTheta * ( nPhi - 1 ); // Two extra degenerate triangles per row (except the last one)
|
|
int nIndices = 2 * ( nTheta + 1 ) * ( nPhi - 1 );
|
|
|
|
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
|
|
pRenderContext->Bind( m_pVertexColor[0] );
|
|
|
|
CMeshBuilder meshBuilder;
|
|
IMesh* pMesh = pRenderContext->GetDynamicMesh();
|
|
|
|
meshBuilder.Begin( pMesh, MATERIAL_TRIANGLE_STRIP, nTriangles, nIndices );
|
|
|
|
//
|
|
// Build the index buffer.
|
|
//
|
|
int i, j;
|
|
for ( i = 0; i < nPhi; ++i )
|
|
{
|
|
for ( j = 0; j < nTheta; ++j )
|
|
{
|
|
float u = j / ( float )( nTheta - 1 );
|
|
float v = i / ( float )( nPhi - 1 );
|
|
float theta = 2.0f * M_PI * u;
|
|
float phi = M_PI * v;
|
|
|
|
Vector vecPos;
|
|
vecPos.x = flRadius * sin(phi) * cos(theta);
|
|
vecPos.y = flRadius * sin(phi) * sin(theta);
|
|
vecPos.z = flRadius * cos(phi);
|
|
|
|
Vector vecNormal = vecPos;
|
|
VectorNormalize(vecNormal);
|
|
|
|
float flScale = LightPlane(vecNormal);
|
|
|
|
unsigned char red = chRed * flScale;
|
|
unsigned char green = chGreen * flScale;
|
|
unsigned char blue = chBlue * flScale;
|
|
|
|
vecPos += vCenter;
|
|
|
|
meshBuilder.Position3f( vecPos.x, vecPos.y, vecPos.z );
|
|
meshBuilder.Color3ub( red, green, blue );
|
|
meshBuilder.AdvanceVertex();
|
|
}
|
|
}
|
|
|
|
//
|
|
// Emit the triangle strips.
|
|
//
|
|
int idx = 0;
|
|
for ( i = 0; i < nPhi - 1; ++i )
|
|
{
|
|
for ( j = 0; j < nTheta; ++j )
|
|
{
|
|
idx = nTheta * i + j;
|
|
|
|
meshBuilder.Index( idx + nTheta );
|
|
meshBuilder.AdvanceIndex();
|
|
|
|
meshBuilder.Index( idx );
|
|
meshBuilder.AdvanceIndex();
|
|
}
|
|
|
|
//
|
|
// Emit a degenerate triangle to skip to the next row without
|
|
// a connecting triangle.
|
|
//
|
|
if ( i < nPhi - 2 )
|
|
{
|
|
meshBuilder.Index( idx );
|
|
meshBuilder.AdvanceIndex();
|
|
|
|
meshBuilder.Index( idx + nTheta + 1 );
|
|
meshBuilder.AdvanceIndex();
|
|
}
|
|
}
|
|
|
|
meshBuilder.End();
|
|
pMesh->Draw();
|
|
|
|
PopRenderMode();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::RenderWireframeSphere(Vector const &vCenter, float flRadius, int nTheta, int nPhi,
|
|
unsigned char chRed, unsigned char chGreen, unsigned char chBlue )
|
|
{
|
|
PushRenderMode(RENDER_MODE_WIREFRAME);
|
|
|
|
// Make one more coordinate because (u,v) is discontinuous.
|
|
++nTheta;
|
|
|
|
int nVertices = nPhi * nTheta;
|
|
int nIndices = ( nTheta - 1 ) * 4 * ( nPhi - 1 );
|
|
|
|
CMeshBuilder meshBuilder;
|
|
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
|
|
IMesh* pMesh = pRenderContext->GetDynamicMesh();
|
|
|
|
meshBuilder.Begin( pMesh, MATERIAL_LINES, nVertices, nIndices );
|
|
|
|
int i, j;
|
|
for ( i = 0; i < nPhi; ++i )
|
|
{
|
|
for ( j = 0; j < nTheta; ++j )
|
|
{
|
|
float u = j / ( float )( nTheta - 1 );
|
|
float v = i / ( float )( nPhi - 1 );
|
|
float theta = 2.0f * M_PI * u;
|
|
float phi = M_PI * v;
|
|
|
|
meshBuilder.Position3f( vCenter.x + ( flRadius * sin(phi) * cos(theta) ),
|
|
vCenter.y + ( flRadius * sin(phi) * sin(theta) ),
|
|
vCenter.z + ( flRadius * cos(phi) ) );
|
|
meshBuilder.Color3ub( chRed, chGreen, chBlue );
|
|
meshBuilder.AdvanceVertex();
|
|
}
|
|
}
|
|
|
|
for ( i = 0; i < nPhi - 1; ++i )
|
|
{
|
|
for ( j = 0; j < nTheta - 1; ++j )
|
|
{
|
|
int idx = nTheta * i + j;
|
|
|
|
meshBuilder.Index( idx );
|
|
meshBuilder.AdvanceIndex();
|
|
|
|
meshBuilder.Index( idx + nTheta );
|
|
meshBuilder.AdvanceIndex();
|
|
|
|
meshBuilder.Index( idx );
|
|
meshBuilder.AdvanceIndex();
|
|
|
|
meshBuilder.Index( idx + 1 );
|
|
meshBuilder.AdvanceIndex();
|
|
}
|
|
}
|
|
|
|
meshBuilder.End();
|
|
pMesh->Draw();
|
|
|
|
PopRenderMode();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pDrawDC -
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::RenderPointsAndPortals(void)
|
|
{
|
|
CMapDoc *pDoc = m_pView->GetMapDoc();
|
|
|
|
if ( pDoc->m_PFPoints.Count() )
|
|
{
|
|
PushRenderMode(RENDER_MODE_WIREFRAME);
|
|
|
|
int nPFPoints = pDoc->m_PFPoints.Count();
|
|
Vector* pPFPoints = pDoc->m_PFPoints.Base();
|
|
CMeshBuilder meshBuilder;
|
|
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
|
|
IMesh* pMesh = pRenderContext->GetDynamicMesh( );
|
|
meshBuilder.Begin( pMesh, MATERIAL_LINE_STRIP, nPFPoints - 1 );
|
|
|
|
for (int i = 0; i < nPFPoints; i++)
|
|
{
|
|
meshBuilder.Position3f(pPFPoints[i][0], pPFPoints[i][1], pPFPoints[i][2]);
|
|
meshBuilder.Color3ub(255, 0, 0);
|
|
meshBuilder.AdvanceVertex();
|
|
}
|
|
|
|
meshBuilder.End();
|
|
pMesh->Draw();
|
|
PopRenderMode();
|
|
}
|
|
|
|
// draw any portal file that was loaded
|
|
if ( pDoc->m_pPortalFile )
|
|
{
|
|
PushRenderMode(RENDER_MODE_FLAT_NOCULL);
|
|
|
|
// each vert makes and edge and thus a quad
|
|
int totalQuads = pDoc->m_pPortalFile->totalVerts;
|
|
int nMaxVerts;
|
|
int nMaxIndices;
|
|
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
|
|
pRenderContext->GetMaxToRender( pRenderContext->GetDynamicMesh( ), false, &nMaxVerts, &nMaxIndices );
|
|
|
|
int portalIndex = 0;
|
|
int baseVert = 0;
|
|
while ( totalQuads > 0 )
|
|
{
|
|
int quadLimit = totalQuads;
|
|
int quadOut = 0;
|
|
IMesh* pMesh = pRenderContext->GetDynamicMesh( );
|
|
if ( (quadLimit * 4) > nMaxVerts )
|
|
{
|
|
quadLimit = nMaxVerts / 4;
|
|
}
|
|
if ( (quadLimit * 6) > nMaxIndices )
|
|
{
|
|
quadLimit = nMaxIndices / 6;
|
|
}
|
|
CMeshBuilder meshBuilder;
|
|
meshBuilder.Begin( pMesh, MATERIAL_QUADS, quadLimit );
|
|
|
|
const float edgeWidth = 2.0f;
|
|
for (; portalIndex < pDoc->m_pPortalFile->vertCount.Count(); portalIndex++)
|
|
{
|
|
int vertCount = pDoc->m_pPortalFile->vertCount[portalIndex];
|
|
|
|
if ( (quadOut + vertCount) > quadLimit )
|
|
break;
|
|
quadOut += vertCount;
|
|
// compute a face normal
|
|
Vector e0 = pDoc->m_pPortalFile->verts[baseVert+1] - pDoc->m_pPortalFile->verts[baseVert];
|
|
Vector e1 = pDoc->m_pPortalFile->verts[baseVert+2] - pDoc->m_pPortalFile->verts[baseVert];
|
|
Vector normal = CrossProduct( e1, e0 );
|
|
VectorNormalize(normal);
|
|
for ( int j = 0; j < vertCount; j++ )
|
|
{
|
|
int v0 = baseVert + j;
|
|
int v1 = baseVert + ((j+1) % vertCount);
|
|
// compute the direction in the plane of the face to extrude the edge toward the
|
|
// face interior, use that to make a wide line with a quad
|
|
Vector e0 = pDoc->m_pPortalFile->verts[v1] - pDoc->m_pPortalFile->verts[v0];
|
|
Vector dir = CrossProduct( e0, normal );
|
|
VectorNormalize(dir);
|
|
dir *= edgeWidth;
|
|
meshBuilder.Position3fv( pDoc->m_pPortalFile->verts[v0].Base() );
|
|
meshBuilder.Color3ub(0, 0, 255);
|
|
meshBuilder.AdvanceVertex();
|
|
meshBuilder.Position3fv( pDoc->m_pPortalFile->verts[v1].Base() );
|
|
meshBuilder.Color3ub(0, 0, 255);
|
|
meshBuilder.AdvanceVertex();
|
|
meshBuilder.Position3fv( (pDoc->m_pPortalFile->verts[v1] + dir).Base() );
|
|
meshBuilder.Color3ub(0, 0, 255);
|
|
meshBuilder.AdvanceVertex();
|
|
meshBuilder.Position3fv( (pDoc->m_pPortalFile->verts[v0] + dir).Base() );
|
|
meshBuilder.Color3ub(0, 0, 255);
|
|
meshBuilder.AdvanceVertex();
|
|
}
|
|
baseVert += vertCount;
|
|
}
|
|
|
|
meshBuilder.End();
|
|
pMesh->Draw();
|
|
totalQuads -= quadOut;
|
|
}
|
|
PopRenderMode();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Draws a wireframe box using the given color.
|
|
// Input : pfMins - Pointer to the box minima in all 3 dimensions.
|
|
// pfMins - Pointer to the box maxima in all 3 dimensions.
|
|
// chRed, chGreen, chBlue - Red, green, and blue color compnents for the box.
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::RenderWireframeBox(const Vector &Mins, const Vector &Maxs,
|
|
unsigned char chRed, unsigned char chGreen, unsigned char chBlue)
|
|
{
|
|
//
|
|
// Draw the box bottom, top, and one corner edge.
|
|
//
|
|
|
|
PushRenderMode( RENDER_MODE_WIREFRAME );
|
|
SetDrawColor( chRed, chGreen, chBlue );
|
|
DrawBox( Mins, Maxs );
|
|
PopRenderMode();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Renders this object (and all of its children) if it is visible and
|
|
// has not already been rendered this frame.
|
|
// Input : pMapClass - Pointer to the object to be rendered.
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::RenderMapClass(CMapClass *pMapClass)
|
|
{
|
|
Assert(pMapClass != NULL);
|
|
|
|
if ((pMapClass != NULL) && (pMapClass->GetRenderFrame() != m_nFrameCount))
|
|
{
|
|
if (pMapClass->IsVisible())
|
|
{
|
|
//
|
|
// Render this object's culling box if it is enabled.
|
|
//
|
|
if (g_bRenderCullBoxes)
|
|
{
|
|
Vector mins,maxs;
|
|
pMapClass->GetCullBox(mins, maxs);
|
|
|
|
RenderWireframeBox(mins, maxs, 255, 0, 0);
|
|
}
|
|
|
|
bool should_appear=true;
|
|
if (m_eCurrentRenderMode == RENDER_MODE_LIGHT_PREVIEW2)
|
|
{
|
|
should_appear &= pMapClass->ShouldAppearInLightingPreview();
|
|
}
|
|
|
|
if (m_eCurrentRenderMode == RENDER_MODE_LIGHT_PREVIEW_RAYTRACED)
|
|
{
|
|
should_appear &= pMapClass->ShouldAppearInLightingPreview();
|
|
// should_appear &= pMapClass->ShouldAppearInRaytracedLightingPreview();
|
|
}
|
|
|
|
if ( m_bRenderingOverEngine )
|
|
{
|
|
should_appear &= pMapClass->ShouldAppearOverEngine();
|
|
}
|
|
|
|
if ( should_appear == true && m_Pick.bPicking == true && ( m_Pick.m_nFlags & FLAG_OBJECTS_AT_ONLY_SOLIDS ) != 0 )
|
|
{
|
|
if ( pMapClass->IsSolid() == false )
|
|
{
|
|
should_appear = false;
|
|
}
|
|
}
|
|
|
|
if ( should_appear )
|
|
{
|
|
//
|
|
// If we should render this object after all the other objects,
|
|
// just add it to a list of objects to render last. Otherwise, render it now.
|
|
//
|
|
if (!pMapClass->ShouldRenderLast())
|
|
{
|
|
pMapClass->Render3D(this);
|
|
}
|
|
else
|
|
{
|
|
if (
|
|
(m_eCurrentRenderMode != RENDER_MODE_LIGHT_PREVIEW2) &&
|
|
(m_eCurrentRenderMode != RENDER_MODE_LIGHT_PREVIEW_RAYTRACED) )
|
|
{
|
|
AddTranslucentDeferredRendering( pMapClass );
|
|
}
|
|
}
|
|
}
|
|
//
|
|
// Render this object's children.
|
|
//
|
|
const CMapObjectList *pChildren = pMapClass->GetChildren();
|
|
|
|
FOR_EACH_OBJ( *pChildren, pos )
|
|
{
|
|
Vector vecMins,vecMaxs;
|
|
|
|
CMapClass *pChild = (CUtlReference< CMapClass >)pChildren->Element(pos);
|
|
|
|
pChild->GetCullBox(vecMins, vecMaxs);
|
|
|
|
if (IsBoxVisible(vecMins, vecMaxs) != VIS_NONE )
|
|
{
|
|
RenderMapClass(pChild);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Consider this object as handled for this frame.
|
|
//
|
|
pMapClass->SetRenderFrame(m_nFrameCount);
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: this function will render an instance map at the specific offset and rotation
|
|
// Input : pInstanceClass - the map class of the func_instance
|
|
// pMapClass - the map class of the world spawn of the instance
|
|
// InstanceOrigin - the translation offset
|
|
// InstanceAngles - the axis rotation
|
|
// Output : none
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::RenderInstanceMapClass( CMapInstance *pInstanceClass, CMapClass *pMapClass, Vector &InstanceOrigin, QAngle &InstanceAngles )
|
|
{
|
|
if ( !pInstanceClass->IsInstanceVisible() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
PushInstanceData( pInstanceClass, InstanceOrigin, InstanceAngles );
|
|
|
|
m_nInstanceCount++;
|
|
|
|
RenderInstanceMapClass_r( pMapClass );
|
|
|
|
if ( m_DeferRendering )
|
|
{
|
|
CMapFace::RenderOpaqueFaces(this);
|
|
}
|
|
|
|
if ( m_TranslucentSortRendering == false )
|
|
{ // translucent objects will do their own transforms
|
|
RenderTranslucentObjects();
|
|
}
|
|
|
|
PopInstanceData();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: this function will recursively render an instance and all of its children
|
|
// Input : pObject - the object to be rendered
|
|
// Output : none
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::RenderInstanceMapClass_r(CMapClass *pMapClass)
|
|
{
|
|
Assert(pMapClass != NULL);
|
|
|
|
if ( ( pMapClass != NULL ) && ( pMapClass->GetRenderFrame() != m_nInstanceCount ) )
|
|
{
|
|
if (pMapClass->IsVisible())
|
|
{
|
|
//
|
|
// Render this object's culling box if it is enabled.
|
|
//
|
|
if (g_bRenderCullBoxes)
|
|
{
|
|
Vector vecMins, vecMaxs, vecExpandedMins, vecExpandedMaxs;
|
|
pMapClass->GetCullBox( vecMins, vecMaxs );
|
|
|
|
RenderWireframeBox( vecMins, vecMaxs, 255, 0, 0 );
|
|
}
|
|
|
|
bool should_appear=true;
|
|
if (m_eCurrentRenderMode == RENDER_MODE_LIGHT_PREVIEW2)
|
|
should_appear &= pMapClass->ShouldAppearInLightingPreview();
|
|
|
|
if (m_eCurrentRenderMode == RENDER_MODE_LIGHT_PREVIEW_RAYTRACED)
|
|
should_appear &= pMapClass->ShouldAppearInLightingPreview();
|
|
// should_appear &= pMapClass->ShouldAppearInRaytracedLightingPreview();
|
|
|
|
if ( should_appear )
|
|
{
|
|
//
|
|
// If we should render this object after all the other objects,
|
|
// just add it to a list of objects to render last. Otherwise, render it now.
|
|
//
|
|
if (!pMapClass->ShouldRenderLast())
|
|
{
|
|
pMapClass->Render3D(this);
|
|
}
|
|
else
|
|
{
|
|
if (
|
|
(m_eCurrentRenderMode != RENDER_MODE_LIGHT_PREVIEW2) &&
|
|
(m_eCurrentRenderMode != RENDER_MODE_LIGHT_PREVIEW_RAYTRACED) )
|
|
{
|
|
AddTranslucentDeferredRendering( pMapClass );
|
|
}
|
|
}
|
|
}
|
|
//
|
|
// Render this object's children.
|
|
//
|
|
const CMapObjectList *pChildren = pMapClass->GetChildren();
|
|
|
|
FOR_EACH_OBJ( *pChildren, pos )
|
|
{
|
|
Vector vecMins, vecMaxs, vecExpandedMins, vecExpandedMaxs;
|
|
|
|
CMapClass *pChild = (CUtlReference< CMapClass >)pChildren->Element( pos );
|
|
|
|
pChild->GetCullBox( vecMins, vecMaxs );
|
|
TransformInstanceAABB( vecMins, vecMaxs, vecExpandedMins, vecExpandedMaxs );
|
|
|
|
if (IsBoxVisible( vecExpandedMins, vecExpandedMaxs ) != VIS_NONE )
|
|
{
|
|
RenderInstanceMapClass_r( pChild );
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Consider this object as handled for this instance frame.
|
|
//
|
|
pMapClass->SetRenderFrame( m_nInstanceCount );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Prepares all objects in this node for rendering.
|
|
// Input : pParent -
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::Preload(CMapClass *pParent)
|
|
{
|
|
Assert(pParent != NULL);
|
|
|
|
if (pParent != NULL)
|
|
{
|
|
//
|
|
// Preload this object's children.
|
|
//
|
|
const CMapObjectList *pChildren = pParent->GetChildren();
|
|
FOR_EACH_OBJ( *pChildren, pos )
|
|
{
|
|
((CUtlReference< CMapClass >)pChildren->Element(pos))->RenderPreload(this, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Renders all objects in this node if this node is visible.
|
|
// Input : pNode - The node to render.
|
|
// bForce - If true, don't check for visibility, just render the node
|
|
// and all of its children.
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::RenderNode(CCullTreeNode *pNode, bool bForce )
|
|
{
|
|
//
|
|
// Render all child nodes first.
|
|
//
|
|
CCullTreeNode *pChild;
|
|
int nChildren = pNode->GetChildCount();
|
|
if (nChildren != 0)
|
|
{
|
|
for (int nChild = 0; nChild < nChildren; nChild++)
|
|
{
|
|
pChild = pNode->GetCullTreeChild(nChild);
|
|
Assert(pChild != NULL);
|
|
|
|
if (pChild != NULL)
|
|
{
|
|
//
|
|
// Only bother checking nodes with children or objects.
|
|
//
|
|
if ((pChild->GetChildCount() != 0) || (pChild->GetObjectCount() != 0))
|
|
{
|
|
bool bForceThisChild = bForce;
|
|
Visibility_t eVis = VIS_NONE;
|
|
|
|
if (!bForceThisChild)
|
|
{
|
|
Vector vecMins;
|
|
Vector vecMaxs;
|
|
pChild->GetBounds(vecMins, vecMaxs);
|
|
eVis = IsBoxVisible(vecMins, vecMaxs);
|
|
if (eVis == VIS_TOTAL)
|
|
{
|
|
bForceThisChild = true;
|
|
}
|
|
}
|
|
|
|
if ((bForceThisChild) || (eVis != VIS_NONE))
|
|
{
|
|
RenderNode(pChild, bForceThisChild);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Now render the contents of this node.
|
|
//
|
|
CMapClass *pObject;
|
|
int nObjects = pNode->GetObjectCount();
|
|
for (int nObject = 0; nObject < nObjects; nObject++)
|
|
{
|
|
pObject = pNode->GetCullTreeObject(nObject);
|
|
Assert(pObject != NULL);
|
|
|
|
Vector vecMins;
|
|
Vector vecMaxs;
|
|
pObject->GetCullBox(vecMins, vecMaxs);
|
|
if (IsBoxVisible(vecMins, vecMaxs) != VIS_NONE)
|
|
{
|
|
RenderMapClass(pObject);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CRender3D::RenderCrossHair()
|
|
{
|
|
int width, height;
|
|
|
|
GetCamera()->GetViewPort( width, height );
|
|
|
|
int nCenterX = width / 2;
|
|
int nCenterY = height / 2;
|
|
|
|
Assert( IsInClientSpace() );
|
|
|
|
// Render the world axes
|
|
PushRenderMode( RENDER_MODE_FLAT_NOZ );
|
|
|
|
SetDrawColor(0,0,0);
|
|
|
|
DrawLine( Vector(nCenterX - CROSSHAIR_DIST_HORIZONTAL, nCenterY - 1, 0),
|
|
Vector(nCenterX + CROSSHAIR_DIST_HORIZONTAL + 1, nCenterY - 1, 0) );
|
|
|
|
DrawLine( Vector(nCenterX - CROSSHAIR_DIST_HORIZONTAL, nCenterY + 1, 0),
|
|
Vector(nCenterX + CROSSHAIR_DIST_HORIZONTAL + 1, nCenterY + 1, 0) );
|
|
|
|
DrawLine( Vector(nCenterX - 1, nCenterY - CROSSHAIR_DIST_VERTICAL, 0),
|
|
Vector(nCenterX - 1, nCenterY + CROSSHAIR_DIST_VERTICAL, 0) );
|
|
|
|
DrawLine( Vector(nCenterX + 1, nCenterY - CROSSHAIR_DIST_VERTICAL, 0),
|
|
Vector(nCenterX + 1, nCenterY + CROSSHAIR_DIST_VERTICAL, 0) );
|
|
|
|
SetDrawColor(255,255,255);
|
|
|
|
DrawLine( Vector(nCenterX - CROSSHAIR_DIST_HORIZONTAL, nCenterY, 0),
|
|
Vector(nCenterX + CROSSHAIR_DIST_HORIZONTAL + 1, nCenterY, 0) );
|
|
|
|
DrawLine( Vector(nCenterX, nCenterY - CROSSHAIR_DIST_VERTICAL, 0),
|
|
Vector(nCenterX, nCenterY + CROSSHAIR_DIST_VERTICAL, 0) );
|
|
|
|
PopRenderMode();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Renders 2D elements that overlay the 3D objects.
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::RenderOverlayElements(void)
|
|
{
|
|
bool bPopMode = BeginClientSpace();
|
|
|
|
if (m_RenderState.bCenterCrosshair && !m_bRenderingOverEngine)
|
|
RenderCrossHair();
|
|
|
|
if ( bPopMode )
|
|
EndClientSpace();
|
|
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Gives all the tools a chance to render themselves.
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::RenderTool(void)
|
|
{
|
|
CMapDoc *pDoc = m_pView->GetMapDoc();
|
|
|
|
CBaseTool *pTool = pDoc->GetTools()->GetActiveTool();
|
|
|
|
if ( pTool )
|
|
{
|
|
pTool->RenderTool3D(this);
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::RenderTree( CMapWorld *pWorld )
|
|
{
|
|
if (pWorld == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Recursively traverse the culling tree, rendering visible nodes.
|
|
//
|
|
CCullTreeNode *pTree = pWorld->CullTree_GetCullTree();
|
|
if (pTree != NULL)
|
|
{
|
|
Vector vecMins;
|
|
Vector vecMaxs;
|
|
pTree->GetBounds(vecMins, vecMaxs);
|
|
Visibility_t eVis = IsBoxVisible(vecMins, vecMaxs);
|
|
|
|
if (eVis != VIS_NONE)
|
|
{
|
|
RenderNode(pTree, eVis == VIS_TOTAL);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns whether we are in lighting preview mode or not.
|
|
//-----------------------------------------------------------------------------
|
|
bool CRender3D::IsInLightingPreview()
|
|
{
|
|
return false; //m_bLightingPreview;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Enables/disables lighting preview mode.
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::SetInLightingPreview( bool bLightingPreview )
|
|
{
|
|
m_bLightingPreview = false; //bLightingPreview;
|
|
}
|
|
|
|
|
|
void CRender3D::ResetFocus()
|
|
{
|
|
// A bizarre workaround; the drop-down menu somehow
|
|
// sets some wierd state that causes the whole screen to not be updated
|
|
InvalidateRect( m_WinData.hWnd, 0, false );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// indicates we need to render an overlay pass...
|
|
//-----------------------------------------------------------------------------
|
|
bool CRender3D::NeedsOverlay() const
|
|
{
|
|
return (m_eCurrentRenderMode == RENDER_MODE_LIGHTMAP_GRID) ||
|
|
(m_eCurrentRenderMode == RENDER_MODE_TEXTURED_SHADED) ||
|
|
(m_eCurrentRenderMode == RENDER_MODE_LIGHT_PREVIEW2) ||
|
|
(m_eCurrentRenderMode == RENDER_MODE_LIGHT_PREVIEW_RAYTRACED) ||
|
|
(m_eCurrentRenderMode == RENDER_MODE_TEXTURED);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::ShutDown(void)
|
|
{
|
|
MaterialSystemInterface()->RemoveView( m_WinData.hWnd );
|
|
|
|
if (m_WinData.hDC)
|
|
{
|
|
m_WinData.hDC = NULL;
|
|
}
|
|
|
|
if (m_WinData.bFullScreen)
|
|
{
|
|
ChangeDisplaySettings(NULL, 0);
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Uncaches all cached textures
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::UncacheAllTextures()
|
|
{
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Enables and disables various rendering parameters.
|
|
// Input : eRenderState - Parameter to enable or disable. See RenderState_t.
|
|
// bEnable - true to enable, false to disable the specified render state.
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::RenderEnable(RenderState_t eRenderState, bool bEnable)
|
|
{
|
|
switch (eRenderState)
|
|
{
|
|
case RENDER_POLYGON_OFFSET_FILL:
|
|
{
|
|
m_nDecalMode = bEnable?1:0;
|
|
SetRenderMode( RENDER_MODE_CURRENT, true );
|
|
}
|
|
break;
|
|
|
|
case RENDER_POLYGON_OFFSET_LINE:
|
|
{
|
|
assert(0);
|
|
/* FIXME:
|
|
Think we'll need to have two versions of the wireframe material
|
|
one which ztests with offset + culling, the other which doesn't
|
|
ztest, doesn't offect, and doesn't cull??!?
|
|
|
|
m_pWireframeIgnoreZ->SetIntValue( bEnable );
|
|
m_pWireframe->GetMaterial()->InitializeStateSnapshots();
|
|
/*
|
|
if (bEnable)
|
|
{
|
|
glEnable(GL_POLYGON_OFFSET_LINE);
|
|
glPolygonOffset(-1, -1);
|
|
}
|
|
else
|
|
{
|
|
glDisable(GL_POLYGON_OFFSET_LINE);
|
|
}
|
|
*/
|
|
break;
|
|
}
|
|
|
|
case RENDER_CENTER_CROSSHAIR:
|
|
{
|
|
m_RenderState.bCenterCrosshair = bEnable;
|
|
break;
|
|
}
|
|
|
|
case RENDER_GRID:
|
|
{
|
|
m_RenderState.bDrawGrid = bEnable;
|
|
break;
|
|
}
|
|
|
|
case RENDER_FILTER_TEXTURES:
|
|
{
|
|
m_RenderState.bFilterTextures = bEnable;
|
|
break;
|
|
}
|
|
|
|
case RENDER_REVERSE_SELECTION:
|
|
{
|
|
m_RenderState.bReverseSelection = bEnable;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Groovy little debug hook; can be whatever I want or need.
|
|
// Input : pData -
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::DebugHook1(void *pData)
|
|
{
|
|
g_bShowStatistics = !g_bShowStatistics;
|
|
|
|
#ifdef _DEBUG
|
|
m_bRecomputeFrustumRenderGeometry = true;
|
|
m_bRenderFrustum = true;
|
|
#endif
|
|
|
|
//if (!m_bDroppedCamera)
|
|
//{
|
|
// *m_pDropCamera = *m_pCamera;
|
|
// m_bDroppedCamera = true;
|
|
//}
|
|
//else
|
|
//{
|
|
// m_bDroppedCamera = false;
|
|
//}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Another groovy little debug hook; can be whatever I want or need.
|
|
// Input : pData -
|
|
//-----------------------------------------------------------------------------
|
|
void CRender3D::DebugHook2(void *pData)
|
|
{
|
|
g_bRenderCullBoxes = !g_bRenderCullBoxes;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
float CRender3D::ComputePixelWidthOfSphere( const Vector &vecOrigin, float flRadius )
|
|
{
|
|
return ComputePixelDiameterOfSphere( vecOrigin, flRadius ) * 2.0f;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// This returns the diameter of the sphere in pixels based on
|
|
// the current model, view, + projection matrices and viewport.
|
|
//-----------------------------------------------------------------------------
|
|
float CRender3D::ComputePixelDiameterOfSphere( const Vector &vecOrigin, float flRadius )
|
|
{
|
|
// Get the current camera.
|
|
CCamera *pCamera = GetCamera();
|
|
if ( !pCamera )
|
|
return 0.0f;
|
|
|
|
// Get the up vector.
|
|
Vector vecViewUp;
|
|
pCamera->GetViewUp( vecViewUp );
|
|
|
|
Vector4D testPoint1, testPoint2;
|
|
VectorMA( vecOrigin, flRadius, vecViewUp, testPoint1.AsVector3D() );
|
|
VectorMA( vecOrigin, -flRadius, vecViewUp, testPoint2.AsVector3D() );
|
|
testPoint1.w = testPoint2.w = 1.0f;
|
|
|
|
// Get the projection matrix.
|
|
VMatrix matProj;
|
|
pCamera->GetViewProjMatrix( matProj );
|
|
|
|
Vector4D clipPos1, clipPos2;
|
|
Vector4DMultiply( matProj, testPoint1, clipPos1 );
|
|
Vector4DMultiply( matProj, testPoint2, clipPos2 );
|
|
if (clipPos1.w >= 0.001f)
|
|
{
|
|
clipPos1.y /= clipPos1.w;
|
|
}
|
|
else
|
|
{
|
|
clipPos1.y *= 1000;
|
|
}
|
|
if (clipPos2.w >= 0.001f)
|
|
{
|
|
clipPos2.y /= clipPos2.w;
|
|
}
|
|
else
|
|
{
|
|
clipPos2.y *= 1000;
|
|
}
|
|
|
|
// Scale by viewport.
|
|
int nWidth, nHeight;
|
|
pCamera->GetViewPort( nWidth, nHeight );
|
|
|
|
// The divide-by-two here is because y goes from -1 to 1 in projection space
|
|
return nHeight * fabs( clipPos2.y - clipPos1.y ) / 2.0f;
|
|
}
|