Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
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.
 
 
 
 
 
 

1460 lines
51 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $Workfile: $
// $Date: $
// $NoKeywords: $
//=============================================================================//
#ifndef BUILDDISP_H
#define BUILDDISP_H
#ifdef _WIN32
#pragma once
#endif
#include "commonmacros.h"
#include "tier0/dbg.h"
#include "bspfile.h"
#include "mathlib/mathlib.h"
#include "mathlib/bumpvects.h"
#include "disp_common.h"
#include "bitvec.h"
#define DISP_ALPHA_PROP_DELTA 382.5f
class CCoreDispInfo;
struct CoreDispBBox_t
{
Vector vMin, vMax;
};
//=========================================================================
//
// Surface Class - interfacing class (fill in with MapFace, dface_t, and
// msurface_t)
//
class CCoreDispSurface
{
public:
enum { QUAD_POINT_COUNT = 4 };
enum { MAX_CORNER_NEIGHBOR_COUNT = 16 };
CCoreDispSurface();
//=========================================================================
//
// initialization
//
void Init( void );
//=========================================================================
//
// parent surface id - index to CMapFace, dface_t, or msurface_t
//
inline void SetHandle( int handle );
inline int GetHandle( void );
//=========================================================================
//
// vertex data - pos, normal, texture, lightmap, alpha, etc...
//
inline void SetPointCount( int count );
inline int GetPointCount( void ) const;
inline void SetPoint( int index, Vector const &pt );
inline void GetPoint( int index, Vector& pt ) const;
inline Vector const& GetPoint( int index ) const;
inline void SetPointNormal( int index, Vector const &normal );
inline void GetPointNormal( int index, Vector &normal );
inline void SetTexCoord( int index, Vector2D const& texCoord );
inline void GetTexCoord( int index, Vector2D& texCoord ) const;
inline void SetLuxelCoord( int bumpIndex, int index, Vector2D const& luxelCoord );
inline void GetLuxelCoord( int bumpIndex, int index, Vector2D& luxelCoord ) const;
inline void SetLuxelCoords( int bumpIndex, Vector2D const coords[4] );
inline void GetLuxelCoords( int bumpIndex, Vector2D coords[4] ) const;
inline void SetLuxelU( int nU ) { m_nLuxelU = nU; }
inline int GetLuxelU( void ) { return m_nLuxelU; }
inline void SetLuxelV( int nV ) { m_nLuxelV = nV; }
inline int GetLuxelV( void ) { return m_nLuxelV; }
bool CalcLuxelCoords( int nLuxels, bool bAdjust, const Vector &vecU, const Vector &vecV );
inline void SetAlpha( int index, float alpha );
inline float GetAlpha( int const index ) const;
//=========================================================================
//
// utils
//
inline void GetNormal( Vector& normal );
inline void SetFlags( int flag );
inline int GetFlags( void );
inline void SetContents( int contents );
inline int GetContents( void );
//=========================================================================
//
// create utils (texture axis not use anymore but here to support older maps)
//
inline void SetSAxis( Vector const &axis );
inline void GetSAxis( Vector &axis );
inline void SetTAxis( Vector const &axis );
inline void GetTAxis( Vector &axis );
inline void SetPointStartIndex( int index );
inline int GetPointStartIndex( void );
inline void SetPointStart( Vector const &pt );
inline void GetPointStart( Vector &pt );
// Used by the tools to set the neighbor data from the BSP file.
void SetNeighborData( const CDispNeighbor edgeNeighbors[4], const CDispCornerNeighbors cornerNeighbors[4] );
void GeneratePointStartIndexFromMappingAxes( Vector const &sAxis, Vector const &tAxis );
int GenerateSurfPointStartIndex( void );
int FindSurfPointStartIndex( void );
void AdjustSurfPointData( void );
// Indexed by CORNER_ defines.
CDispCornerNeighbors* GetCornerNeighbors( int iCorner ) { Assert( iCorner >= 0 && iCorner < ARRAYSIZE( m_CornerNeighbors ) ); return &m_CornerNeighbors[iCorner]; }
const CDispCornerNeighbors* GetCornerNeighbors( int iCorner ) const { Assert( iCorner >= 0 && iCorner < ARRAYSIZE( m_CornerNeighbors ) ); return &m_CornerNeighbors[iCorner]; }
// Indexed by CORNER_ defines.
int GetCornerNeighborCount( int iCorner ) const { return GetCornerNeighbors( iCorner )->m_nNeighbors; }
int GetCornerNeighbor( int iCorner, int iNeighbor ) const { Assert( iNeighbor >= 0 && iNeighbor < GetCornerNeighbors(iCorner)->m_nNeighbors ); return GetCornerNeighbors( iCorner )->m_Neighbors[iNeighbor]; }
CDispNeighbor* GetEdgeNeighbor( int iEdge ) { Assert( iEdge >= 0 && iEdge < ARRAYSIZE( m_EdgeNeighbors ) ); return &m_EdgeNeighbors[iEdge]; }
const CDispNeighbor* GetEdgeNeighbor( int iEdge ) const { Assert( iEdge >= 0 && iEdge < ARRAYSIZE( m_EdgeNeighbors ) ); return &m_EdgeNeighbors[iEdge]; }
protected:
// Utility
bool LongestInU( const Vector &vecU, const Vector &vecV );
int m_Index; // parent face (CMapFace, dface_t, msurface_t) index "handle"
int m_PointCount; // number of points in the face (should be 4!)
Vector m_Points[QUAD_POINT_COUNT]; // points
Vector m_Normals[QUAD_POINT_COUNT]; // normals at points
Vector2D m_TexCoords[QUAD_POINT_COUNT]; // texture coordinates at points
Vector2D m_LuxelCoords[NUM_BUMP_VECTS+1][QUAD_POINT_COUNT]; // lightmap coordinates at points
float m_Alphas[QUAD_POINT_COUNT]; // alpha at points
// Luxels sizes
int m_nLuxelU;
int m_nLuxelV;
// Straight from the BSP file.
CDispNeighbor m_EdgeNeighbors[4];
CDispCornerNeighbors m_CornerNeighbors[4];
int m_Flags; // surface flags - inherited from the "parent" face
int m_Contents; // contents flags - inherited from the "parent" face
Vector sAxis; // used to generate start disp orientation (old method)
Vector tAxis; // used to generate start disp orientation (old method)
int m_PointStartIndex; // index to the starting point -- for saving starting point
Vector m_PointStart; // starting point used to determine the orientation of the displacement map on the surface
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetHandle( int handle )
{
m_Index = handle;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CCoreDispSurface::GetHandle( void )
{
return m_Index;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetPointCount( int count )
{
// quad only -- currently!
if( count != 4 )
return;
m_PointCount = count;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CCoreDispSurface::GetPointCount( void ) const
{
return m_PointCount;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetPoint( int index, Vector const &pt )
{
Assert( index >= 0 );
Assert( index < QUAD_POINT_COUNT );
VectorCopy( pt, m_Points[index] );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::GetPoint( int index, Vector &pt ) const
{
Assert( index >= 0 );
Assert( index < QUAD_POINT_COUNT );
VectorCopy( m_Points[index], pt );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline Vector const& CCoreDispSurface::GetPoint( int index ) const
{
Assert( index >= 0 );
Assert( index < QUAD_POINT_COUNT );
return m_Points[index];
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetPointNormal( int index, Vector const &normal )
{
Assert( index >= 0 );
Assert( index < QUAD_POINT_COUNT );
VectorCopy( normal, m_Normals[index] );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::GetPointNormal( int index, Vector& normal )
{
Assert( index >= 0 );
Assert( index < QUAD_POINT_COUNT );
VectorCopy( m_Normals[index], normal );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetTexCoord( int index, Vector2D const& texCoord )
{
Assert( index >= 0 );
Assert( index < QUAD_POINT_COUNT );
Vector2DCopy( texCoord, m_TexCoords[index] );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::GetTexCoord( int index, Vector2D& texCoord ) const
{
Assert( index >= 0 );
Assert( index < QUAD_POINT_COUNT );
Vector2DCopy( m_TexCoords[index], texCoord );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetLuxelCoord( int bumpIndex, int index, Vector2D const& luxelCoord )
{
Assert( index >= 0 );
Assert( index < QUAD_POINT_COUNT );
Assert( bumpIndex >= 0 );
Assert( bumpIndex < NUM_BUMP_VECTS + 1 );
Vector2DCopy( luxelCoord, m_LuxelCoords[bumpIndex][index] );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::GetLuxelCoord( int bumpIndex, int index, Vector2D& luxelCoord ) const
{
Assert( index >= 0 );
Assert( index < QUAD_POINT_COUNT );
Assert( bumpIndex >= 0 );
Assert( bumpIndex < NUM_BUMP_VECTS + 1 );
Vector2DCopy( m_LuxelCoords[bumpIndex][index], luxelCoord );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetLuxelCoords( int bumpIndex, Vector2D const luxelCoords[4] )
{
Assert( bumpIndex >= 0 );
Assert( bumpIndex < NUM_BUMP_VECTS + 1 );
for( int i=0; i < 4; i++ )
Vector2DCopy( luxelCoords[i], m_LuxelCoords[bumpIndex][i] );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::GetLuxelCoords( int bumpIndex, Vector2D luxelCoords[4] ) const
{
Assert( bumpIndex >= 0 );
Assert( bumpIndex < NUM_BUMP_VECTS + 1 );
for( int i=0; i < 4; i++ )
Vector2DCopy( m_LuxelCoords[bumpIndex][i], luxelCoords[i] );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetAlpha( int index, float alpha )
{
Assert( index >= 0 );
Assert( index < QUAD_POINT_COUNT );
m_Alphas[index] = alpha;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline float CCoreDispSurface::GetAlpha( int const index ) const
{
Assert( index >= 0 );
Assert( index < QUAD_POINT_COUNT );
return m_Alphas[index];
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetFlags( int flag )
{
m_Flags = flag;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CCoreDispSurface::GetFlags( void )
{
return m_Flags;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetContents( int contents )
{
m_Contents = contents;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CCoreDispSurface::GetContents( void )
{
return m_Contents;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetSAxis( Vector const &axis )
{
VectorCopy( axis, sAxis );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::GetSAxis( Vector& axis )
{
VectorCopy( sAxis, axis );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetTAxis( Vector const &axis )
{
VectorCopy( axis, tAxis );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::GetTAxis( Vector& axis )
{
VectorCopy( tAxis, axis );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetPointStartIndex( int index )
{
Assert( index >= 0 );
Assert( index < QUAD_POINT_COUNT );
m_PointStartIndex = index;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CCoreDispSurface::GetPointStartIndex( void )
{
return m_PointStartIndex;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::SetPointStart( Vector const& pt )
{
VectorCopy( pt, m_PointStart );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::GetPointStart( Vector& pt )
{
VectorCopy( m_PointStart, pt );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispSurface::GetNormal( Vector& normal )
{
//
// calculate the displacement surface normal
//
Vector tmp[2];
VectorSubtract( m_Points[1], m_Points[0], tmp[0] );
VectorSubtract( m_Points[3], m_Points[0], tmp[1] );
CrossProduct( tmp[1], tmp[0], normal );
VectorNormalize( normal );
}
//=========================================================================
//
// Node Class (for displacement quad-tree)
//
class CCoreDispNode
{
public:
enum { MAX_NEIGHBOR_NODE_COUNT = 4 };
enum { MAX_NEIGHBOR_VERT_COUNT = 8 };
enum { MAX_SURF_AT_NODE_COUNT = 8 };
//=========================================================================
//
// Initialization
//
void Init( void );
//=========================================================================
//
//
//
inline void SetBoundingBox( Vector const& bMin, Vector const& bMax );
inline void GetBoundingBox( Vector& bMin, Vector& bMax );
inline void SetErrorTerm( float errorTerm );
inline float GetErrorTerm( void );
inline void SetNeighborNodeIndex( int dir, int index );
inline int GetNeighborNodeIndex( int dir );
inline void SetCenterVertIndex( int index );
inline int GetCenterVertIndex( void );
inline void SetNeighborVertIndex( int dir, int index );
inline int GetNeighborVertIndex( int dir );
inline void SetTriBoundingBox( int index, Vector const& bMin, Vector const& bMax );
inline void GetTriBoundingBox( int index, Vector& bMin, Vector& bMax );
inline void SetTriPlane( int index, Vector const& normal, float dist );
inline void GetTriPlane( int index, cplane_t *plane );
inline void SetRayBoundingBox( int index, Vector const& bMin, Vector const& bMax );
inline void GetRayBoundingBox( int index, Vector& bMin, Vector& bMax );
//=========================================================================
//
// Node Functions (friend functions)
//
friend int GetNodeLevel( int index );
friend int GetNodeCount( int power );
friend int GetNodeParent( int index );
friend int GetNodeChild( int power, int index, int direction );
friend int GetNodeNeighborNode( int power, int index, int direction, int level );
friend int GetNodeNeighborNodeFromNeighborSurf( int power, int index, int direction, int level, int neighborOrient );
friend int GetNodeMinNodeAtLevel( int level );
friend void GetDispNodeTriVerts( CCoreDispInfo *pDisp, int nodeIndex, int triIndex, float *v1, float *v2, float *v3 );
friend void GetComponentsFromNodeIndex( int index, int *x, int *y );
friend int GetNodeIndexFromComponents( int x, int y );
protected:
Vector m_BBox[2]; // displacement node bounding box (take into account size of children)
float m_ErrorTerm; // LOD error term (the "precision" of the representation of the surface at this node's level)
int m_VertIndex; // the node's vertex index (center vertex of node)
int m_NeighborVertIndices[MAX_NEIGHBOR_VERT_COUNT]; // all other vertex indices in node (maximally creates 8 trianglar surfaces)
Vector m_SurfBBoxes[MAX_SURF_AT_NODE_COUNT][2]; // surface bounding boxes - old method
cplane_t m_SurfPlanes[MAX_SURF_AT_NODE_COUNT]; // surface plane info - old method
Vector m_RayBBoxes[4][2]; // bounding boxes for ray traces
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispNode::SetBoundingBox( Vector const& bMin, Vector const& bMax )
{
VectorCopy( bMin, m_BBox[0] );
VectorCopy( bMax, m_BBox[1] );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispNode::GetBoundingBox( Vector& bMin, Vector& bMax )
{
VectorCopy( m_BBox[0], bMin );
VectorCopy( m_BBox[1], bMax );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispNode::SetErrorTerm( float errorTerm )
{
m_ErrorTerm = errorTerm;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline float CCoreDispNode::GetErrorTerm( void )
{
return m_ErrorTerm;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispNode::SetCenterVertIndex( int index )
{
m_VertIndex = index;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CCoreDispNode::GetCenterVertIndex( void )
{
return m_VertIndex;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispNode::SetNeighborVertIndex( int dir, int index )
{
Assert( dir >= 0 );
Assert( dir < MAX_NEIGHBOR_VERT_COUNT );
m_NeighborVertIndices[dir] = index;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CCoreDispNode::GetNeighborVertIndex( int dir )
{
Assert( dir >= 0 );
Assert( dir < MAX_NEIGHBOR_VERT_COUNT );
return m_NeighborVertIndices[dir];
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispNode::SetTriBoundingBox( int index, Vector const& bMin, Vector const& bMax )
{
Assert( index >= 0 );
Assert( index < MAX_SURF_AT_NODE_COUNT );
VectorCopy( bMin, m_SurfBBoxes[index][0] );
VectorCopy( bMax, m_SurfBBoxes[index][1] );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispNode::GetTriBoundingBox( int index, Vector& bMin, Vector& bMax )
{
Assert( index >= 0 );
Assert( index < MAX_SURF_AT_NODE_COUNT );
VectorCopy( m_SurfBBoxes[index][0], bMin );
VectorCopy( m_SurfBBoxes[index][1], bMax );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispNode::SetTriPlane( int index, Vector const &normal, float dist )
{
Assert( index >= 0 );
Assert( index < MAX_SURF_AT_NODE_COUNT );
VectorCopy( normal, m_SurfPlanes[index].normal );
m_SurfPlanes[index].dist = dist;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispNode::GetTriPlane( int index, cplane_t *plane )
{
Assert( index >= 0 );
Assert( index < MAX_SURF_AT_NODE_COUNT );
VectorCopy( m_SurfPlanes[index].normal, plane->normal );
plane->dist = m_SurfPlanes[index].dist;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispNode::SetRayBoundingBox( int index, Vector const &bMin, Vector const &bMax )
{
Assert( index >= 0 );
Assert( index < 4 );
VectorCopy( bMin, m_RayBBoxes[index][0] );
VectorCopy( bMax, m_RayBBoxes[index][1] );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispNode::GetRayBoundingBox( int index, Vector& bMin, Vector& bMax )
{
Assert( index >= 0 );
Assert( index < 4 );
VectorCopy( m_RayBBoxes[index][0], bMin );
VectorCopy( m_RayBBoxes[index][1], bMax );
}
//=============================================================================
//
// CCoreInfoBuilder - the primary data necessay to derive a displacement surface
// used by WorldCraft (CMapFace, CMapDisp), VRAD (dface_t, ddispinto_t),
// and the engine (msurface_t, CDispInfo)
//
struct CoreDispVert_t
{
Vector m_FieldVector; // displacement vector field
float m_FieldDistance; // the distances along the displacement vector normal
Vector m_SubdivNormal;
Vector m_SubdivPos; // used the create curvature of displacements
// generated displacement surface data
Vector m_Vert; // displacement surface vertices
Vector m_FlatVert;
Vector m_Normal; // displacement surface normals
Vector m_TangentS; // use in calculating the tangent space axes
Vector m_TangentT; // use in calculating the tangent space axes
Vector2D m_TexCoord; // displacement surface texture coordinates
Vector2D m_LuxelCoords[NUM_BUMP_VECTS+1]; // displacement surface lightmap coordinates
// additional per-vertex data
float m_Alpha; // displacement alpha values (per displacement vertex)
};
// New, need to use this at the node level
#define COREDISPTRI_TAG_WALKABLE (1<<0)
#define COREDISPTRI_TAG_FORCE_WALKABLE_BIT (1<<1)
#define COREDISPTRI_TAG_FORCE_WALKABLE_VAL (1<<2)
#define COREDISPTRI_TAG_BUILDABLE (1<<3)
#define COREDISPTRI_TAG_FORCE_BUILDABLE_BIT (1<<4)
#define COREDISPTRI_TAG_FORCE_BUILDABLE_VAL (1<<5)
#define COREDISPTRI_TAG_FORCE_REMOVE_BIT (1<<6)
struct CoreDispTri_t
{
unsigned short m_iIndex[3]; // the three indices that make up a triangle
unsigned short m_uiTags; // walkable, buildable, etc.
};
class CCoreDispInfo : public CDispUtilsHelper
{
public:
//
// tree and displacement surface directions
//
enum { WEST = 0,
NORTH = 1,
EAST = 2,
SOUTH = 3,
SOUTHWEST = 4,
SOUTHEAST = 5,
NORTHWEST = 6,
NORTHEAST = 7 };
#if 0
//
// building parameters
//
enum { BUILD_NORMALS = 0x1,
BUILD_TEXCOORDS = 0x2,
BUILD_LIGHTCOORDS = 0x4,
BUILD_LODTREE = 0x8,
BUILD_COLLISION = 0x10,
BUILD_TANGENTSPACE = 0x20 };
#endif
//
// surface info flags
//
enum { SURF_BUMPED = 0x1,
SURF_NOPHYSICS_COLL = 0x2,
SURF_NOHULL_COLL = 0x4,
SURF_NORAY_COLL = 0x8 };
enum { MAX_DISP_POWER = MAX_MAP_DISP_POWER };
enum { MAX_VERT_COUNT = MAX_DISPVERTS };
enum { MAX_NODE_COUNT = 85 };
// Convert from a CDispUtilsHelper.
public:
static CCoreDispInfo* FromDispUtils( CDispUtilsHelper *p ) { return (CCoreDispInfo*)p; }
// CDispUtilsHelper implementation.
public:
virtual CDispNeighbor* GetEdgeNeighbor( int index );
virtual CDispCornerNeighbors* GetCornerNeighbors( int index );
virtual const CPowerInfo* GetPowerInfo() const;
virtual CDispUtilsHelper* GetDispUtilsByIndex( int index );
public:
//=========================================================================
//
// Creation/Destruction
//
CCoreDispInfo();
~CCoreDispInfo();
void InitSurf( int parentIndex, Vector points[4], Vector normals[4],
Vector2D texCoords[4], Vector2D lightCoords[4][4], int contents, int flags,
bool bGenerateSurfPointStart, Vector& startPoint,
bool bHasMappingAxes, Vector& uAxis, Vector& vAxis );
void InitDispInfo( int power, int minTess, float smoothingAngle,
float *alphas, Vector *dispVectorField, float *dispDistances );
// This just unpacks the contents of the verts into arrays and calls InitDispInfo.
void InitDispInfo( int power, int minTess, float smoothingAngle, const CDispVert *pVerts, const CDispTri *pTris );
// bool Create( int creationFlags );
bool Create( void );
bool CreateWithoutLOD( void );
//=========================================================================
//
// Parameter "Wrappers"
//
CCoreDispSurface* GetSurface() { return &m_Surf; }
const CCoreDispSurface* GetSurface() const { return &m_Surf; }
inline CCoreDispNode *GetNode( int index );
inline void SetPower( int power );
inline int GetPower( void ) const;
inline int GetPostSpacing( void );
inline int GetWidth( void );
inline int GetHeight( void );
inline int GetSize( void ) const;
// Use this disp as a CDispUtils.
void SetDispUtilsHelperInfo( CCoreDispInfo **ppListBase, int listSize );
void SetNeighborData( const CDispNeighbor edgeNeighbors[4], const CDispCornerNeighbors cornerNeighbors[4] ) { GetSurface()->SetNeighborData( edgeNeighbors, cornerNeighbors ); }
// Get a corner point. Indexed by the CORNER_ defines.
const CVertIndex& GetCornerPointIndex( int index ) const { return GetPowerInfo()->GetCornerPointIndex( index ); }
const Vector& GetCornerPoint( int index ) const { return GetVert( VertIndexToInt( GetCornerPointIndex( index ) ) ); }
inline void SetVert( int index, Vector const& vert );
inline void GetVert( int index, Vector& vert ) const;
inline const Vector& GetVert( int index ) const;
inline const Vector& GetVert( const CVertIndex &index ) const;
inline void GetFlatVert( int index, Vector& vert ) const;
inline void SetFlatVert( int index, const Vector &vert );
inline void GetNormal( int index, Vector& normal ) const;
inline const Vector& GetNormal( int index ) const;
inline const Vector& GetNormal( const CVertIndex &index ) const;
inline void SetNormal( int index, Vector const& normal );
inline void SetNormal( const CVertIndex &index, Vector const& normal );
inline void GetTangentS( int index, Vector& tangentS ) const;
inline const Vector &GetTangentS( int index ) const;
inline const Vector &GetTangentS( const CVertIndex &index ) const { return GetTangentS(VertIndexToInt(index)); }
inline void GetTangentT( int index, Vector& tangentT ) const;
inline void SetTangentS( int index, Vector const& vTangentS ) { m_pVerts[index].m_TangentS = vTangentS; }
inline void SetTangentT( int index, Vector const& vTangentT ) { m_pVerts[index].m_TangentT = vTangentT; }
inline void SetTexCoord( int index, Vector2D const& texCoord );
inline void GetTexCoord( int index, Vector2D& texCoord ) const;
inline void SetLuxelCoord( int bumpIndex, int index, Vector2D const& luxelCoord );
inline void GetLuxelCoord( int bumpIndex, int index, Vector2D& luxelCoord ) const;
inline void SetAlpha( int index, float alpha );
inline float GetAlpha( int index );
int GetTriCount( void );
void GetTriIndices( int iTri, unsigned short &v1, unsigned short &v2, unsigned short &v3 );
void SetTriIndices( int iTri, unsigned short v1, unsigned short v2, unsigned short v3 );
void GetTriPos( int iTri, Vector &v1, Vector &v2, Vector &v3 );
inline void SetTriTag( int iTri, unsigned short nTag ) { m_pTris[iTri].m_uiTags |= nTag; }
inline void ResetTriTag( int iTri, unsigned short nTag ) { m_pTris[iTri].m_uiTags &= ~nTag; }
inline void ToggleTriTag( int iTri, unsigned short nTag ) { m_pTris[iTri].m_uiTags ^= nTag; }
inline bool IsTriTag( int iTri, unsigned short nTag ) { return ( ( m_pTris[iTri].m_uiTags & nTag ) != 0 ); }
inline unsigned short GetTriTagValue( int iTri ) { return m_pTris[iTri].m_uiTags; }
inline void SetTriTagValue( int iTri, unsigned short nVal ) { m_pTris[iTri].m_uiTags = nVal; }
bool IsTriWalkable( int iTri );
bool IsTriBuildable( int iTri );
bool IsTriRemove( int iTri );
inline void SetElevation( float elevation );
inline float GetElevation( void );
inline void ResetFieldVectors( void );
inline void SetFieldVector( int index, Vector const &v );
inline void GetFieldVector( int index, Vector& v );
inline void ResetFieldDistances( void );
inline void SetFieldDistance( int index, float dist );
inline float GetFieldDistance( int index );
inline void ResetSubdivPositions( void );
inline void SetSubdivPosition( int ndx, Vector const &v );
inline void GetSubdivPosition( int ndx, Vector& v );
inline void ResetSubdivNormals( void );
inline void SetSubdivNormal( int ndx, Vector const &v );
inline void GetSubdivNormal( int ndx, Vector &v );
inline void SetRenderIndexCount( int count );
inline int GetRenderIndexCount( void );
inline void SetRenderIndex( int index, int triIndex );
inline int GetRenderIndex( int index );
inline CoreDispVert_t *GetDispVert( int iVert ) { return &m_pVerts[iVert]; }
inline CoreDispVert_t *GetDispVertList();
inline unsigned short *GetRenderIndexList( void );
inline void SetTouched( bool touched );
inline bool IsTouched( void );
void CalcDispSurfCoords( bool bLightMap, int lightmapID );
void GetPositionOnSurface( float u, float v, Vector &vPos, Vector *pNormal, float *pAlpha );
void DispUVToSurf( Vector2D const &dispUV, Vector &vecPoint, Vector *pNormal, float *pAlpha );
void BaseFacePlaneToDispUV( Vector const &planePt, Vector2D &dispUV );
bool SurfToBaseFacePlane( Vector const &surfPt, Vector &planePt );
const CDispCornerNeighbors* GetCornerNeighbors( int iCorner ) const { return GetSurface()->GetCornerNeighbors( iCorner ); }
const CDispNeighbor* GetEdgeNeighbor( int iEdge ) const { return GetSurface()->GetEdgeNeighbor( iEdge ); }
void SetListIndex( int nIndex ) { m_nListIndex = nIndex; }
int GetListIndex( void ) { return m_nListIndex; }
CBitVec<MAX_DISPVERTS>& GetAllowedVerts() { return m_AllowedVerts; }
const CBitVec<MAX_DISPVERTS>& GetAllowedVerts() const { return m_AllowedVerts; }
void AllowedVerts_Clear( void ) { m_AllowedVerts.SetAll(); }
int AllowedVerts_GetNumDWords() const { return m_AllowedVerts.GetNumDWords(); }
unsigned long AllowedVerts_GetDWord(int i) const { return m_AllowedVerts.GetDWord( i ); }
void AllowedVerts_SetDWord(int i, unsigned long val) { m_AllowedVerts.SetDWord( i, val ); }
void Position_Update( int iVert, Vector vecPos );
//=========================================================================
//
// friend functions
//
friend void SmoothNeighboringDispSurfNormals( CCoreDispInfo **ppCoreDispInfoList, int listSize );
private:
// be changed to match the paint normal next pass)
// LOD/collision node data
CCoreDispNode *m_Nodes; // LOD quad-tree nodes
float m_Elevation; // distance along the subdivision normal (should
// defines the size of the displacement surface
int m_Power; // "size" of the displacement map
// base surface data
CCoreDispSurface m_Surf; // surface containing displacement data
// be changed to match the paint normal next pass)
// Vertex data..
CoreDispVert_t *m_pVerts;
// Triangle data..
CoreDispTri_t *m_pTris;
// render specific data
int m_RenderIndexCount; // number of indices used in rendering
unsigned short *m_RenderIndices; // rendering index list (list of triangles)
int m_RenderCounter; // counter to verify surfaces are renderered/collided with only once per frame
// utility data
bool m_bTouched; // touched flag
CCoreDispInfo *m_pNext; // used for chaining
// The list that this disp is in (used for CDispUtils::IHelper implementation).
CCoreDispInfo **m_ppListBase;
int m_ListSize;
CBitVec<MAX_DISPVERTS> m_AllowedVerts; // Built in VBSP. Defines which verts are allowed to exist based on what the neighbors are.
int m_nListIndex;
//=========================================================================
//
// Creation Functions
//
void GenerateDispSurf( void );
void GenerateDispSurfNormals( void );
void GenerateDispSurfTangentSpaces( void );
bool DoesEdgeExist( int indexRow, int indexCol, int direction, int postSpacing );
void CalcNormalFromEdges( int indexRow, int indexCol, bool bIsEdge[4], Vector& normal );
void CalcDispSurfAlphas( void );
void GenerateLODTree( void );
void CalcVertIndicesAtNodes( int nodeIndex );
int GetNodeVertIndexFromParentIndex( int level, int parentVertIndex, int direction );
void CalcNodeInfo( int nodeIndex, int terminationLevel );
void CalcNeighborVertIndicesAtNode( int nodeIndex, int level );
void CalcNeighborNodeIndicesAtNode( int nodeIndex, int level );
void CalcErrorTermAtNode( int nodeIndex, int level );
float GetMaxErrorFromChildren( int nodeIndex, int level );
void CalcBoundingBoxAtNode( int nodeIndex );
void CalcMinMaxBoundingBoxAtNode( int nodeIndex, Vector& bMin, Vector& bMax );
void CalcTriSurfInfoAtNode( int nodeIndex );
void CalcTriSurfIndices( int nodeIndex, int indices[8][3] );
void CalcTriSurfBoundingBoxes( int nodeIndex, int indices[8][3] );
void CalcRayBoundingBoxes( int nodeIndex, int indices[8][3] );
void CalcTriSurfPlanes( int nodeIndex, int indices[8][3] );
void GenerateCollisionData( void );
void GenerateCollisionSurface( void );
void CreateBoundingBoxes( CoreDispBBox_t *pBBox, int count );
void DispUVToSurf_TriTLToBR( Vector &vecPoint, Vector *pNormal, float *pAlpha, float flU, float flV, const Vector &vecIntersectPoint );
void DispUVToSurf_TriBLToTR( Vector &vecPoint, Vector *pNormal, float *pAlpha, float flU, float flV, const Vector &vecIntersectPoint );
void DispUVToSurf_TriTLToBR_1( const Vector &vecIntersectPoint, int nSnapU, int nNextU, int nSnapV, int nNextV, Vector &vecPoint, Vector *pNormal, float *pAlpha, bool bBackup );
void DispUVToSurf_TriTLToBR_2( const Vector &vecIntersectPoint, int nSnapU, int nNextU, int nSnapV, int nNextV, Vector &vecPoint, Vector *pNormal, float *pAlpha, bool bBackup );
void DispUVToSurf_TriBLToTR_1( const Vector &vecIntersectPoint, int nSnapU, int nNextU, int nSnapV, int nNextV, Vector &vecPoint, Vector *pNormal, float *pAlpha, bool bBackup );
void DispUVToSurf_TriBLToTR_2( const Vector &vecIntersectPoint, int nSnapU, int nNextU, int nSnapV, int nNextV, Vector &vecPoint, Vector *pNormal, float *pAlpha, bool bBackup );
void GetTriangleIndicesForDispBBox( int nIndex, int nTris[2][3] );
void BuildTriTLtoBR( int ndx );
void BuildTriBLtoTR( int ndx );
void InitTris( void );
void CreateTris( void );
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::SetPower( int power )
{
m_Power = power;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CCoreDispInfo::GetPower( void ) const
{
return m_Power;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CCoreDispInfo::GetPostSpacing( void )
{
return ( ( 1 << m_Power ) + 1 );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CCoreDispInfo::GetWidth( void )
{
return ( ( 1 << m_Power ) + 1 );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CCoreDispInfo::GetHeight( void )
{
return ( ( 1 << m_Power ) + 1 );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CCoreDispInfo::GetSize( void ) const
{
return ( ( ( 1 << m_Power ) + 1 ) * ( ( 1 << m_Power ) + 1 ) );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::SetVert( int index, Vector const &vert )
{
Assert( index >= 0 );
Assert( index < MAX_VERT_COUNT );
VectorCopy( vert, m_pVerts[index].m_Vert );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::GetVert( int index, Vector& vert ) const
{
Assert( index >= 0 );
Assert( index < MAX_VERT_COUNT );
VectorCopy( m_pVerts[index].m_Vert, vert );
}
inline const Vector& CCoreDispInfo::GetVert( int index ) const
{
Assert( index >= 0 );
Assert( index < MAX_VERT_COUNT );
return m_pVerts[index].m_Vert;
}
inline const Vector& CCoreDispInfo::GetVert( const CVertIndex &index ) const
{
return GetVert( VertIndexToInt( index ) );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::GetFlatVert( int index, Vector& vert ) const
{
Assert( index >= 0 );
Assert( index < MAX_VERT_COUNT );
VectorCopy( m_pVerts[index].m_FlatVert, vert );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::SetFlatVert( int index, const Vector &vert )
{
Assert( index >= 0 );
Assert( index < MAX_VERT_COUNT );
VectorCopy( vert, m_pVerts[index].m_FlatVert );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::SetNormal( int index, Vector const &normal )
{
Assert( index >= 0 );
Assert( index < MAX_VERT_COUNT );
VectorCopy( normal, m_pVerts[index].m_Normal );
}
inline void CCoreDispInfo::SetNormal( const CVertIndex &index, Vector const &normal )
{
SetNormal( VertIndexToInt( index ), normal );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::GetNormal( int index, Vector& normal ) const
{
Assert( index >= 0 );
Assert( index < MAX_VERT_COUNT );
VectorCopy( m_pVerts[index].m_Normal, normal );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline const Vector& CCoreDispInfo::GetNormal( int index ) const
{
Assert( index >= 0 );
Assert( index < MAX_VERT_COUNT );
return m_pVerts[index].m_Normal;
}
inline const Vector& CCoreDispInfo::GetNormal( const CVertIndex &index ) const
{
return GetNormal( VertIndexToInt( index ) );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::GetTangentS( int index, Vector& tangentS ) const
{
Assert( index >= 0 );
Assert( index < GetSize() );
VectorCopy( m_pVerts[index].m_TangentS, tangentS );
}
inline const Vector &CCoreDispInfo::GetTangentS( int index ) const
{
Assert( index >= 0 );
Assert( index < GetSize() );
return m_pVerts[index].m_TangentS;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::GetTangentT( int index, Vector& tangentT ) const
{
Assert( index >= 0 );
Assert( index < GetSize() );
VectorCopy( m_pVerts[index].m_TangentT, tangentT );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::SetTexCoord( int index, Vector2D const& texCoord )
{
Assert( index >= 0 );
Assert( index < GetSize() );
Vector2DCopy( texCoord, m_pVerts[index].m_TexCoord );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::GetTexCoord( int index, Vector2D& texCoord ) const
{
Assert( index >= 0 );
Assert( index < GetSize() );
Vector2DCopy( m_pVerts[index].m_TexCoord, texCoord );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::SetLuxelCoord( int bumpIndex, int index, Vector2D const& luxelCoord )
{
Assert( index >= 0 );
Assert( index < GetSize() );
Assert( bumpIndex >= 0 );
Assert( bumpIndex < NUM_BUMP_VECTS + 1 );
Vector2DCopy( luxelCoord, m_pVerts[index].m_LuxelCoords[bumpIndex] );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::GetLuxelCoord( int bumpIndex, int index, Vector2D& luxelCoord ) const
{
Assert( index >= 0 );
Assert( index < MAX_VERT_COUNT );
Assert( bumpIndex >= 0 );
Assert( bumpIndex < NUM_BUMP_VECTS + 1 );
Vector2DCopy( m_pVerts[index].m_LuxelCoords[bumpIndex], luxelCoord );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::SetAlpha( int index, float alpha )
{
Assert( index >= 0 );
Assert( index < MAX_VERT_COUNT );
m_pVerts[index].m_Alpha = alpha;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline float CCoreDispInfo::GetAlpha( int index )
{
Assert( index >= 0 );
Assert( index < MAX_VERT_COUNT );
return m_pVerts[index].m_Alpha;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::SetElevation( float elevation )
{
m_Elevation = elevation;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline float CCoreDispInfo::GetElevation( void )
{
return m_Elevation;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::ResetFieldVectors( void )
{
// Vector normal;
// m_Surf.GetNormal( normal );
int size = GetSize();
for( int i = 0; i < size; i++ )
{
m_pVerts[i].m_FieldVector.Init();
// m_FieldVectors[i] = normal;
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::SetFieldVector( int index, Vector const &v )
{
Assert( index >= 0 );
Assert( index < MAX_VERT_COUNT );
VectorCopy( v, m_pVerts[index].m_FieldVector );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::GetFieldVector( int index, Vector& v )
{
Assert( index >= 0 );
Assert( index < MAX_VERT_COUNT );
VectorCopy( m_pVerts[index].m_FieldVector, v );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::ResetSubdivPositions( void )
{
int size = GetSize();
for( int i = 0; i < size; i++ )
{
m_pVerts[i].m_SubdivPos.Init();
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::SetSubdivPosition( int ndx, Vector const &v )
{
Assert( ndx >= 0 );
Assert( ndx < MAX_VERT_COUNT );
m_pVerts[ndx].m_SubdivPos = v;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::GetSubdivPosition( int ndx, Vector& v )
{
Assert( ndx >= 0 );
Assert( ndx < MAX_VERT_COUNT );
v = m_pVerts[ndx].m_SubdivPos;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::ResetSubdivNormals( void )
{
Vector normal;
m_Surf.GetNormal( normal );
int size = GetSize();
for( int i = 0; i < size; i++ )
{
m_pVerts[i].m_SubdivNormal = normal;
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::SetSubdivNormal( int ndx, Vector const &v )
{
Assert( ndx >= 0 );
Assert( ndx < MAX_VERT_COUNT );
m_pVerts[ndx].m_SubdivNormal = v;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::GetSubdivNormal( int ndx, Vector &v )
{
Assert( ndx >= 0 );
Assert( ndx < MAX_VERT_COUNT );
v = m_pVerts[ndx].m_SubdivNormal;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::ResetFieldDistances( void )
{
int size = GetSize();
for( int i = 0; i < size; i++ )
{
m_pVerts[i].m_FieldDistance = 0.0f;
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::SetFieldDistance( int index, float dist )
{
Assert( index >= 0 );
Assert( index < GetSize() );
m_pVerts[index].m_FieldDistance = dist;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline float CCoreDispInfo::GetFieldDistance( int index )
{
Assert( index >= 0 );
Assert( index < GetSize() );
return m_pVerts[index].m_FieldDistance;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::SetRenderIndexCount( int count )
{
m_RenderIndexCount = count;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CCoreDispInfo::GetRenderIndexCount( void )
{
return m_RenderIndexCount;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::SetRenderIndex( int index, int triIndex )
{
Assert( index >= 0 );
Assert( index < ( MAX_VERT_COUNT*2*3) );
m_RenderIndices[index] = triIndex;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CCoreDispInfo::GetRenderIndex( int index )
{
Assert( index >= 0 );
Assert( index < ( MAX_VERT_COUNT*2*3) );
return m_RenderIndices[index];
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline CoreDispVert_t *CCoreDispInfo::GetDispVertList()
{
return m_pVerts;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline unsigned short *CCoreDispInfo::GetRenderIndexList( void )
{
return &m_RenderIndices[0];
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CCoreDispInfo::SetTouched( bool touched )
{
m_bTouched = touched;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline bool CCoreDispInfo::IsTouched( void )
{
return m_bTouched;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline CCoreDispNode *CCoreDispInfo::GetNode( int index )
{
Assert( index >= 0 );
Assert( index < MAX_NODE_COUNT );
return &m_Nodes[index];
}
bool CalcBarycentricCooefs( Vector const &v0, Vector const &v1, Vector const &v2,
Vector const &pt, float &c0, float &c1, float &c2 );
#endif // BUILDDISP_H