path: root/mp/src/public/builddisp.h

//========= 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