645 lines
19 KiB
C++
645 lines
19 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================//
|
|
|
|
#ifndef MAPFACE_H
|
|
#define MAPFACE_H
|
|
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
|
|
#pragma warning(push, 1)
|
|
#pragma warning(disable:4701 4702 4530)
|
|
#include <fstream>
|
|
#pragma warning(pop)
|
|
#include "hammer_mathlib.h"
|
|
#include "MapAtom.h"
|
|
#include "DispManager.h"
|
|
#include "mathlib/Vector4d.h"
|
|
#include "utlvector.h"
|
|
#include "Color.h"
|
|
#include "smoothinggroupmgr.h"
|
|
#include "detailobjects.h"
|
|
|
|
class CCheckFaceInfo;
|
|
class IEditorTexture;
|
|
class CRender;
|
|
class CRender3D;
|
|
class CChunkFile;
|
|
class CSaveInfo;
|
|
class IMaterial;
|
|
class CMapWorld;
|
|
struct MapFaceRender_t;
|
|
class CMeshBuilder;
|
|
class IMesh;
|
|
|
|
struct LoadFace_t;
|
|
|
|
enum EditorRenderMode_t;
|
|
enum ChunkFileResult_t;
|
|
|
|
#define DEFAULT_TEXTURE_SCALE 0.25
|
|
#define DEFAULT_LIGHTMAP_SCALE 16
|
|
|
|
#define SMOOTHING_GROUP_MAX_COUNT 32
|
|
#define SMOOTHING_GROUP_DEFAULT 0
|
|
|
|
//
|
|
// Flags for CMapFace::CopyFrom.
|
|
//
|
|
#define COPY_FACE_PLANE 0x00000001 // Copies only the face's plane. Used for carving.
|
|
#define COPY_FACE_POINTS 0x00000002 // Copies the face's points and plane.
|
|
|
|
|
|
//
|
|
// Used for storing the extrema of a face. Each element of the Extents_t array
|
|
// contains a point that represents a local extreme along a particular dimension.
|
|
//
|
|
enum
|
|
{
|
|
EXTENTS_XMIN = 0,
|
|
EXTENTS_XMAX,
|
|
EXTENTS_YMIN,
|
|
EXTENTS_YMAX,
|
|
EXTENTS_ZMIN,
|
|
EXTENTS_ZMAX,
|
|
NUM_EXTENTS_DIMS,
|
|
};
|
|
|
|
typedef Vector Extents_t[NUM_EXTENTS_DIMS];
|
|
|
|
|
|
struct PLANE
|
|
{
|
|
Vector normal;
|
|
float dist;
|
|
Vector planepts[3];
|
|
};
|
|
|
|
|
|
typedef struct
|
|
{
|
|
int numpoints;
|
|
Vector *p; // variable sized
|
|
} winding_t;
|
|
|
|
|
|
enum FaceOrientation_t
|
|
{
|
|
FACE_ORIENTATION_FLOOR = 0,
|
|
FACE_ORIENTATION_CEILING,
|
|
FACE_ORIENTATION_NORTH_WALL,
|
|
FACE_ORIENTATION_SOUTH_WALL,
|
|
FACE_ORIENTATION_EAST_WALL,
|
|
FACE_ORIENTATION_WEST_WALL,
|
|
FACE_ORIENTATION_INVALID
|
|
};
|
|
|
|
|
|
//
|
|
// Both an enumeration and bitflags. Used as bitflags when querying a face for its texture
|
|
// alignment because it could be world aligned and face aligned at the same time.
|
|
//
|
|
enum TextureAlignment_t
|
|
{
|
|
TEXTURE_ALIGN_NONE = 0x0000,
|
|
TEXTURE_ALIGN_WORLD = 0x0001,
|
|
TEXTURE_ALIGN_FACE = 0x0002,
|
|
TEXTURE_ALIGN_QUAKE = 0x0004
|
|
};
|
|
|
|
|
|
enum TextureJustification_t
|
|
{
|
|
TEXTURE_JUSTIFY_NONE = 0,
|
|
TEXTURE_JUSTIFY_TOP,
|
|
TEXTURE_JUSTIFY_BOTTOM,
|
|
TEXTURE_JUSTIFY_LEFT,
|
|
TEXTURE_JUSTIFY_CENTER,
|
|
TEXTURE_JUSTIFY_RIGHT,
|
|
TEXTURE_JUSTIFY_FIT,
|
|
TEXTURE_JUSTIFY_MAX
|
|
};
|
|
|
|
|
|
#define INIT_TEXTURE_FORCE 0x0001
|
|
#define INIT_TEXTURE_AXES 0x0002
|
|
#define INIT_TEXTURE_ROTATION 0x0004
|
|
#define INIT_TEXTURE_SHIFT 0x0008
|
|
#define INIT_TEXTURE_SCALE 0x0010
|
|
#define INIT_TEXTURE_ALL (INIT_TEXTURE_AXES | INIT_TEXTURE_ROTATION | INIT_TEXTURE_SHIFT | INIT_TEXTURE_SCALE)
|
|
|
|
|
|
//
|
|
// Flags for CreateFace.
|
|
//
|
|
#define CREATE_FACE_PRESERVE_PLANE 0x0001 // Hack to prevent plane from being recalculated while building a solid from its planes.
|
|
#define CREATE_FACE_CLIPPING 0x0002
|
|
|
|
//
|
|
// Serialized data structure. Do not modify!
|
|
//
|
|
struct TEXTURE_21
|
|
{
|
|
char texture[MAX_PATH];
|
|
float rotate;
|
|
float shift[2];
|
|
float scale[2];
|
|
BYTE smooth;
|
|
BYTE material;
|
|
DWORD q2surface;
|
|
DWORD q2contents;
|
|
DWORD q2value;
|
|
};
|
|
|
|
|
|
//
|
|
// Post 2.1 explicit texture U/V axes were added.
|
|
//
|
|
// Serialized data structure. Do not modify!
|
|
//
|
|
struct TEXTURE_33
|
|
{
|
|
char texture[MAX_PATH];
|
|
float UAxis[4]; // Must remain float[4] for RMF serialization.
|
|
float VAxis[4]; // Must remain float[4] for RMF serialization.
|
|
float rotate;
|
|
float scale[2];
|
|
BYTE smooth;
|
|
BYTE material;
|
|
DWORD q2surface;
|
|
DWORD q2contents;
|
|
int nLightmapScale;
|
|
};
|
|
|
|
|
|
struct TEXTURE
|
|
{
|
|
char texture[MAX_PATH];
|
|
Vector4D UAxis;
|
|
Vector4D VAxis;
|
|
float rotate;
|
|
float scale[2];
|
|
BYTE smooth;
|
|
BYTE material;
|
|
DWORD q2surface;
|
|
DWORD q2contents;
|
|
int nLightmapScale;
|
|
|
|
TEXTURE& operator=( TEXTURE const& src )
|
|
{
|
|
// necessary since operator= is private for UAxis
|
|
memcpy( this, &src, sizeof(TEXTURE) );
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
|
|
#define FACE_FLAGS_NOSHADOW 1
|
|
#define FACE_FLAGS_NODRAW_IN_LPREVIEW 2
|
|
|
|
|
|
|
|
class CMapFace : public CMapAtom
|
|
{
|
|
public:
|
|
|
|
CMapFace(void);
|
|
~CMapFace(void);
|
|
|
|
// If bRescaleTextureCoordinates is true, then it will rescale and reoffset the texture coordinates
|
|
// so that the texture is in the same apparent spot as the old texture (if they are different sizes).
|
|
void SetTexture(const char *pszNewTex, bool bRescaleTextureCoordinates = false);
|
|
void SetTexture(IEditorTexture *pTexture, bool bRescaleTextureCoordinates = false);
|
|
void GetTextureName(char *pszName) const;
|
|
|
|
inline IEditorTexture *GetTexture(void) const;
|
|
|
|
// Renders opaque faces
|
|
static void AddFaceToQueue( CMapFace* pMapFace, IEditorTexture* pTexture, EditorRenderMode_t renderMode, bool selected, SelectionState_t faceSelectionState );
|
|
static void PushFaceQueue( void );
|
|
static void PopFaceQueue( void );
|
|
static void RenderOpaqueFaces( CRender3D* pRender );
|
|
|
|
//
|
|
// Serialization.
|
|
//
|
|
ChunkFileResult_t LoadVMF(CChunkFile *pFile);
|
|
ChunkFileResult_t SaveVMF(CChunkFile *pFile, CSaveInfo *pSaveInfo);
|
|
int SerializeRMF(std::fstream&, BOOL);
|
|
int SerializeMAP(std::fstream&, BOOL);
|
|
|
|
BOOL CheckFace(CCheckFaceInfo* = NULL);
|
|
BOOL Fix(void);
|
|
|
|
float GetNormalDistance(Vector& fPoint);
|
|
|
|
inline int GetPointCount(void);
|
|
inline void GetPoint(Vector& Point, int nPoint);
|
|
|
|
inline void GetLightmapCoord( Vector2D & LightmapCoord, int nIndex );
|
|
inline void SetLightmapCoord( const Vector2D &LightmapCoord, int nIndex );
|
|
inline void GetTexCoord( Vector2D & TexCoord, int nTexCoord );
|
|
|
|
// Texture alignment.
|
|
void GetCenter(Vector& Center);
|
|
FaceOrientation_t GetOrientation(void) const;
|
|
void RotateTextureAxes(float fDegrees);
|
|
void InitializeTextureAxes(TextureAlignment_t eAlignment, DWORD dwFlags);
|
|
void JustifyTexture(TextureJustification_t eJustification);
|
|
void JustifyTextureUsingExtents(TextureJustification_t eJustification, Extents_t Extents);
|
|
void GetFaceBounds(Vector& pfMins, Vector& pfMaxs) const;
|
|
void GetFaceExtents(Extents_t Extents) const;
|
|
void GetTextureExtents(Extents_t Extents, Vector2D & TopLeft, Vector2D & BottomRight) const;
|
|
int GetTextureAlignment(void) const;
|
|
void GetFaceTextureExtents(Vector2D & TopLeft, Vector2D & BottomRight) const;
|
|
|
|
void CalcTextureCoordAtPoint( const Vector& pt, Vector2D & texCoord );
|
|
void CalcLightmapCoordAtPoint( const Vector& pt, Vector2D & lightCoord );
|
|
|
|
// Returns the max lightmap size for this face
|
|
int MaxLightmapSize() const;
|
|
|
|
void NormalizeTextureShifts(void);
|
|
BOOL IsTextureAxisValid(void) const;
|
|
|
|
inline void SetCordonFace( bool bCordonFace );
|
|
inline bool IsCordonFace() const;
|
|
|
|
// Old code for setting up texture axes. Needed for backwards compatibility.
|
|
void InitializeQuakeStyleTextureAxes(Vector4D& UAxis, Vector4D& VAxis);
|
|
|
|
void CreateFace(Vector *pPoints, int nPoints, bool bIsCordonFace = false);
|
|
void CreateFace(winding_t *w, int nFlags = 0);
|
|
CMapFace *CopyFrom(const CMapFace *pFrom, DWORD dwFlags = COPY_FACE_POINTS, bool bUpdateDependencies = true );
|
|
size_t AllocatePoints(int nPoints);
|
|
|
|
void OnUndoRedo();
|
|
|
|
void CalcPlane(void);
|
|
void CalcPlaneFromFacePoints(void);
|
|
|
|
void CalcTextureCoords();
|
|
void OffsetTexture(const Vector &Delta);
|
|
void SetTextureCoords(int nPoint, float u, float v);
|
|
|
|
struct TangentSpaceAxes_t
|
|
{
|
|
Vector tangent;
|
|
Vector binormal;
|
|
};
|
|
|
|
void CalcTangentSpaceAxes( void );
|
|
bool AllocTangentSpaceAxes( int count );
|
|
void FreeTangentSpaceAxes( void );
|
|
|
|
void Render2D(CRender2D *pRender);
|
|
void Render3D(CRender3D *pRender);
|
|
void Render3DGrid(CRender3D *pRender);
|
|
void RenderVertices(CRender *pRender);
|
|
|
|
void OnAddToWorld(CMapWorld *pWorld);
|
|
void OnRemoveFromWorld(void);
|
|
|
|
static void SetShowSelection(bool bShowSelection);
|
|
|
|
inline void SetRenderAlpha(unsigned char uchAlpha) { m_uchAlpha = uchAlpha; } // HACK: should be in CMapAtom
|
|
|
|
inline void GetFaceNormal( Vector& normal );
|
|
bool TraceLine(Vector &HitPos, Vector &HitNormal, Vector const &Start, Vector const &End);
|
|
bool TraceLineInside( Vector &HitPos, Vector &HitNormal, Vector const &Start, Vector const &End, bool bNoDisp = false );
|
|
|
|
inline void SetDisp( EditDispHandle_t handle, bool bDestroyPrevious = true );
|
|
inline EditDispHandle_t GetDisp( void );
|
|
inline bool HasDisp( void ) const;
|
|
|
|
bool ShouldRenderLast();
|
|
void GetDownVector( int index, Vector& downVect );
|
|
|
|
bool GetRender2DBox( Vector& boundMin, Vector& boundMax );
|
|
bool GetCullBox( Vector& boundMin, Vector& boundMax );
|
|
size_t GetDataSize( void );
|
|
|
|
inline int GetFaceID(void);
|
|
inline void SetFaceID(int nFaceID);
|
|
|
|
// Smoothing group.
|
|
int SmoothingGroupCount( void );
|
|
void AddSmoothingGroup( int iGroup );
|
|
void RemoveSmoothingGroup( int iGroup );
|
|
bool InSmoothingGroup( int iGroup );
|
|
|
|
// Indicates this guy should be unlit
|
|
void RenderUnlit( bool enable );
|
|
|
|
// (begin serialized information
|
|
TEXTURE texture; // Texture info.
|
|
Vector *Points; // Array of face points, dynamically allocated.
|
|
int nPoints; // The number of points in the array.
|
|
// end serialized information)
|
|
|
|
PLANE plane;
|
|
|
|
int m_nFaceFlags; // FACE_FLAGS_xx
|
|
|
|
void DoTransform(const VMatrix &matrix);
|
|
|
|
virtual void AddShadowingTriangles( CUtlVector<Vector> &tri_list );
|
|
|
|
DetailObjects *m_pDetailObjects;
|
|
|
|
protected:
|
|
|
|
void ComputeColor( CRender3D* pRender, bool bRenderAsSelected, SelectionState_t faceSelectionState,
|
|
bool ignoreLighting, Color &pColor );
|
|
|
|
void DrawFace( Color &pColor, EditorRenderMode_t mode );
|
|
void RenderGridIfCloseEnough( CRender3D* pRender );
|
|
void RenderTextureAxes( CRender3D* pRender );
|
|
|
|
// Adds a face's vertices to the meshbuilder
|
|
void AddFaceVertices( CMeshBuilder &builder, CRender3D* pRender, bool bRenderSelected, SelectionState_t faceSelectionState );
|
|
|
|
// render texture axes
|
|
static void RenderTextureAxes( CRender3D* pRender, int nCount, CMapFace **ppFaces );
|
|
static void RenderGridsIfCloseEnough( CRender3D* pRender, int nCount, CMapFace **ppFaces );
|
|
static void Render3DGrids( CRender3D* pRender, int nCount, CMapFace **ppFaces );
|
|
static void RenderWireframeFaces( CRender3D* pRender, int nCount, MapFaceRender_t **ppFaces );
|
|
static void RenderFacesBatch( CMeshBuilder &MeshBuilder, IMesh* pMesh, CRender3D* pRender, MapFaceRender_t **ppFaces, int nFaceCount, int nVertexCount, int nIndexCount, bool bWireframe );
|
|
static void RenderFaces( CRender3D* pRender, int nCount, MapFaceRender_t **ppFaces );
|
|
|
|
void RenderFace3D( CRender3D* pRender, EditorRenderMode_t renderMode, bool renderSelected, SelectionState_t faceSelectionState );
|
|
|
|
//
|
|
// Serialization (chunk handlers).
|
|
//
|
|
static ChunkFileResult_t LoadDispInfoCallback(CChunkFile *pFile, CMapFace *pFace);
|
|
static ChunkFileResult_t LoadKeyCallback(const char *szKey, const char *szValue, LoadFace_t *pLoadFace);
|
|
|
|
unsigned char m_uchAlpha; // HACK: should be in CMapAtom
|
|
|
|
int m_nFaceID; // The unique ID of this face in the world.
|
|
|
|
IEditorTexture *m_pTexture; // Texture that is applied to this face.
|
|
static IEditorTexture *m_pLightmapGrid; // Lightmap grid texture for use in viewing lightmap scales.
|
|
EditDispHandle_t m_DispHandle; // Displacement map applied to this face, NULL if none.
|
|
|
|
static bool m_bShowFaceSelection; // Whether to render faces with a special color when they are selected.
|
|
|
|
Vector2D *m_pTextureCoords; // An array of texture coordinates, one per face point.
|
|
Vector2D *m_pLightmapCoords; // An array of lightmap coordinates, one per face point.
|
|
|
|
bool m_bIsCordonFace : 1;
|
|
|
|
// should this be affected by lighting?
|
|
bool m_bIgnoreLighting : 1;
|
|
|
|
TangentSpaceAxes_t *m_pTangentAxes;
|
|
|
|
unsigned int m_fSmoothingGroups; // 32-bits representing 32 smoothing groups
|
|
|
|
void UpdateFaceFlags( void ); // sniff face flags from texture
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns the unique ID of this face.
|
|
//-----------------------------------------------------------------------------
|
|
inline int CMapFace::GetFaceID(void)
|
|
{
|
|
return(m_nFaceID);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : TexCoord -
|
|
// nTexCoord -
|
|
//-----------------------------------------------------------------------------
|
|
inline void CMapFace::GetLightmapCoord( Vector2D& LightmapCoord, int nIndex )
|
|
{
|
|
Assert( nIndex < nPoints );
|
|
LightmapCoord[0] = m_pLightmapCoords[nIndex][0];
|
|
LightmapCoord[1] = m_pLightmapCoords[nIndex][1];
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : &LightmapCoord -
|
|
// nIndex -
|
|
// Output : inline void
|
|
//-----------------------------------------------------------------------------
|
|
inline void CMapFace::SetLightmapCoord( const Vector2D &LightmapCoord, int nIndex )
|
|
{
|
|
Assert( nIndex < nPoints );
|
|
m_pLightmapCoords[nIndex][0] = LightmapCoord[0];
|
|
m_pLightmapCoords[nIndex][1] = LightmapCoord[1];
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : TexCoord -
|
|
// nTexCoord -
|
|
//-----------------------------------------------------------------------------
|
|
inline void CMapFace::GetTexCoord( Vector2D& TexCoord, int nTexCoord )
|
|
{
|
|
Assert( nTexCoord < nPoints );
|
|
TexCoord[0] = m_pTextureCoords[nTexCoord][0];
|
|
TexCoord[1] = m_pTextureCoords[nTexCoord][1];
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns a pointer to the texture that is applied to this face, NULL if none.
|
|
//-----------------------------------------------------------------------------
|
|
inline IEditorTexture *CMapFace::GetTexture(void) const
|
|
{
|
|
return(m_pTexture);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns the number of vertices that define this face.
|
|
//-----------------------------------------------------------------------------
|
|
inline int CMapFace::GetPointCount(void)
|
|
{
|
|
return(nPoints);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Retrieves a point on this face by its index.
|
|
// Input : Point - Receives point coordinates.
|
|
// nPoint - Index of point to retrieve.
|
|
//-----------------------------------------------------------------------------
|
|
inline void CMapFace::GetPoint(Vector& Point, int nPoint)
|
|
{
|
|
Assert(nPoint < nPoints);
|
|
Point = Points[nPoint];
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
inline void CMapFace::GetFaceNormal( Vector& normal )
|
|
{
|
|
normal = plane.normal;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Sets the unique ID of this face.
|
|
//-----------------------------------------------------------------------------
|
|
inline void CMapFace::SetFaceID(int nID)
|
|
{
|
|
m_nFaceID = nID;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Attaches a displacement surface to this face.
|
|
// Input : handle - Displacement surface handle of surface attached to this face
|
|
//-----------------------------------------------------------------------------
|
|
inline void CMapFace::SetDisp( EditDispHandle_t handle, bool bDestroyPrevious )
|
|
{
|
|
if ( ( m_DispHandle != EDITDISPHANDLE_INVALID ) && bDestroyPrevious )
|
|
{
|
|
// destroy old handle
|
|
EditDispMgr()->Destroy( m_DispHandle );
|
|
}
|
|
|
|
Assert( ( handle == EDITDISPHANDLE_INVALID ) || ( EditDispMgr()->GetDisp( handle ) != NULL ) );
|
|
|
|
m_DispHandle = handle;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns the displacement surface applied to this face,
|
|
// DISPHANDLE_INVALID if none.
|
|
//-----------------------------------------------------------------------------
|
|
inline EditDispHandle_t CMapFace::GetDisp( void )
|
|
{
|
|
return m_DispHandle;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns true if this face has a displacement surface, false if not.
|
|
//-----------------------------------------------------------------------------
|
|
inline bool CMapFace::HasDisp( void ) const
|
|
{
|
|
return ( m_DispHandle != EDITDISPHANDLE_INVALID );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Whether this face belongs to a cordon brush.
|
|
//-----------------------------------------------------------------------------
|
|
inline void CMapFace::SetCordonFace( bool bCordonFace )
|
|
{
|
|
m_bIsCordonFace = bCordonFace;
|
|
}
|
|
|
|
|
|
inline bool CMapFace::IsCordonFace() const
|
|
{
|
|
return m_bIsCordonFace;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Defines a container class for a list of face pointers.
|
|
//-----------------------------------------------------------------------------
|
|
class CMapFaceList : public CUtlVector<CMapFace *>
|
|
{
|
|
public:
|
|
|
|
inline CMapFaceList(void) {}
|
|
inline CMapFaceList(CMapFaceList const &other);
|
|
inline CMapFaceList &CMapFaceList::operator =(CMapFaceList const &other);
|
|
|
|
inline int FindFaceID(int nFaceID);
|
|
void Intersect(CMapFaceList &IntersectWith, CMapFaceList &In, CMapFaceList &Out);
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Copy constructor.
|
|
//-----------------------------------------------------------------------------
|
|
CMapFaceList::CMapFaceList(CMapFaceList const &other)
|
|
{
|
|
*this = other;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Assignment operator for copying face lists.
|
|
// Input : other -
|
|
//-----------------------------------------------------------------------------
|
|
CMapFaceList &CMapFaceList::operator =(CMapFaceList const &other)
|
|
{
|
|
AddVectorToTail(other);
|
|
return *this;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Searches the list for a face with the given ID.
|
|
// Input : nFaceID - Numeric face ID to search for.
|
|
// Output : Index of found element, -1 if none.
|
|
//-----------------------------------------------------------------------------
|
|
int CMapFaceList::FindFaceID(int nFaceID)
|
|
{
|
|
for (int i = 0; i < Count(); i++)
|
|
{
|
|
if ((Element(i) != NULL) && (Element(i)->GetFaceID() == nFaceID))
|
|
{
|
|
return(i);
|
|
}
|
|
}
|
|
|
|
return(-1);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Defines a container class for a list of face IDs.
|
|
//-----------------------------------------------------------------------------
|
|
class CMapFaceIDList : public CUtlVector<int>
|
|
{
|
|
public:
|
|
|
|
inline CMapFaceIDList(void) {}
|
|
inline CMapFaceIDList(CMapFaceIDList const &other);
|
|
inline CMapFaceIDList &CMapFaceIDList::operator =(CMapFaceIDList const &other);
|
|
|
|
void Intersect(CMapFaceIDList &IntersectWith, CMapFaceIDList &In, CMapFaceIDList &Out);
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Copy constructor.
|
|
//-----------------------------------------------------------------------------
|
|
CMapFaceIDList::CMapFaceIDList(CMapFaceIDList const &other)
|
|
{
|
|
*this = other;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Assignment operator for copying face ID lists.
|
|
// Input : other -
|
|
//-----------------------------------------------------------------------------
|
|
CMapFaceIDList &CMapFaceIDList::operator =(CMapFaceIDList const &other)
|
|
{
|
|
AddVectorToTail(other);
|
|
return *this;
|
|
}
|
|
|
|
|
|
#endif // MAPFACE_H
|