BotoX
/
hl2_src-leak-2017
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
hl2_src-leak-2017/src/hammer/mapstudiomodel.cpp

905 lines
24 KiB
C++
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#include "stdafx.h"
#include "Box3D.h"
#include "GlobalFunctions.h"
#include "MapDefs.h" // dvs: For COORD_NOTINIT
#include "MapDoc.h"
#include "MapEntity.h"
#include "MapStudioModel.h"
#include "Render2D.h"
#include "Render3D.h"
#include "ViewerSettings.h"
#include "hammer.h"
#include "materialsystem/imesh.h"
#include "TextureSystem.h"
#include "Material.h"
#include "Options.h"
#include "camera.h"
// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>
#define STUDIO_RENDER_DISTANCE 400
IMPLEMENT_MAPCLASS(CMapStudioModel)
float CMapStudioModel::m_fRenderDistance = STUDIO_RENDER_DISTANCE;
BOOL CMapStudioModel::m_bAnimateModels = TRUE;
//-----------------------------------------------------------------------------
// Purpose: Factory function. Used for creating a CMapStudioModel from a set
// of string parameters from the FGD file.
// Input : pInfo - Pointer to helper info class which gives us information
// about how to create the class.
// Output : Returns a pointer to the class, NULL if an error occurs.
//-----------------------------------------------------------------------------
CMapClass *CMapStudioModel::CreateMapStudioModel(CHelperInfo *pHelperInfo, CMapEntity *pParent)
{
const char *pszModel = pHelperInfo->GetParameter(0);
//
// If we weren't passed a model name as an argument, get it from our parent
// entity's "model" key.
//
if (pszModel == NULL)
{
pszModel = pParent->GetKeyValue("model");
}
//
// If we have a model name, create a studio model object.
//
if (pszModel != NULL)
{
bool bLightProp = !stricmp(pHelperInfo->GetName(), "lightprop");
bool bOrientedBounds = (bLightProp | !stricmp(pHelperInfo->GetName(), "studioprop"));
return CreateMapStudioModel(pszModel, bOrientedBounds, bLightProp);
}
return(NULL);
}
//-----------------------------------------------------------------------------
// Purpose: Factory function. Creates a CMapStudioModel object from a relative
// path to an MDL file.
// Input : pszModelPath - Relative path to the .MDL file. The path is appended
// to each path in the application search path until the model is found.
// bOrientedBounds - Whether the bounding box should consider the orientation of the model.
// Output : Returns a pointer to the newly created CMapStudioModel object.
//-----------------------------------------------------------------------------
CMapStudioModel *CMapStudioModel::CreateMapStudioModel(const char *pszModelPath, bool bOrientedBounds, bool bReversePitch)
{
CMapStudioModel *pModel = new CMapStudioModel;
pModel->m_pStudioModel = CStudioModelCache::CreateModel(pszModelPath);
if ( pModel->m_pStudioModel )
{
pModel->SetOrientedBounds(bOrientedBounds);
pModel->ReversePitch(bReversePitch);
pModel->CalcBounds();
}
else
{
delete pModel;
pModel = NULL;
}
return(pModel);
}
//-----------------------------------------------------------------------------
// Purpose: Constructor.
//-----------------------------------------------------------------------------
CMapStudioModel::CMapStudioModel(void)
{
Initialize();
InitViewerSettings();
}
//-----------------------------------------------------------------------------
// Purpose: Destructor. Releases the studio model cache reference.
//-----------------------------------------------------------------------------
CMapStudioModel::~CMapStudioModel(void)
{
if (m_pStudioModel != NULL)
{
CStudioModelCache::Release(m_pStudioModel);
}
}
//-----------------------------------------------------------------------------
// Purpose: Called by the renderer before every frame to animate the models.
//-----------------------------------------------------------------------------
void CMapStudioModel::AdvanceAnimation(float flInterval)
{
if (m_bAnimateModels)
{
CStudioModelCache::AdvanceAnimation(flInterval);
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : bFullUpdate -
//-----------------------------------------------------------------------------
void CMapStudioModel::CalcBounds(BOOL bFullUpdate)
{
CMapClass::CalcBounds(bFullUpdate);
Vector Mins(0, 0, 0);
Vector Maxs(0, 0, 0);
if (m_pStudioModel != NULL)
{
//
// The 3D bounds are the bounds of the oriented model's first sequence, so that
// frustum culling works properly in the 3D view.
//
QAngle angles;
GetRenderAngles(angles);
m_pStudioModel->SetAngles(angles);
m_pStudioModel->ExtractBbox(m_CullBox.bmins, m_CullBox.bmaxs);
if (m_bOrientedBounds)
{
//
// Oriented bounds - the 2D bounds are the same as the 3D bounds.
//
Mins = m_CullBox.bmins;
Maxs = m_CullBox.bmaxs;
}
else
{
//
// The 2D bounds are the movement bounding box of the model, which is not affected
// by the entity's orientation. This is used for character models for which we want
// to render a meaningful collision box in the editor.
//
m_pStudioModel->ExtractMovementBbox(Mins, Maxs);
}
Mins += m_Origin;
Maxs += m_Origin;
m_CullBox.bmins += m_Origin;
m_CullBox.bmaxs += m_Origin;
}
//
// If we do not yet have a valid bounding box, use a default box.
//
if ((Maxs - Mins) == Vector(0, 0, 0))
{
Mins = m_CullBox.bmins = m_Origin - Vector(10, 10, 10);
Maxs = m_CullBox.bmaxs = m_Origin + Vector(10, 10, 10);
}
m_BoundingBox = m_CullBox;
m_Render2DBox.UpdateBounds(Mins, Maxs);
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : CMapClass
//-----------------------------------------------------------------------------
CMapClass *CMapStudioModel::Copy(bool bUpdateDependencies)
{
CMapStudioModel *pCopy = new CMapStudioModel;
if (pCopy != NULL)
{
pCopy->CopyFrom(this, bUpdateDependencies);
}
return(pCopy);
}
//-----------------------------------------------------------------------------
// Purpose: Makes this an exact duplicate of pObject.
// Input : pObject - Object to copy.
// Output : Returns this.
//-----------------------------------------------------------------------------
CMapClass *CMapStudioModel::CopyFrom(CMapClass *pObject, bool bUpdateDependencies)
{
Assert(pObject->IsMapClass(MAPCLASS_TYPE(CMapStudioModel)));
CMapStudioModel *pFrom = (CMapStudioModel *)pObject;
CMapClass::CopyFrom(pObject, bUpdateDependencies);
m_pStudioModel = pFrom->m_pStudioModel;
if (m_pStudioModel != NULL)
{
CStudioModelCache::AddRef(m_pStudioModel);
}
m_Angles = pFrom->m_Angles;
m_Skin = pFrom->m_Skin;
m_bOrientedBounds = pFrom->m_bOrientedBounds;
m_bReversePitch = pFrom->m_bReversePitch;
m_bPitchSet = pFrom->m_bPitchSet;
m_flPitch = pFrom->m_flPitch;
m_bScreenSpaceFade = pFrom->m_bScreenSpaceFade;
m_flFadeScale = pFrom->m_flFadeScale;
m_flFadeMinDist = pFrom->m_flFadeMinDist;
m_flFadeMaxDist = pFrom->m_flFadeMaxDist;
m_iSolid = pFrom->m_iSolid;
return(this);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : bEnable -
//-----------------------------------------------------------------------------
void CMapStudioModel::EnableAnimation(BOOL bEnable)
{
m_bAnimateModels = bEnable;
}
//-----------------------------------------------------------------------------
// Purpose: Returns this object's pitch, yaw, and roll.
//-----------------------------------------------------------------------------
void CMapStudioModel::GetAngles(QAngle &Angles)
{
Angles = m_Angles;
if (m_bPitchSet)
{
Angles[PITCH] = m_flPitch;
}
}
//-----------------------------------------------------------------------------
// Purpose: Returns this object's pitch, yaw, and roll for rendering.
//-----------------------------------------------------------------------------
void CMapStudioModel::GetRenderAngles(QAngle &Angles)
{
GetAngles(Angles);
if (m_bReversePitch)
{
Angles[PITCH] *= -1;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapStudioModel::Initialize(void)
{
m_Angles.Init();
m_bPitchSet = false;
m_flPitch = 0;
m_bReversePitch = false;
m_pStudioModel = NULL;
m_Skin = 0;
m_bScreenSpaceFade = false;
m_flFadeScale = 1.0f;
m_flFadeMinDist = 0.0f;
m_flFadeMaxDist = 0.0f;
m_iSolid = -1;
}
//-----------------------------------------------------------------------------
// Purpose: Notifies that this object's parent entity has had a key value change.
// Input : szKey - The key that changed.
// szValue - The new value of the key.
//-----------------------------------------------------------------------------
void CMapStudioModel::OnParentKeyChanged(const char* szKey, const char* szValue)
{
if (!stricmp(szKey, "angles"))
{
sscanf(szValue, "%f %f %f", &m_Angles[PITCH], &m_Angles[YAW], &m_Angles[ROLL]);
PostUpdate(Notify_Changed);
}
else if (!stricmp(szKey, "pitch"))
{
m_flPitch = atof(szValue);
m_bPitchSet = true;
PostUpdate(Notify_Changed);
}
else if (!stricmp(szKey, "skin"))
{
m_Skin = atoi(szValue);
PostUpdate(Notify_Changed);
}
else if (!stricmp(szKey, "fademindist"))
{
m_flFadeMinDist = atoi(szValue);
}
else if (!stricmp(szKey, "fademaxdist"))
{
m_flFadeMaxDist = atoi(szValue);
}
else if (!stricmp(szKey, "screenspacefade"))
{
m_bScreenSpaceFade = (atoi(szValue) != 0);
}
else if (!stricmp(szKey, "fadescale"))
{
m_flFadeScale = atof(szValue);
}
else if ( !stricmp( szKey, "solid") )
{
m_iSolid = atof( szValue );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pRender -
//-----------------------------------------------------------------------------
bool CMapStudioModel::RenderPreload(CRender3D *pRender, bool bNewContext)
{
return(m_pStudioModel != NULL);
}
//-----------------------------------------------------------------------------
// Draws basis vectors
//-----------------------------------------------------------------------------
static void DrawBasisVectors( CRender3D* pRender, const Vector &origin, const QAngle &angles)
{
matrix3x4_t fCurrentMatrix;
AngleMatrix(angles, fCurrentMatrix);
pRender->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(origin[0], origin[1], origin[2]);
meshBuilder.AdvanceVertex();
meshBuilder.Color3ub(255, 0, 0);
meshBuilder.Position3f(origin[0] + (100 * fCurrentMatrix[0][0]),
origin[1] + (100 * fCurrentMatrix[1][0]), origin[2] + (100 * fCurrentMatrix[2][0]));
meshBuilder.AdvanceVertex();
meshBuilder.Color3ub(0, 255, 0);
meshBuilder.Position3f(origin[0], origin[1], origin[2]);
meshBuilder.AdvanceVertex();
meshBuilder.Color3ub(0, 255, 0);
meshBuilder.Position3f(origin[0] + (100 * fCurrentMatrix[0][1]),
origin[1] + (100 * fCurrentMatrix[1][1]), origin[2] + (100 * fCurrentMatrix[2][1]));
meshBuilder.AdvanceVertex();
meshBuilder.Color3ub(0, 0, 255);
meshBuilder.Position3f(origin[0], origin[1], origin[2]);
meshBuilder.AdvanceVertex();
meshBuilder.Color3ub(0, 0, 255);
meshBuilder.Position3f(origin[0] + (100 * fCurrentMatrix[0][2]),
origin[1] + (100 * fCurrentMatrix[1][2]), origin[2] + (100 * fCurrentMatrix[2][2]));
meshBuilder.AdvanceVertex();
meshBuilder.End();
pMesh->Draw();
pRender->PopRenderMode();
}
//-----------------------------------------------------------------------------
// It should render last if any of its materials are translucent, or if
// we are previewing model fades.
//-----------------------------------------------------------------------------
bool CMapStudioModel::ShouldRenderLast()
{
return m_pStudioModel->IsTranslucent() || Options.view3d.bPreviewModelFade;
}
//-----------------------------------------------------------------------------
// Purpose: Renders the studio model in the 2D views.
// Input : pRender - Interface to the 2D renderer.
//-----------------------------------------------------------------------------
void CMapStudioModel::Render2D(CRender2D *pRender)
{
Vector vecMins;
Vector vecMaxs;
GetRender2DBox(vecMins, vecMaxs);
Vector2D pt,pt2;
pRender->TransformPoint(pt, vecMins);
pRender->TransformPoint(pt2, vecMaxs);
color32 rgbColor = GetRenderColor();
bool bIsEditable = IsEditable();
if (GetSelectionState() != SELECT_NONE)
{
pRender->SetDrawColor( GetRValue(Options.colors.clrSelection), GetGValue(Options.colors.clrSelection), GetBValue(Options.colors.clrSelection) );
pRender->SetHandleColor( GetRValue(Options.colors.clrSelection), GetGValue(Options.colors.clrSelection), GetBValue(Options.colors.clrSelection) );
}
else
{
pRender->SetDrawColor( rgbColor.r, rgbColor.g, rgbColor.b );
pRender->SetHandleColor( rgbColor.r, rgbColor.g, rgbColor.b );
}
int sizeX = abs(pt2.x-pt.x);
int sizeY = abs(pt2.y-pt.y);
//
// Don't draw the center handle if the model is smaller than the handle cross
//
if ( bIsEditable && sizeX >= 8 && sizeY >= 8 && pRender->IsActiveView() )
{
pRender->SetHandleStyle( HANDLE_RADIUS, CRender::HANDLE_CROSS );
pRender->DrawHandle( (vecMins+vecMaxs)/2 );
}
QAngle vecAngles;
GetRenderAngles(vecAngles);
bool bDrawAsModel = (Options.view2d.bDrawModels && ((sizeX+sizeY) > 50)) ||
IsSelected() || ( pRender->IsInLocalTransformMode() && !pRender->GetInstanceRendering() );
if ( !bDrawAsModel || IsSelected() )
{
// Draw the bounding box.
pRender->DrawBox( vecMins, vecMaxs );
}
if ( bDrawAsModel )
{
//
// Draw the model as wireframe.
//
m_pStudioModel->SetAngles(vecAngles);
m_pStudioModel->SetOrigin(m_Origin[0], m_Origin[1], m_Origin[2]);
m_pStudioModel->SetSkin(m_Skin);
if ( GetSelectionState() == SELECT_NORMAL || ( pRender->IsInLocalTransformMode() && pRender->GetInstanceRendering() == false ) )
{
// draw textured model half translucent
m_pStudioModel->DrawModel2D(pRender, 0.6 , false );
}
else
{
// just draw the wireframe
m_pStudioModel->DrawModel2D(pRender, 1.0 , true );
}
}
if ( IsSelected() )
{
//
// Render the forward vector if the object is selected.
//
Vector Forward;
AngleVectors(vecAngles, &Forward, NULL, NULL);
pRender->SetDrawColor( 255, 255, 0 );
pRender->DrawLine(m_Origin, m_Origin + Forward * 24);
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline float CMapStudioModel::ComputeDistanceFade( CRender3D *pRender ) const
{
Vector vecViewPos;
pRender->GetCamera()->GetViewPoint( vecViewPos );
Vector vecDelta;
vecDelta = m_Origin - vecViewPos;
float flMin = min(m_flFadeMinDist, m_flFadeMaxDist);
float flMax = max(m_flFadeMinDist, m_flFadeMaxDist);
if (flMin < 0)
{
flMin = 0;
}
float alpha = 1.0f;
if (flMax > 0)
{
float flDist = vecDelta.Length();
if ( flDist > flMax )
{
alpha = 0.0f;
}
else if ( flDist > flMin )
{
alpha = RemapValClamped( flDist, flMin, flMax, 1.0f, 0 );
}
}
return alpha;
}
//-----------------------------------------------------------------------------
// Computes fade alpha based on distance fade + screen fade
//-----------------------------------------------------------------------------
inline float CMapStudioModel::ComputeScreenFade( CRender3D *pRender ) const
{
return 1.0;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline float CMapStudioModel::ComputeFade( CRender3D *pRender ) const
{
if ( m_bScreenSpaceFade )
{
return ComputeScreenFade( pRender );
}
else
{
return ComputeDistanceFade( pRender );
}
}
//-----------------------------------------------------------------------------
// Purpose: Renders the studio model in the 3D views.
// Input : pRender - Interface to the 3D renderer.
//-----------------------------------------------------------------------------
void CMapStudioModel::Render3D(CRender3D *pRender)
{
Color CurrentColor;
CurrentColor.SetColor( r, g, b );
//
// Set to the default rendering mode, unless we're in lightmap mode
//
if (pRender->GetCurrentRenderMode() == RENDER_MODE_LIGHTMAP_GRID)
pRender->PushRenderMode(RENDER_MODE_TEXTURED);
else
pRender->PushRenderMode(RENDER_MODE_CURRENT);
//
// Set up our angles for rendering.
//
QAngle vecAngles;
GetRenderAngles(vecAngles);
//
// If we have a model, render it if it is close enough to the camera.
//
if (m_pStudioModel != NULL)
{
Vector ViewPoint;
pRender->GetCamera()->GetViewPoint(ViewPoint);
Vector Origin( m_Origin );
if ( pRender->GetInstanceRendering() )
{
pRender->TransformInstanceVector( m_Origin, Origin );
}
if ((fabs(ViewPoint[0] - Origin[0]) < m_fRenderDistance) &&
(fabs(ViewPoint[1] - Origin[1]) < m_fRenderDistance) &&
(fabs(ViewPoint[2] - Origin[2]) < m_fRenderDistance))
{
color32 rgbColor = GetRenderColor();
if (GetSelectionState() != SELECT_NONE)
{
pRender->SetDrawColor( GetRValue(Options.colors.clrSelection), GetGValue(Options.colors.clrSelection), GetBValue(Options.colors.clrSelection) );
}
else
{
// If the user disabled collisions on this instance of the model, color the wireframe differently
if ( m_iSolid != -1 )
{
if ( m_iSolid == 0 )
{
rgbColor.r = GetRValue( Options.colors.clrModelCollisionWireframeDisabled );
rgbColor.g = GetGValue( Options.colors.clrModelCollisionWireframeDisabled );
rgbColor.b = GetBValue( Options.colors.clrModelCollisionWireframeDisabled );
rgbColor.a = 255;
}
else
{
rgbColor.r = GetRValue( Options.colors.clrModelCollisionWireframe );
rgbColor.g = GetGValue( Options.colors.clrModelCollisionWireframe );
rgbColor.b = GetBValue( Options.colors.clrModelCollisionWireframe );
rgbColor.a = 255;
}
}
pRender->SetDrawColor( rgbColor.r, rgbColor.g, rgbColor.b );
}
//
// Move the model to the proper place and orient it.
//
m_pStudioModel->SetAngles(vecAngles);
m_pStudioModel->SetOrigin(m_Origin[0], m_Origin[1], m_Origin[2]);
m_pStudioModel->SetSkin(m_Skin);
float flAlpha = 1.0;
if ( Options.view3d.bPreviewModelFade )
{
flAlpha = ComputeFade( pRender );
}
bool bWireframe = pRender->GetCurrentRenderMode() == RENDER_MODE_WIREFRAME;
if ( GetSelectionState() == SELECT_MODIFY )
bWireframe = true;
pRender->BeginRenderHitTarget(this);
m_pStudioModel->DrawModel3D(pRender, flAlpha, bWireframe );
pRender->EndRenderHitTarget();
if (IsSelected())
{
pRender->RenderWireframeBox(m_Render2DBox.bmins, m_Render2DBox.bmaxs, 255, 255, 0);
}
}
else
{
pRender->BeginRenderHitTarget(this);
pRender->RenderBox(m_Render2DBox.bmins, m_Render2DBox.bmaxs, CurrentColor.r(), CurrentColor.g(), CurrentColor.b(), GetSelectionState());
pRender->EndRenderHitTarget();
}
}
//
// Else no model, render as a bounding box.
//
else
{
pRender->BeginRenderHitTarget(this);
pRender->RenderBox(m_Render2DBox.bmins, m_Render2DBox.bmaxs, CurrentColor.r(), CurrentColor.g(), CurrentColor.b(), GetSelectionState());
pRender->EndRenderHitTarget();
}
//
// Draw our basis vectors.
//
if (IsSelected())
{
DrawBasisVectors( pRender, m_Origin, vecAngles );
}
pRender->PopRenderMode();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &File -
// bRMF -
// Output : int
//-----------------------------------------------------------------------------
int CMapStudioModel::SerializeRMF(std::fstream &File, BOOL bRMF)
{
return(0);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &File -
// bRMF -
// Output : int
//-----------------------------------------------------------------------------
int CMapStudioModel::SerializeMAP(std::fstream &File, BOOL bRMF)
{
return(0);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : Angles -
//-----------------------------------------------------------------------------
void CMapStudioModel::SetAngles(QAngle &Angles)
{
m_Angles = Angles;
//
// Round very small angles to zero.
//
for (int nDim = 0; nDim < 3; nDim++)
{
if (fabs(m_Angles[nDim]) < 0.001)
{
m_Angles[nDim] = 0;
}
}
while (m_Angles[YAW] < 0)
{
m_Angles[YAW] += 360;
}
if (m_bPitchSet)
{
m_flPitch = m_Angles[PITCH];
}
//
// Update the angles of our parent entity.
//
CMapEntity *pEntity = dynamic_cast<CMapEntity *>(m_pParent);
if (pEntity != NULL)
{
char szValue[80];
sprintf(szValue, "%g %g %g", m_Angles[0], m_Angles[1], m_Angles[2]);
pEntity->NotifyChildKeyChanged(this, "angles", szValue);
if (m_bPitchSet)
{
sprintf(szValue, "%g", m_flPitch);
pEntity->NotifyChildKeyChanged(this, "pitch", szValue);
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Sets the distance at which studio models become rendered as bounding
// boxes. If this is set to zero, studio models are never rendered.
// Input : fRenderDistance - Distance in world units.
//-----------------------------------------------------------------------------
void CMapStudioModel::SetRenderDistance(float fRenderDistance)
{
m_fRenderDistance = fRenderDistance;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pTransBox -
//-----------------------------------------------------------------------------
void CMapStudioModel::DoTransform(const VMatrix &matrix)
{
BaseClass::DoTransform(matrix);
// rotate model angles
matrix3x4_t fRotateMatrix, fCurrentMatrix, fMatrixNew;
fRotateMatrix = matrix.As3x4();
// Light entities negate pitch again!
if ( m_bReversePitch )
{
QAngle rotAngles;
MatrixAngles(fRotateMatrix, rotAngles);
rotAngles[PITCH] *= -1;
rotAngles[ROLL] *= -1;
AngleMatrix(rotAngles, fRotateMatrix);
}
QAngle angles;
GetAngles( angles );
AngleMatrix( angles, fCurrentMatrix);
ConcatTransforms(fRotateMatrix, fCurrentMatrix, fMatrixNew);
MatrixAngles( fMatrixNew, angles );
SetAngles( angles );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int CMapStudioModel::GetFrame(void)
{
// TODO:
return 0;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : nFrame -
//-----------------------------------------------------------------------------
void CMapStudioModel::SetFrame(int nFrame)
{
// TODO:
}
//-----------------------------------------------------------------------------
// Purpose: Returns the current sequence being used for rendering.
//-----------------------------------------------------------------------------
int CMapStudioModel::GetSequence(void)
{
if (!m_pStudioModel)
{
return 0;
}
return m_pStudioModel->GetSequence();
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int CMapStudioModel::GetSequenceCount(void)
{
if (!m_pStudioModel)
{
return 0;
}
return m_pStudioModel->GetSequenceCount();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : nIndex -
// szName -
//-----------------------------------------------------------------------------
void CMapStudioModel::GetSequenceName(int nIndex, char *szName)
{
if (m_pStudioModel)
{
m_pStudioModel->GetSequenceName(nIndex, szName);
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : nIndex -
//-----------------------------------------------------------------------------
void CMapStudioModel::SetSequence(int nIndex)
{
if (m_pStudioModel)
{
m_pStudioModel->SetSequence(nIndex);
}
}
int CMapStudioModel::GetSequenceIndex( const char *pSequenceName ) const
{
if ( m_pStudioModel )
{
int cnt = m_pStudioModel->GetSequenceCount();
for ( int i=0; i < cnt; i++ )
{
char name[2048];
m_pStudioModel->GetSequenceName( i, name );
if ( Q_stricmp( pSequenceName, name ) == 0 )
return i;
}
}
return -1;
}
Reference in New Issue View Git Blame Copy Permalink