Backups/csgo-2018-source
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
main
csgo-2018-source/hammer/Render.cpp

1621 lines
45 KiB
C++
Raw Permalink Normal View History

uid issue
2021-07-25 12:11:47 +08:00
//===== Copyright <20> 1996-2005, Valve Corporation, All rights reserved. ======//
//
// Purpose: Base rendering utilities for all views
//
// $NoKeywords: $
//===========================================================================//
#include "stdafx.h"
#include "MapDoc.h"
#include <VGuiMatSurface/IMatSystemSurface.h>
#include "mathlib/vmatrix.h"
#include "Render.h"
#include "Camera.h"
#include "Material.h"
#include "materialsystem/imesh.h"
#include "datacache\imdlcache.h"
#include "hammer.h"
#include "hammer_mathlib.h"
#include "vgui_controls/Controls.h"
#include "vgui/IScheme.h"
#include "texturesystem.h"
#include "IStudioRender.h"
#include "builddisp.h"
#include "mapview.h"
#include "material.h"
#include <renderparm.h>
#include "materialsystem/IMaterialSystemHardwareConfig.h"
#include "vphysics_interface.h"
#include "materialsystem/MaterialSystem_Config.h"
#include "VGuiWnd.h"
#include "Box3D.h"
#include "MapInstance.h"
#include "foundrytool.h"
#include "tier3/tier3.h"
static float s_fOneUnitLength = 1;
CRender::CRender(void)
{
m_pView = NULL;
// returns a handle to the default (first loaded) scheme
vgui::IScheme * pScheme = vgui::scheme()->GetIScheme( vgui::scheme()->GetDefaultScheme() );
if ( pScheme )
{
m_DefaultFont = pScheme->GetFont( "Default" );
}
else
{
m_DefaultFont = vgui::INVALID_FONT;
static bool s_bOnce = false;
if ( !s_bOnce )
{
s_bOnce = true;
MessageBox( NULL, "Failed to load the default scheme file. The map views may be missing some visual elements.", "Error", MB_OK | MB_ICONEXCLAMATION );
}
}
for (int i = 0; i < 2; ++i)
{
m_pFlat[i] = NULL;
m_pWireframe[i] = NULL;
m_pTranslucentFlat[i] = NULL;
m_pLightmapGrid[i] = NULL;
m_pSelectionOverlay[i] = NULL;
m_pDotted[i] = NULL;
m_pFlatNoZ[i] = NULL;
m_pFlatNoCull[i] = NULL;
}
m_pCurrentMaterial = NULL;
m_pBoundMaterial = NULL;
m_nDecalMode = 0;
m_bIsRendering = false;
m_bIsClientSpace = false;
m_bIsLocalTransform = false;
m_bIsRenderingIntoVGUI = false;
VMatrix IdentityMatrix;
IdentityMatrix.Identity();
m_LocalMatrix.AddToHead( IdentityMatrix );
m_OrthoMatrix.Identity();
m_eCurrentRenderMode = m_eDefaultRenderMode = RENDER_MODE_FLAT;
m_bInstanceRendering = false;
m_nInstanceCount = 0;
m_InstanceSelectionDepth = 0;
PushInstanceData( NULL, Vector( 0.0f, 0.0f, 0.0f ), QAngle( 0.0f, 0.0f, 0.0f ) ); // always add a default state
if ( !APP()->IsFoundryMode() )
{
UpdateStudioRenderConfig( false, false );
}
}
CRender::~CRender(void)
{
}
//-----------------------------------------------------------------------------
// Purpose: this function will push all of the instance data
// Input : pInstanceClass - the func_instance entity
// InstanceOrigin - the translation of the instance
// InstanceAngles - the rotation of the instance
// Output : none
//-----------------------------------------------------------------------------
void CRender::PushInstanceData( CMapInstance *pInstanceClass, Vector &InstanceOrigin, QAngle &InstanceAngles )
{
TInstanceState InstanceState;
matrix3x4_t Instance3x4Matrix;
InstanceState.m_InstanceOrigin = InstanceOrigin;
InstanceState.m_InstanceAngles = InstanceAngles;
InstanceState.m_pInstanceClass = pInstanceClass;
InstanceState.m_pTopInstanceClass = NULL;
matrix3x4_t TransMatrix;
matrix3x4_t RotMatrix;
matrix3x4_t TransRotMatrix;
AngleMatrix( InstanceState.m_InstanceAngles, RotMatrix );
SetIdentityMatrix( TransMatrix );
PositionMatrix( InstanceState.m_InstanceOrigin, TransMatrix );
MatrixMultiply( TransMatrix, RotMatrix, TransRotMatrix );
Vector vLocalOrigin = vec3_origin;
if ( pInstanceClass != NULL && pInstanceClass->GetInstancedMap() != NULL )
{
CMapEntityList entityList;
pInstanceClass->GetInstancedMap()->FindEntitiesByClassName( entityList, "func_instance_origin", false );
if ( entityList.Count() == 1 )
{
entityList.Element( 0 )->GetOrigin( vLocalOrigin );
}
}
matrix3x4_t LocalTransRotMatrix;
Vector vOut;
VectorRotate( -vLocalOrigin, RotMatrix, vOut );
SetIdentityMatrix( TransMatrix );
PositionMatrix( vOut, TransMatrix );
MatrixMultiply( TransMatrix, TransRotMatrix, Instance3x4Matrix );
InstanceState.m_InstanceMatrix.Init( Instance3x4Matrix );
Vector vecTransformedOrigin;
TransformInstanceVector( InstanceState.m_InstanceOrigin, vecTransformedOrigin );
m_CurrentInstanceState.m_InstanceOrigin = vecTransformedOrigin;
// RotateInstanceVector( ( Vector )InstanceState.m_InstanceAngles, m_CurrentInstanceState.m_InstanceAngles ); no one uses this right now make sure to store it in the same fashion as vecTransformedOrigin
if ( m_InstanceState.Count() > 0 )
{ // first push is just a default state
m_bInstanceRendering = true;
BeginLocalTransfrom( InstanceState.m_InstanceMatrix, true );
if ( m_CurrentInstanceState.m_pTopInstanceClass == NULL )
{
if ( pInstanceClass->IsEditable() == false )
{
InstanceState.m_pTopInstanceClass = pInstanceClass;
}
}
else
{
InstanceState.m_pTopInstanceClass = m_CurrentInstanceState.m_pTopInstanceClass;
}
if ( pInstanceClass->IsSelected() || m_InstanceSelectionDepth )
{
m_InstanceSelectionDepth++;
}
InstanceState.m_InstanceMatrix = m_CurrentInstanceState.m_InstanceMatrix * InstanceState.m_InstanceMatrix;
InstanceState.m_bIsEditable = pInstanceClass->IsEditable();
}
else
{
m_bInstanceRendering = false;
InstanceState.m_bIsEditable = true;
}
InstanceState.m_InstanceRenderMatrix = m_LocalMatrix.Head();
m_InstanceState.AddToHead( InstanceState );
m_CurrentInstanceState = InstanceState;
if ( !pInstanceClass )
{
}
else if ( m_InstanceSelectionDepth > 0 )
{
PushInstanceRendering( INSTANCE_STACE_SELECTED );
}
else if ( pInstanceClass->IsEditable() || CMapDoc::GetActiveMapDoc()->GetShowInstance() == INSTANCES_SHOW_NORMAL )
{
PushInstanceRendering( INSTANCE_STATE_OFF );
}
else
{
PushInstanceRendering( GetInstanceClass()->IsSelected() ? INSTANCE_STACE_SELECTED : INSTANCE_STATE_ON );
}
}
//-----------------------------------------------------------------------------
// Purpose: this function will pop off the top most instance data
//-----------------------------------------------------------------------------
void CRender::PopInstanceData( void )
{
if ( m_CurrentInstanceState.m_pInstanceClass )
{
PopInstanceRendering();
}
m_InstanceState.Remove( 0 );
m_CurrentInstanceState = m_InstanceState.Head();
if ( m_InstanceState.Count() > 1 )
{ // first push is just a default state
m_bInstanceRendering = true;
}
else
{
m_bInstanceRendering = false;
}
if ( m_InstanceSelectionDepth > 0 )
{
m_InstanceSelectionDepth--;
}
EndLocalTransfrom();
// m_CurrentInstanceState.m_InstanceRenderMatrix = m_LocalMatrix.Head();
}
//-----------------------------------------------------------------------------
// Purpose: this function initializes the stencil buffer for instance rendering
//-----------------------------------------------------------------------------
void CRender::PrepareInstanceStencil( void )
{
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
#if STENCIL_AS_CALLS
pRenderContext->SetStencilEnable( true );
pRenderContext->SetStencilCompareFunction( STENCILCOMPARISONFUNCTION_ALWAYS );
pRenderContext->SetStencilFailOperation( STENCILOPERATION_KEEP );
pRenderContext->SetStencilZFailOperation( STENCILOPERATION_KEEP );
pRenderContext->SetStencilWriteMask( 0xff );
pRenderContext->SetStencilTestMask( 0xff );
pRenderContext->SetStencilReferenceValue( 0x01 );
pRenderContext->SetStencilPassOperation( STENCILOPERATION_ZERO);
#else
m_ShaderStencilState.m_bEnable = true;
m_ShaderStencilState.m_CompareFunc = SHADER_STENCILFUNC_ALWAYS;
m_ShaderStencilState.m_FailOp = SHADER_STENCILOP_KEEP;
m_ShaderStencilState.m_ZFailOp = SHADER_STENCILOP_KEEP;
m_ShaderStencilState.m_nWriteMask = 0xff;
m_ShaderStencilState.m_nTestMask = 0xff;
m_ShaderStencilState.m_nReferenceValue = 0x01;
m_ShaderStencilState.m_PassOp = SHADER_STENCILOP_ZERO;
pRenderContext->SetStencilState( m_ShaderStencilState );
#endif // STENCIL_AS_CALLS
}
//-----------------------------------------------------------------------------
// Purpose: this function will draw the various alpha color 2d rectangles for the instance states
//-----------------------------------------------------------------------------
void CRender::DrawInstanceStencil( void )
{
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
CCamera *pCamera = GetCamera();
if ( m_nNumInstancesRendered > 0 )
{
#if STENCIL_AS_CALLS
pRenderContext->SetStencilPassOperation( STENCILOPERATION_KEEP );
pRenderContext->SetStencilCompareFunction( STENCILCOMPARISONFUNCTION_EQUAL );
#else
m_ShaderStencilState.m_PassOp = SHADER_STENCILOP_KEEP;
m_ShaderStencilState.m_CompareFunc = SHADER_STENCILFUNC_EQUAL;
#endif // STENCIL_AS_CALLS
Color InstanceColoring;
int width, height;
pCamera->GetViewPort( width, height );
PushRenderMode( RENDER_MODE_INSTANCE_OVERLAY );
BeginClientSpace();
InstanceColor( InstanceColoring, false );
#if STENCIL_AS_CALLS
pRenderContext->SetStencilReferenceValue( 0x01 );
#else
m_ShaderStencilState.m_nReferenceValue = 0x01;
pRenderContext->SetStencilState( m_ShaderStencilState );
#endif // STENCIL_AS_CALLS
DrawFilledRect( Vector2D( 0.0f, 0.0f ), Vector2D( width, height ), ( byte * )&InstanceColoring, false );
InstanceColor( InstanceColoring, true );
#if STENCIL_AS_CALLS
pRenderContext->SetStencilTestMask( 0xff );
pRenderContext->SetStencilReferenceValue( 0x02 );
#else
m_ShaderStencilState.m_nReferenceValue = 0x02;
pRenderContext->SetStencilState( m_ShaderStencilState );
#endif // STENCIL_AS_CALLS
DrawFilledRect( Vector2D( 0.0f, 0.0f ), Vector2D( width, height ), ( byte * )&InstanceColoring, false );
EndClientSpace();
PopRenderMode();
}
#if STENCIL_AS_CALLS
pRenderContext->SetStencilEnable( false );
#else
m_ShaderStencilState.m_bEnable = false;
pRenderContext->SetStencilState( m_ShaderStencilState );
#endif // STENCIL_AS_CALLS
}
//-----------------------------------------------------------------------------
// Purpose: this function will push all of the instance data
// Input : pInstanceClass - the func_instance entity
// InstanceOrigin - the translation of the instance
// InstanceAngles - the rotation of the instance
// Output : none
//-----------------------------------------------------------------------------
void CRender::PushInstanceRendering( InstanceRenderingState_t State )
{
SetInstanceRendering( State );
m_InstanceRenderingState.AddToHead( State );
if ( State != INSTANCE_STATE_OFF )
{
m_nNumInstancesRendered++;
}
}
//-----------------------------------------------------------------------------
// Purpose: this function will pop off the top most instance data
//-----------------------------------------------------------------------------
void CRender::PopInstanceRendering( void )
{
m_InstanceRenderingState.Remove( 0 );
if ( m_InstanceRenderingState.Count() > 0 )
{
SetInstanceRendering( m_InstanceRenderingState.Head() );
}
else
{
SetInstanceRendering( INSTANCE_STATE_OFF );
}
}
//-----------------------------------------------------------------------------
// Purpose: Sets the instance rendering state for stencil buffer operations.
// 0 in stencil buffer = normal drawing
// 1 in stencil buffer = instance shaded pass
// 2 in stencil buffer = instance selected shaded pass
// Input : State - the state at which the next drawing operations should impact
// the stencil buffer
//-----------------------------------------------------------------------------
void CRender::SetInstanceRendering( InstanceRenderingState_t State )
{
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
switch( State )
{
case INSTANCE_STATE_OFF:
#ifdef STENCIL_AS_CALLS
pRenderContext->SetStencilPassOperation( STENCILOPERATION_ZERO );
#else
m_ShaderStencilState.m_PassOp = SHADER_STENCILOP_ZERO;
#endif // STENCIL_AS_CALLS
break;
case INSTANCE_STATE_ON:
#if STENCIL_AS_CALLS
pRenderContext->SetStencilPassOperation( STENCILOPERATION_REPLACE );
pRenderContext->SetStencilReferenceValue( 0x01 );
#else
m_ShaderStencilState.m_PassOp = SHADER_STENCILOP_SET_TO_REFERENCE;
m_ShaderStencilState.m_nReferenceValue = 0x01;
#endif // STENCIL_AS_CALLS
break;
case INSTANCE_STACE_SELECTED:
#if STENCIL_AS_CALLS
pRenderContext->SetStencilPassOperation( STENCILOPERATION_REPLACE );
pRenderContext->SetStencilReferenceValue( 0x02 );
#else
m_ShaderStencilState.m_PassOp = SHADER_STENCILOP_SET_TO_REFERENCE;
m_ShaderStencilState.m_nReferenceValue = 0x02;
#endif // STENCIL_AS_CALLS
break;
}
#ifndef STENCIL_AS_CALLS
pRenderContext->SetStencilState( m_ShaderStencilState );
#endif // STENCIL_AS_CALLS
}
//-----------------------------------------------------------------------------
// Purpose: This function renders a text string at the given position, width,
// height, and format
// Input: text - the string to print
// pos - the screen space position of the text (the is the top-left of
// a screen space rect)
// width - the width to render the text into
// height - the height to render the text into
// nFlags - define the text format -- see SetTextFormat
//-----------------------------------------------------------------------------
void CRender::DrawText( const char *text, int x, int y, int nFlags )
{
wchar_t unicode[ 128 ];
mbstowcs( unicode, text, sizeof(unicode) );
int len = min( 127, Q_strlen( text ) );
Assert( m_DefaultFont != vgui::INVALID_FONT );
bool bJustifyText = ( nFlags & ( TEXT_JUSTIFY_LEFT | TEXT_JUSTIFY_TOP | TEXT_JUSTIFY_HORZ_CENTER | TEXT_JUSTIFY_VERT_CENTER ) ) ? true : false;
if ( bJustifyText && m_DefaultFont != vgui::INVALID_FONT )
{
int wide,tall;
g_pMatSystemSurface->GetTextSize( m_DefaultFont, unicode, wide, tall );
if ( nFlags & TEXT_JUSTIFY_LEFT )
x -= wide;
if ( nFlags & TEXT_JUSTIFY_TOP )
y -= tall;
if ( nFlags & TEXT_JUSTIFY_HORZ_CENTER )
x -= wide/2;
if ( nFlags & TEXT_JUSTIFY_VERT_CENTER )
y -= tall/2;
}
PushRenderMode( RENDER_MODE_EXTERN );
bool bPopMode = BeginClientSpace();
g_pMatSystemSurface->DrawSetTextPos( x, y );
g_pMatSystemSurface->DrawPrintText( unicode, len );
if ( bPopMode )
EndClientSpace();
PopRenderMode();
}
//-----------------------------------------------------------------------------
// Uses "world" coordinates
//-----------------------------------------------------------------------------
void CRender::DrawText( const char *text, const Vector2D &vPos, int nOffsetX, int nOffsetY, int nFlags )
{
Vector vecActualPos( vPos.x, vPos.y, 0.0f );
if ( IsInLocalTransformMode() )
{
VMatrix matrix;
GetLocalTranform( matrix );
Vector vWorld = vecActualPos;
Vector3DMultiplyPosition( matrix, vWorld, vecActualPos );
}
Vector2D pt;
m_pView->WorldToClient( pt, vecActualPos );
DrawText( text, (int)pt.x + nOffsetX, (int)pt.y + nOffsetY, nFlags );
}
//-----------------------------------------------------------------------------
// Purpose: set the text and background (behind text) colors
// Input: tR, tG, tB - text red, green, and blue values : [0...255]
// bkR, bkG, bkB - background red, green, blue values : [0...255]
//-----------------------------------------------------------------------------
void CRender::SetTextColor( unsigned char r, unsigned char g, unsigned char b, unsigned char a )
{
m_TextColor.SetColor( r,g,b,a );
if ( m_bIsRenderingIntoVGUI )
{
g_pMatSystemSurface->DrawSetTextColor( m_TextColor );
}
}
void CRender::SetHandleColor( unsigned char r, unsigned char g, unsigned char b )
{
m_HandleColor.SetColor( r, g, b, 255 );
}
void CRender::UpdateStudioRenderConfig( bool bFlat, bool bWireframe )
{
StudioRenderConfig_t config;
memset( &config, 0, sizeof( config ) );
config.fEyeShiftX = 0.0f;
config.fEyeShiftY = 0.0f;
config.fEyeShiftZ = 0.0f;
config.fEyeSize = 0;
config.drawEntities = 1;
config.skin = 0;
config.fullbright = MaterialSystemConfig().nFullbright;
config.bEyeMove = true;
config.bSoftwareSkin = bWireframe;
config.bNoHardware = false;
config.bNoSoftware = false;
config.bTeeth = false;
config.bEyes = true;
config.bFlex = true;
config.bSoftwareLighting = true;
config.bWireframe = bWireframe;
config.bDrawNormals = false;
config.bShowEnvCubemapOnly = false;
g_pStudioRender->UpdateConfig( config );
}
void CRender::StartRenderFrame( bool bRenderingOverEngine )
{
Assert( !m_bIsRendering );
m_bRenderingOverEngine = bRenderingOverEngine;
m_nNumInstancesRendered = 0;
m_bIsRenderingIntoVGUI = dynamic_cast<CVGuiWnd*>( GetView() ) ? true : false;
if ( m_bIsRenderingIntoVGUI )
{
g_pMatSystemSurface->DrawSetTextFont( m_DefaultFont );
g_pMatSystemSurface->DrawSetTextColor( m_TextColor );
g_pMatSystemSurface->DrawSetColor( m_DrawColor );
}
CCamera *pCamera = GetCamera();
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
// build ortho matrix for client space mode
if ( !bRenderingOverEngine )
{
int width, height;
VMatrix matrix;
pCamera->GetViewPort( width, height );
pRenderContext->MatrixMode(MATERIAL_PROJECTION);
pRenderContext->LoadIdentity();
pRenderContext->Scale( 1, -1, 1 );
pRenderContext->Ortho(0, 0, width, height, -99999, 99999 );
pRenderContext->GetMatrix( MATERIAL_PROJECTION, &m_OrthoMatrix );
// setup world camera
pCamera->GetProjMatrix(matrix);
pRenderContext->MatrixMode( MATERIAL_PROJECTION );
pRenderContext->LoadMatrix( matrix );
pCamera->GetViewMatrix(matrix);
pRenderContext->MatrixMode( MATERIAL_VIEW );
pRenderContext->LoadMatrix( matrix );
pRenderContext->MatrixMode(MATERIAL_MODEL);
pRenderContext->LoadIdentity();
// specular is turned off in the multiblend shader though for the editor
Vector vLightDir( 0.0f, 0.0f, -1.0f );
pRenderContext->SetVectorRenderingParameter( VECTOR_RENDERPARM_GLOBAL_LIGHT_DIRECTION, vLightDir );
pRenderContext->SetFloatRenderingParameter( FLOAT_RENDERPARM_SPECULAR_POWER, 8.0f );
}
pCamera->GetViewMatrix( m_CurrentMatrix );
// Disable all the lights..
pRenderContext->DisableAllLocalLights();
m_bIsClientSpace = false;
// reset render mode
m_RenderModeStack.Clear();
SetRenderMode( m_eDefaultRenderMode, true );
// reset colors
m_DrawColor.SetColor( 255,255,255,255 );
m_TextColor.SetColor( 255,255,255,255 );
m_HandleColor.SetColor( 255,255,255,255 );
s_fOneUnitLength = 1/pCamera->GetZoom();
// tell studiorender that we've updated the camera.
if( !bRenderingOverEngine && g_pStudioRender )
{
g_pStudioRender->BeginFrame();
Vector viewOrigin, viewRight, viewUp, viewForward;
pCamera->GetViewPoint( viewOrigin );
pCamera->GetViewRight( viewRight );
pCamera->GetViewUp( viewUp );
pCamera->GetViewForward( viewForward );
g_pStudioRender->SetViewState( viewOrigin, viewRight, viewUp, viewForward );
static Vector white[6] =
{
Vector( 1.0, 1.0, 1.0 ),
Vector( 1.0, 1.0, 1.0 ),
Vector( 1.0, 1.0, 1.0 ),
Vector( 1.0, 1.0, 1.0 ),
Vector( 1.0, 1.0, 1.0 ),
Vector( 1.0, 1.0, 1.0 ),
};
g_pStudioRender->SetAmbientLightColors( white );
}
m_bIsRendering = true;
}
void CRender::EndRenderFrame()
{
Assert( m_bIsRendering );
Assert( !m_bIsClientSpace );
Assert( m_RenderModeStack.Count() == 0 );
Assert( !m_bIsLocalTransform );
if ( g_pStudioRender )
{
g_pStudioRender->BeginFrame();
}
// turn off lighting preview shader state
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
pRenderContext->SetIntRenderingParameter(INT_RENDERPARM_ENABLE_FIXED_LIGHTING,0);
m_nFrameCount++;
m_bIsRendering = false;
m_bIsRenderingIntoVGUI = false;
}
void CRender::DrawLine( const Vector &vStart, const Vector &vEnd )
{
float scale = VectorLength( vEnd-vStart ) / ( s_fOneUnitLength * 16 );
meshBuilder.Begin(m_pMesh, MATERIAL_LINES, 1);
meshBuilder.Position3fv(vStart.Base());
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.TexCoord2f(0, 0, 0);
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv(vEnd.Base());
meshBuilder.Color4ubv((byte*)&m_DrawColor);
meshBuilder.TexCoord2f(0, scale, scale);
meshBuilder.AdvanceVertex();
meshBuilder.End();
m_pMesh->Draw();
}
void CRender::BeginLocalTransfrom( const VMatrix &matrix, bool MultiplyCurrent )
{
Assert( !m_bIsClientSpace );
VMatrix LocalCopy = matrix;
if ( MultiplyCurrent )
{
LocalCopy = m_LocalMatrix.Head() * LocalCopy;
}
m_LocalMatrix.AddToHead( LocalCopy );
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
pRenderContext->MatrixMode(MATERIAL_MODEL);
pRenderContext->PushMatrix();
pRenderContext->LoadMatrix( m_LocalMatrix.Head() );
CCamera *pCamera = GetCamera();
pCamera->GetViewMatrix( m_CurrentMatrix );
m_CurrentMatrix = m_CurrentMatrix * LocalCopy;
m_bIsLocalTransform = true;
}
void CRender::EndLocalTransfrom()
{
Assert( m_bIsLocalTransform );
Assert( !m_bIsClientSpace );
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
pRenderContext->MatrixMode(MATERIAL_MODEL);
pRenderContext->PopMatrix();
m_LocalMatrix.Remove( 0 );
CCamera *pCamera = GetCamera();
pCamera->GetViewMatrix( m_CurrentMatrix );
if ( m_LocalMatrix.Count() > 1 )
{
m_CurrentMatrix = m_CurrentMatrix * m_LocalMatrix.Head();
m_bIsLocalTransform = true;
}
else
{
m_bIsLocalTransform = false;
}
}
bool CRender::IsInLocalTransformMode()
{
return m_bIsLocalTransform;
}
void CRender::GetLocalTranform( VMatrix &matrix )
{
matrix = m_LocalMatrix.Head();
}
bool CRender::BeginClientSpace(void)
{
if ( m_bIsClientSpace )
return false;
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
pRenderContext->MatrixMode( MATERIAL_PROJECTION );
pRenderContext->PushMatrix();
pRenderContext->LoadMatrix( m_OrthoMatrix );
pRenderContext->MatrixMode(MATERIAL_VIEW);
pRenderContext->PushMatrix();
// For DX9, we need to offset vertex positions by 1/2 pixel, so that pixel and texel centers fall on the same spot.
// If we don't do this, we are at relying on undefined behavior in the various GPUs' texture units, and e.g. the 4800 series
// will render garbage text because of it. If Hammer ever needs to run on top of GL or D3D10/11, this translate has to
// become conditional based on the API we're using.
pRenderContext->LoadIdentity();
pRenderContext->Translate( -.5f, .5f, 0.0f );
if ( m_bIsLocalTransform )
{
pRenderContext->MatrixMode(MATERIAL_MODEL);
pRenderContext->PushMatrix();
pRenderContext->LoadIdentity();
}
m_bIsClientSpace = true;
return true;
}
void CRender::EndClientSpace(void)
{
Assert( m_bIsClientSpace );
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
pRenderContext->MatrixMode(MATERIAL_VIEW);
pRenderContext->PopMatrix();
pRenderContext->MatrixMode(MATERIAL_PROJECTION);
pRenderContext->PopMatrix();
if ( m_bIsLocalTransform )
{
pRenderContext->MatrixMode(MATERIAL_MODEL);
pRenderContext->PopMatrix();
}
m_bIsClientSpace = false;
}
void CRender::TransformPoint( Vector2D &vClient, const Vector& vWorld )
{
Vector vecActualPos;
if ( !m_bIsLocalTransform )
{
vecActualPos = vWorld;
}
else
{
m_LocalMatrix.Head().V3Mul( vWorld, vecActualPos );
}
m_pView->WorldToClient( vClient, vecActualPos );
}
void CRender::TransformNormal( Vector2D &vClient, const Vector& vWorld )
{
Vector2D originClient, normalClient;
TransformPoint( originClient, vec3_origin );
TransformPoint( normalClient, vWorld );
vClient = normalClient- originClient;
}
void CRender::DrawCircle( const Vector &vCenter, const Vector &vNormal, float flRadius, int nSegments)
{
Vector vx,vy;
if ( !BuildAxesFromNormal( vNormal, vx, vy ) )
return;
vx *= flRadius;
vy *= flRadius;
meshBuilder.Begin( m_pMesh, MATERIAL_LINE_LOOP, nSegments );
float invDelta = 2.0f * M_PI / nSegments;
for ( int i = 0; i < nSegments; ++i )
{
float flRadians = i * invDelta;
float ca = cos( flRadians );
float sa = sin( flRadians );
// Rotate it around the circle
Vector vertex = vCenter + (ca*vx) + (sa*vy);
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.Position3fv( &vertex.x );
meshBuilder.AdvanceVertex();
}
meshBuilder.End();
m_pMesh->Draw();
}
void CRender::DrawCircle( Vector2D &vCenter, float fRadius, int nSegments, unsigned char *pColor )
{
meshBuilder.Begin( m_pMesh, MATERIAL_LINE_LOOP, nSegments );
float invDelta = 2.0f * M_PI / nSegments;
for ( int i = 0; i < nSegments; ++i )
{
float flRadians = i * invDelta;
float ca = cos( flRadians );
float sa = sin( flRadians );
// Rotate it around the circle
float x = vCenter.x + (fRadius * ca);
float y = vCenter.y + (fRadius * sa);
meshBuilder.Color4ubv( pColor );
meshBuilder.Position3f( x, y, 0 );
meshBuilder.AdvanceVertex();
}
meshBuilder.End();
m_pMesh->Draw();
}
void CRender::DrawCross( Vector2D& ul, Vector2D& lr, unsigned char *pColor )
{
// just sizes
meshBuilder.Begin( m_pMesh, MATERIAL_LINES, 2 );
meshBuilder.Color4ubv( pColor );
meshBuilder.Position3f( ul.x, ul.y, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.Color4ubv( pColor );
meshBuilder.Position3f( lr.x, lr.y, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.Color4ubv( pColor );
meshBuilder.Position3f( ul.x, lr.y-1, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.Color4ubv( pColor );
meshBuilder.Position3f( lr.x, ul.y-1, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.End();
m_pMesh->Draw();
}
void CRender::DrawRect( Vector2D& ul, Vector2D& lr, unsigned char *pColor )
{
Vector2D vScale = (lr-ul)/16;
meshBuilder.Begin( m_pMesh, MATERIAL_LINE_LOOP, 4 );
Vector2D tex(0,0);
meshBuilder.Color4ubv( pColor );
meshBuilder.Position3f( ul.x, ul.y, 0 );
meshBuilder.TexCoord2f(0, tex.x, tex.y );
meshBuilder.AdvanceVertex();
tex.x += vScale.x;
tex.y += vScale.x;
meshBuilder.Color4ubv( pColor );
meshBuilder.Position3f( lr.x, ul.y, 0 );
meshBuilder.TexCoord2f(0, tex.x, tex.y );
meshBuilder.AdvanceVertex();
tex.x += vScale.y;
tex.y -= vScale.y;
meshBuilder.Color4ubv( pColor );
meshBuilder.Position3f( lr.x, lr.y, 0 );
meshBuilder.TexCoord2f(0, tex.x, tex.y );
meshBuilder.AdvanceVertex();
tex.x -= vScale.x;
tex.y -= vScale.x;
meshBuilder.Color4ubv( pColor );
meshBuilder.Position3f( ul.x, lr.y, 0 );
meshBuilder.TexCoord2f(0, tex.x, tex.y );
meshBuilder.AdvanceVertex();
meshBuilder.End();
m_pMesh->Draw();
}
void CRender::DrawPlane( const Vector &p0, const Vector &p1, const Vector &p2, const Vector &p3, bool bFill )
{
if ( bFill )
{
meshBuilder.Begin( m_pMesh, MATERIAL_QUADS, 1 );
}
else
{
meshBuilder.Begin( m_pMesh, MATERIAL_LINE_LOOP, 4 );
}
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.Position3fv( &p0.x );
meshBuilder.AdvanceVertex();
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.Position3fv( &p1.x );
meshBuilder.AdvanceVertex();
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.Position3fv( &p2.x );
meshBuilder.AdvanceVertex();
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.Position3fv( &p3.x );
meshBuilder.AdvanceVertex();
meshBuilder.End();
m_pMesh->Draw();
}
void CRender::DrawFilledRect( Vector2D& ul, Vector2D& lr, unsigned char *pColor, bool bBorder )
{
static Color black(0,0,0,255);
meshBuilder.Begin( m_pMesh, MATERIAL_QUADS, bBorder?2:1 );
if ( bBorder )
{
meshBuilder.Color4ubv( (byte*)&black );
meshBuilder.Position3f( ul.x, ul.y, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.Color4ubv( (byte*)&black );
meshBuilder.Position3f( lr.x, ul.y, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.Color4ubv( (byte*)&black );
meshBuilder.Position3f( lr.x, lr.y, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.Color4ubv( (byte*)&black );
meshBuilder.Position3f( ul.x, lr.y, 0 );
meshBuilder.AdvanceVertex();
ul.x+=1;
ul.y+=1;
lr.x-=1;
lr.y-=1;
}
meshBuilder.Color4ubv( pColor );
meshBuilder.Position3f( ul.x, ul.y, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.Color4ubv( pColor );
meshBuilder.Position3f( lr.x, ul.y, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.Color4ubv( pColor );
meshBuilder.Position3f( lr.x, lr.y, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.Color4ubv( pColor );
meshBuilder.Position3f( ul.x, lr.y, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.End();
m_pMesh->Draw();
}
void CRender::DrawHandle( const Vector &vCenter, const Vector2D *vOffset )
{
if ( !m_CurrentInstanceState.m_bIsEditable )
{
return;
}
int size = m_nHandleSize;
bool bPopMode = BeginClientSpace();
Vector2D vCenter2D;
TransformPoint( vCenter2D, vCenter );
if ( vOffset )
{
vCenter2D += *vOffset;
}
RoundVector( vCenter2D );
if ( m_nHandleType == HANDLE_CROSS )
size--;
Vector2D ul( vCenter2D.x-size, vCenter2D.y-size );
Vector2D lr( vCenter2D.x+size+1, vCenter2D.y+size+1 );
switch ( m_nHandleType )
{
case HANDLE_SQUARE : DrawFilledRect( ul, lr, (byte*)&m_HandleColor, true );break;
case HANDLE_CIRCLE : DrawCircle( vCenter2D, size, 16, (byte*)&m_HandleColor ); break;
case HANDLE_DIAMOND : break;
case HANDLE_CROSS : DrawCross( ul, lr, (byte*)&m_HandleColor );break;
}
if ( bPopMode )
EndClientSpace();
}
CCamera *CRender::GetCamera()
{
return m_pView->GetCamera();
}
bool CRender::SetView( CMapView * pView )
{
Assert( pView );
m_pView = pView;
// Store off the three materials we use most often...
if ( !GetRequiredMaterial( "editor/wireframe", m_pWireframe[0] ) ||
!GetRequiredMaterial( "editor/flat", m_pFlat[0] ) ||
!GetRequiredMaterial( "editor/flatdecal", m_pFlat[1] ) ||
!GetRequiredMaterial( "editor/translucentflat", m_pTranslucentFlat[0] ) ||
!GetRequiredMaterial( "editor/translucentflatdecal", m_pTranslucentFlat[1] ) ||
!GetRequiredMaterial( "editor/lightmapgrid", m_pLightmapGrid[0] ) ||
!GetRequiredMaterial( "editor/lightmapgriddecal", m_pLightmapGrid[1] ) ||
!GetRequiredMaterial( "editor/selectionoverlay", m_pSelectionOverlay[0] ) ||
!GetRequiredMaterial( "editor/flatignorez", m_pFlatNoZ[0] ) ||
!GetRequiredMaterial( "editor/flatnocull", m_pFlatNoCull[0] ) ||
!GetRequiredMaterial( "editor/dotted", m_pDotted[0] )
)
{
return false;
}
// Some materials don't have a separate decal version.
m_pFlatNoZ[1] = m_pFlatNoZ[0];
m_pFlatNoCull[1] = m_pFlatNoCull[0];
m_pWireframe[1] = m_pWireframe[0];
m_pWireframe[1] = m_pDotted[0];
m_pSelectionOverlay[1] = m_pSelectionOverlay[0];
return true;
}
bool CRender::IsActiveView()
{
return m_pView->IsActive();
}
void CRender::SetDrawColor( const Color &color )
{
m_DrawColor = color;
if ( m_bIsRenderingIntoVGUI )
{
g_pMatSystemSurface->DrawSetColor( m_DrawColor );
}
}
void CRender::GetDrawColor( Color &color )
{
color = m_DrawColor;
}
void CRender::SetDrawColor( unsigned char r, unsigned char g, unsigned char b )
{
// current draw color, keep the alpha value
m_DrawColor.SetColor( r, g, b, m_DrawColor.a() );
if ( m_bIsRenderingIntoVGUI )
{
g_pMatSystemSurface->DrawSetColor( m_DrawColor );
}
}
void CRender::SetHandleStyle( int size, int type )
{
m_nHandleType = type;
m_nHandleSize = size;
}
void CRender::DrawArrow( Vector const &vStart, Vector const &vEnd )
{
Assert(0);
}
void CRender::DrawPolyLine( int nPoints, const Vector *Points )
{
// Draw the box bottom, top, and one corner edge.
meshBuilder.Begin( m_pMesh, MATERIAL_LINE_LOOP, nPoints );
for (int i= 0; i<nPoints;i++ )
{
meshBuilder.Position3fv( &Points[i].x );
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.AdvanceVertex();
}
meshBuilder.End();
m_pMesh->Draw();
}
void CRender::DrawDisplacement( CCoreDispInfo *pMapDisp )
{
int numVerts = pMapDisp->GetSize();
int numIndices = pMapDisp->GetRenderIndexCount();
bool bWireFrame = m_eCurrentRenderMode == RENDER_MODE_WIREFRAME;
meshBuilder.Begin( m_pMesh, MATERIAL_TRIANGLES, numVerts, numIndices );
Color color = m_DrawColor;
CoreDispVert_t *pVert = pMapDisp->GetDispVertList();
for (int i = 0; i < numVerts; ++i )
{
if ( bWireFrame )
{
meshBuilder.Position3fv( pVert[i].m_Vert.Base() );
meshBuilder.Color4ubv( (byte*)&color );
meshBuilder.TexCoord2fv( 0, pVert[i].m_TexCoord.Base() );
meshBuilder.TexCoord2fv( 1, pVert[i].m_LuxelCoords[0].Base() );
meshBuilder.AdvanceVertex();
}
else
{
meshBuilder.Position3fv( pVert[i].m_Vert.Base() );
meshBuilder.Color4ub( color[0], color[1], color[2], 255 - ( unsigned char )( pVert[i].m_Alpha ) );
meshBuilder.Normal3fv( pVert[i].m_Normal.Base() );
meshBuilder.TangentS3fv( pVert[i].m_TangentS.Base() );
meshBuilder.TangentT3fv( pVert[i].m_TangentT.Base() );
meshBuilder.TexCoord2fv( 0, pVert[i].m_TexCoord.Base() );
meshBuilder.TexCoord2fv( 1, pVert[i].m_LuxelCoords[0].Base() );
meshBuilder.AdvanceVertex();
}
}
unsigned short *pIndex = pMapDisp->GetRenderIndexList();
for ( int i = 0; i < numIndices; ++i )
{
meshBuilder.Index( pIndex[i] );
meshBuilder.AdvanceIndex();
}
meshBuilder.End();
m_pMesh->Draw();
}
void CRender::DrawModel( DrawModelInfo_t* pInfo, matrix3x4_t *pBoneToWorld, const Vector &vOrigin, float fAlpha, bool bWireFrame, const Color &color )
{
if ( m_bRenderingOverEngine && g_pFoundryTool && !g_pFoundryTool->ShouldRender3DModels() )
return;
// In Foundry mode, the engine owns the studiorender config, so we must restore it after we draw a model.
StudioRenderConfig_t oldConfig;
if ( APP()->IsFoundryMode() )
{
g_pStudioRender->GetCurrentConfig( oldConfig );
}
UpdateStudioRenderConfig( true, bWireFrame );
g_pStudioRender->SetAlphaModulation( fAlpha );
float col[3];
col[0] = color.r() / 255.0f;
col[1] = color.g() / 255.0f;
col[2] = color.b() / 255.0f;
g_pStudioRender->SetColorModulation( col );
Vector viewOrigin;
GetCamera()->GetViewPoint( viewOrigin );
g_pStudioRender->SetEyeViewTarget( pInfo->m_pStudioHdr, pInfo->m_Body, viewOrigin );
if ( m_bRenderingOverEngine )
{
IMaterial *pMat = MaterialSystemInterface()->FindMaterial( "models/editor/white_model_outline", TEXTURE_GROUP_OTHER );
g_pStudioRender->ForcedMaterialOverride( pMat, OVERRIDE_NORMAL );
g_pStudioRender->SetAlphaModulation( 0.3f );
g_pStudioRender->DrawModel( NULL, *pInfo, pBoneToWorld, NULL, NULL, vOrigin, STUDIORENDER_DRAW_ENTIRE_MODEL );
g_pStudioRender->SetAlphaModulation( 1 );
g_pStudioRender->ForcedMaterialOverride( NULL, OVERRIDE_NORMAL );
}
else
{
g_pStudioRender->DrawModel( NULL, *pInfo, pBoneToWorld, NULL, NULL, vOrigin, STUDIORENDER_DRAW_ENTIRE_MODEL );
}
g_pStudioRender->SetAlphaModulation( 1.0f );
col[0] = col[1] = col[2] = 1.0f;
g_pStudioRender->SetColorModulation( col );
// force rendermode reset
SetRenderMode( RENDER_MODE_CURRENT, true );
// Restore the studiorender config.
if ( APP()->IsFoundryMode() )
{
g_pStudioRender->UpdateConfig( oldConfig );
}
}
void CRender::DrawCollisionModel( MDLHandle_t mdlHandle, const VMatrix &mViewMatrix )
{
vcollide_t *pCollide =g_pMDLCache->GetVCollide( mdlHandle );
if ( !pCollide || pCollide->solidCount <= 0 )
return;
Vector *outVerts;
int vertCount = g_pPhysicsCollision->CreateDebugMesh( pCollide->solids[0], &outVerts );
if ( vertCount )
{
PushRenderMode( RENDER_MODE_WIREFRAME );
meshBuilder.Begin( m_pMesh, MATERIAL_TRIANGLES, vertCount/3 );
for ( int j = 0; j < vertCount; j++ )
{
Vector out;
mViewMatrix.V3Mul( outVerts[j], out );
meshBuilder.Position3fv( out.Base() );
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.TexCoord2f( 0, 0, 0 );
meshBuilder.AdvanceVertex();
}
meshBuilder.End();
m_pMesh->Draw();
PopRenderMode();
}
g_pPhysicsCollision->DestroyDebugMesh( vertCount, outVerts );
}
void CRender::DrawSphere( const Vector &vCenter, int nRadius )
{
Assert(0);
}
void CRender::DrawBoxExt( const Vector &vCenter, float extend, bool bFill)
{
Vector vExtent( extend, extend, extend );
Vector vMins = vCenter - vExtent;
Vector vMax = vCenter + vExtent;
DrawBox( vMins, vMax, bFill );
}
void CRender::DrawHandles( int nPoints, const Vector *Points )
{
Assert(0);
}
void CRender::DrawBox( const Vector &vMins, const Vector &vMaxs, bool bFill)
{
Vector points[8];
PointsFromBox( vMins, vMaxs, points );
if ( bFill )
{
Assert(0);
}
else
{
// Draw the box bottom, top, and one corner edge.
meshBuilder.Begin( m_pMesh, MATERIAL_LINE_STRIP, 9 );
meshBuilder.Position3fv( &points[0].x );
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( &points[1].x );
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( &points[3].x );
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( &points[2].x );
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( &points[6].x );
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( &points[7].x );
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( &points[5].x );
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( &points[4].x );
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( &points[0].x );
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( &points[2].x );
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.AdvanceVertex();
meshBuilder.End();
m_pMesh->Draw();
// Draw the three missing edges.
meshBuilder.Begin( m_pMesh, MATERIAL_LINES, 3 );
meshBuilder.Position3fv( &points[4].x );
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( &points[6].x );
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( &points[1].x );
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( &points[5].x );
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( &points[3].x );
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( &points[7].x );
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.AdvanceVertex();
meshBuilder.End();
m_pMesh->Draw();
}
}
void CRender::DrawPoint( const Vector &vPoint )
{
// HACK HACK, MATERIAL_POINTS doesnt work somehow
meshBuilder.Begin( m_pMesh, MATERIAL_LINES, 1 );
meshBuilder.Position3f( vPoint.x, vPoint.y, vPoint.z );
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( vPoint.x+1, vPoint.y+1, vPoint.z );
meshBuilder.Color4ubv( (byte*)&m_DrawColor );
meshBuilder.AdvanceVertex();
meshBuilder.End();
m_pMesh->Draw();
}
//-----------------------------------------------------------------------------
// Purpose: Binds a texture for rendering. If the texture has never been bound
// to this rendering context, it is uploaded to the driver.
// Input : pTexture - Pointer to the texture object being bound.
//-----------------------------------------------------------------------------
void CRender::BindTexture(IEditorTexture *pTexture)
{
// These textures must be CMaterials....
BindMaterial( pTexture->GetMaterial() );
}
//-----------------------------------------------------------------------------
// Purpose: Binds a material for rendering. If the material has never been bound
// to this rendering context, it is uploaded to the driver.
// Input : pMaterial - Pointer to the material object being bound.
//-----------------------------------------------------------------------------
void CRender::BindMaterial( IMaterial *pMaterial )
{
if ( m_pBoundMaterial != pMaterial )
{
m_pBoundMaterial = pMaterial;
SetRenderMode( RENDER_MODE_CURRENT, true );
}
}
bool CRender::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:
// Input : eRenderMode -
//-----------------------------------------------------------------------------
void CRender::SetRenderMode(EditorRenderMode_t eRenderMode, bool bForce)
{
if (eRenderMode == RENDER_MODE_DEFAULT)
{
eRenderMode = m_eDefaultRenderMode;
}
if ( eRenderMode == RENDER_MODE_CURRENT )
{
eRenderMode = m_eCurrentRenderMode;
}
if (m_eCurrentRenderMode == eRenderMode && !bForce)
return;
// Bind the appropriate material based on our mode
CMatRenderContextPtr pRenderContext( MaterialSystemInterface() );
switch(eRenderMode)
{
case RENDER_MODE_DOTTED:
m_pCurrentMaterial = m_pDotted[m_nDecalMode];
break;
case RENDER_MODE_FLAT:
// Ensures we get red even for decals
m_pCurrentMaterial = m_pFlat[m_nDecalMode];
break;
case RENDER_MODE_TRANSLUCENT_FLAT:
m_pCurrentMaterial = m_pTranslucentFlat[m_nDecalMode];
break;
case RENDER_MODE_FLAT_NOZ:
// flat mode but not depth check
m_pCurrentMaterial = m_pFlatNoZ[m_nDecalMode];
break;
case RENDER_MODE_FLAT_NOCULL:
// flat mode but not depth check
m_pCurrentMaterial = m_pFlatNoCull[m_nDecalMode];
break;
case RENDER_MODE_WIREFRAME:
m_pCurrentMaterial = m_pWireframe[m_nDecalMode];
break;
case RENDER_MODE_SMOOTHING_GROUP:
m_pCurrentMaterial = m_pFlat[m_nDecalMode];
break;
case RENDER_MODE_LIGHTMAP_GRID:
m_pCurrentMaterial = m_pLightmapGrid[m_nDecalMode];
break;
case RENDER_MODE_SELECTION_OVERLAY:
case RENDER_MODE_INSTANCE_OVERLAY:
// Ensures we get red even for decals
m_pCurrentMaterial = m_pSelectionOverlay[m_nDecalMode];
break;
case RENDER_MODE_TEXTURED:
case RENDER_MODE_TEXTURED_SHADED:
case RENDER_MODE_LIGHT_PREVIEW2:
case RENDER_MODE_LIGHT_PREVIEW_RAYTRACED:
if (m_pBoundMaterial)
{
if( m_pBoundMaterial->GetPropertyFlag( MATERIAL_PROPERTY_NEEDS_BUMPED_LIGHTMAPS ) )
{
pRenderContext->BindLightmapPage( MATERIAL_SYSTEM_LIGHTMAP_PAGE_WHITE_BUMP );
}
else
{
pRenderContext->BindLightmapPage( MATERIAL_SYSTEM_LIGHTMAP_PAGE_WHITE );
}
m_pCurrentMaterial = m_pBoundMaterial;
}
else
{
m_pCurrentMaterial = m_pFlat[m_nDecalMode];
}
break;
}
Assert( m_pCurrentMaterial != NULL );
pRenderContext->Bind( m_pCurrentMaterial );
pRenderContext->SetIntRenderingParameter(INT_RENDERPARM_ENABLE_FIXED_LIGHTING,0);
if (eRenderMode==RENDER_MODE_TEXTURED_SHADED)
pRenderContext->SetIntRenderingParameter(INT_RENDERPARM_ENABLE_FIXED_LIGHTING,1);
if (
(eRenderMode==RENDER_MODE_LIGHT_PREVIEW2) ||
(eRenderMode==RENDER_MODE_LIGHT_PREVIEW_RAYTRACED)
)
pRenderContext->SetIntRenderingParameter(INT_RENDERPARM_ENABLE_FIXED_LIGHTING,2);
m_pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, m_pCurrentMaterial );
Assert( m_pMesh );
m_eCurrentRenderMode = eRenderMode;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : eRenderMode -
//-----------------------------------------------------------------------------
void CRender::SetDefaultRenderMode(EditorRenderMode_t eRenderMode)
{
Assert( eRenderMode != RENDER_MODE_DEFAULT );
m_eDefaultRenderMode = eRenderMode;
}
void CRender::PushRenderMode( EditorRenderMode_t eRenderMode )
{
m_RenderModeStack.Push( m_eCurrentRenderMode );
SetRenderMode( eRenderMode );
}
void CRender::PopRenderMode()
{
SetRenderMode( m_RenderModeStack.Top() );
m_RenderModeStack.Pop();
}
#define CAMERA_RIGHT 0
#define CAMERA_UP 1
#define CAMERA_FORWARD 2
//-----------------------------------------------------------------------------
// Purpose: Returns a vector indicating the camera's forward axis.
//-----------------------------------------------------------------------------
void CRender::GetViewForward( Vector &ViewForward ) const
{
ViewForward[ 0 ] = -m_CurrentMatrix[ CAMERA_FORWARD ][ 0 ];
ViewForward[ 1 ] = -m_CurrentMatrix[ CAMERA_FORWARD ][ 1 ];
ViewForward[ 2 ] = -m_CurrentMatrix[ CAMERA_FORWARD ][ 2 ];
}
//-----------------------------------------------------------------------------
// Purpose: Returns a vector indicating the camera's up axis.
//-----------------------------------------------------------------------------
void CRender::GetViewUp(Vector& ViewUp) const
{
ViewUp[ 0 ] = m_CurrentMatrix[ CAMERA_UP ][ 0 ];
ViewUp[ 1 ] = m_CurrentMatrix[ CAMERA_UP ][ 1 ];
ViewUp[ 2 ] = m_CurrentMatrix[ CAMERA_UP ][ 2 ];
}
//-----------------------------------------------------------------------------
// Purpose: Returns a vector indicating the camera's right axis.
//-----------------------------------------------------------------------------
void CRender::GetViewRight(Vector& ViewRight) const
{
ViewRight[ 0 ] = m_CurrentMatrix[ CAMERA_RIGHT ][ 0 ];
ViewRight[ 1 ] = m_CurrentMatrix[ CAMERA_RIGHT ][ 1 ];
ViewRight[ 2 ] = m_CurrentMatrix[ CAMERA_RIGHT ][ 2 ];
}
Reference in New Issue Copy Permalink