csgo/cstrike15_src/hammer/mapdisp.h

//========= Copyright � 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $Workfile:     $
// $Date:         $
//
//-----------------------------------------------------------------------------
// $Log: $
//
// $NoKeywords: $
//=============================================================================//

#ifndef MAPDISP_H
#define MAPDISP_H
#pragma once

//=============================================================================

#pragma warning(push, 1)
#pragma warning(disable:4701 4702 4530)
#include <fstream>
#pragma warning(pop)
#include <UtlVector.h>
#include "MapAtom.h"
#include "Render3D.h"
#include "mathlib/VMatrix.h"
#include "DispMapImageFilter.h"
#include "builddisp.h"
#include "DispManager.h"

class CChunkFile;
class CMapClass;
class CMapFace;
class CSaveInfo;
class IWorldEditDispMgr;
class CToolDisplace;
class Color;
class CSelection;

struct Shoreline_t;
struct ExportDXFInfo_s;

enum ChunkFileResult_t;

// Painting Defines
#define DISPPAINT_CHANNEL_POSITION		0
#define DISPPAINT_CHANNEL_ALPHA			1

#define WALKABLE_NORMAL_VALUE			0.7f
#define BUILDABLE_NORMAL_VALUE			0.8f

//=============================================================================
//
// Displacement Map Class
//
class CMapDisp : public CMapAtom
{
private:

	typedef struct
	{
		Vector min;
		Vector max;
	} BBox_t;

	typedef struct
	{
		Vector normal;
		float  dist;
	} Plane_t;

	typedef struct
	{
		Vector v[3];
	} Tri_t;

public:

    enum { MAPDISP_MAX_VERTS      = 289 };			// 17x17
    enum { MAPDISP_MAX_FACES      = 512 };			// ( 16x16 ) x 2
	enum { MAPDISP_MAX_NEIGHBORS  = 8 };			// 4 edges + 4 corners -- always four-sided

	//=========================================================================
	//
	// Constructor/Deconstructor (Initialization)
	//
    CMapDisp();
    ~CMapDisp();

	inline void SetEditHandle( EditDispHandle_t handle ) { m_EditHandle = handle; }
	inline EditDispHandle_t GetEditHandle( void ) { return m_EditHandle; }

	bool InitDispSurfaceData( CMapFace *pFace, bool bGenerateStartPoint );
	void ResetFieldData( void );
	void InitData( int power );
//	void InitData( int power, int minTess, float smoothingAngle, Vector **dispVectorField, Vector **dispVectorOffset, float *dispDistances );

	//=========================================================================
	//
	// Creation, Copy
	//
	bool Create( void );
    CMapDisp *CopyFrom( CMapDisp *pMapDisp, bool bUpdateDependencies );

	//=========================================================================
	//
	// Update/Modification/Editing Functions
	//
	void UpdateSurfData( CMapFace *pFace );
	void UpdateSurfDataAndVectorField( CMapFace *pFace );
	void UpdateData( void );
	void UpdateDataAndNeighborData( void );

	void InvertAlpha( void );

	void Resample( int power );
	void Elevate( float elevation );

	bool TraceLine( Vector &HitPos, Vector &HitNormal, Vector const &RayStart, Vector const &RayEnd );
	bool TraceLineSnapTo( Vector &HitPos, Vector &HitNormal, Vector const &RayStart, Vector const &RayEnd );

	void DoTransform(const VMatrix &matrix);

	void ApplyNoise( float min, float max, float rockiness );

	bool PointSurfIntersection( Vector const &ptCenter, float radius, float &distMin, Vector &ptMin );

	void Split( EditDispHandle_t hBuilderDisp );

	void UpdateWalkable( void );
	void UpdateBuildable( void );

	void CreateShoreOverlays( CMapFace *pFace, Shoreline_t *pShoreline );

	virtual void PostUpdate(Notify_Dependent_t eNotifyType);

	//=========================================================================
	//
	// Attributes
	//
    inline void SetPower( int power );
    inline int GetPower( void );
    inline int CalcPower( int width );

    inline int GetSize( void );
    inline int GetWidth( void );
    inline int GetHeight( void );

	inline int TriangleCount() { return 2 * (GetWidth() - 1) * (GetHeight() - 1); }

	inline void SetElevation( float elevation );
	inline float GetElevation( void );

	void Scale( float scale );
	inline float GetScale( void );

	inline void GetBoundingBox( Vector& boxMin, Vector& boxMax );

	inline size_t GetDataSize( void );

	// flags
    inline bool IsTouched( void );
    inline void SetTouched( void );
    inline void ResetTouched( void );

	inline void SetHasMappingAxes( bool value );

	inline void SetSubdivided( bool bSubdiv );
	inline bool IsSubdivided( void );
	inline void SetReSubdivision( bool bReSubdiv );
	inline bool NeedsReSubdivision( void );

	//=========================================================================
	//
	// Base Surface Data
	//
	inline void GetSurfPoint( int index, Vector& pt );
	inline void GetSurfNormal( Vector& normal );
	inline int GetSurfPointStartIndex( void );
	inline void SetSurfPointStartIndex( int index );
	inline void GetSurfTexCoord( int ndx, Vector2D &texCoord );
	inline void SetSurfTexCoord( int ndx, Vector2D const &texCoord );

	inline int  GetFlags( void )				{ return m_CoreDispInfo.GetSurface()->GetFlags(); }
	inline void SetFlags( int nFlags )			{ m_CoreDispInfo.GetSurface()->SetFlags( nFlags ); }
	inline bool CheckFlags( int nFlags )		{ return ( ( nFlags & GetFlags() ) != 0 ) ? true : false; }

	//=========================================================================
	//
	// Surface Data
	//
	inline void SetVert( int index, Vector const &v );
	inline void GetVert( int index, Vector& v );
	inline void SetAlpha( int index, float alpha );
	inline float GetAlpha( int index );
	inline void GetFlatVert( int index, Vector& v );
	inline void SetFlatVert( int index, const Vector &v );
	inline void GetMultiBlend( int index, Vector4D &vBlend, Vector4D &vAlphaBlend, Vector &vColor1, Vector &vColor2, Vector &vColor3, Vector &vColor4 );
	inline void SetMultiBlend( int index, Vector4D &vBlend, Vector4D &vAlphaBlend, Vector &vColor1, Vector &vColor2, Vector &vColor3, Vector &vColor4 );

	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 distance );
	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 int GetTriCount( void )																	  { return m_CoreDispInfo.GetTriCount(); }
	inline void GetTriIndices( int iTri, unsigned short &v1, unsigned short &v2, unsigned short &v3 ) { m_CoreDispInfo.GetTriIndices( iTri, v1, v2, v3 ); }
	inline void GetTriPos( int iTri, Vector &v1, Vector &v2, Vector &v3 )							  { m_CoreDispInfo.GetTriPos( iTri, v1, v2, v3 ); }
	inline void SetTriTag( int iTri, unsigned short nTag )											  { m_CoreDispInfo.SetTriTag( iTri, nTag ); }
	inline void ResetTriTag( int iTri, unsigned short nTag )										  { m_CoreDispInfo.ResetTriTag( iTri, nTag ); }
	inline void ToggleTriTag( int iTri, unsigned short nTag )										  { m_CoreDispInfo.ToggleTriTag( iTri, nTag ); }
	inline bool IsTriTag( int iTri, unsigned short nTag )											  { return m_CoreDispInfo.IsTriTag( iTri, nTag ); }
	inline bool IsTriWalkable( int iTri )															  { return m_CoreDispInfo.IsTriWalkable( iTri ); }
	inline bool IsTriBuildable( int iTri )															  { return m_CoreDispInfo.IsTriBuildable( iTri ); }
	int CollideWithDispTri( const Vector &rayStart, const Vector &rayEnd, float &flFraction, bool OneSided = false );

	//=========================================================================
	//
	// Neighbors
	//
	void UpdateNeighborDependencies( bool bDestroy );
	
	static void UpdateNeighborsOfDispsIntersectingBox( const Vector &bbMin, const Vector &bbMax, float flPadding );

	inline void SetEdgeNeighbor( int direction, EditDispHandle_t handle, int orient );
	inline void GetEdgeNeighbor( int direction, EditDispHandle_t &handle, int &orient );
	inline EditDispHandle_t GetEdgeNeighbor( int direction );

	inline int GetCornerNeighborCount( int direction );
	inline void AddCornerNeighbor( int direction, EditDispHandle_t handle, int orient );
	inline void GetCornerNeighbor( int direction, int cornerIndex, EditDispHandle_t &handle, int &orient );
	inline EditDispHandle_t GetCornerNeighbor( int direction, int cornerIndex );

	// for lighting preview
	void AddShadowingTriangles( CUtlVector<Vector> &tri_list );

	//=========================================================================
	//
	// Rendering
	//
    void Render3D( CRender3D *pRender, bool bIsSelected, SelectionState_t faceSelectionState );
	void Render2D( CRender2D *pRender, bool bIsSelected, SelectionState_t faceSelectionState );

	static void SetSelectMask( bool bSelectMask );
	static bool HasSelectMask( void );
	static void SetGridMask( bool bGridMask );
	static bool HasGridMask( void );

	//=========================================================================
	//
	// Selection
	//
	inline void SetTexelHitIndex( int index );
	inline int GetTexelHitIndex( void );
	inline void ResetTexelHitIndex( void );

	inline void SetDispMapHitIndex( int index );
	inline void ResetDispMapHitIndex( void );
    EditDispHandle_t GetHitDispMap( void );

	//=========================================================================
	//
	// Paint Functions
	//
	void Paint_Init( int nType );
	void Paint_InitSelfAndNeighbors( int nType );
	void Paint_SetValue( int iVert, Vector const &vPaint );
	void Paint_Update( bool bSplit );
	void Paint_UpdateSelfAndNeighbors( bool bSplit );
	inline bool Paint_IsDirty( void );

	//=========================================================================
	//
	// Undo Functions (friends)
	//
	friend void EditDisp_ForUndo( EditDispHandle_t editHandle, char *pszPositionName, bool bNeighborsUndo );

	//=========================================================================
	//
	// Utility Functions
	//
	void DispUVToSurf( Vector2D const &dispUV, Vector &surfPt, Vector *pNormal, float *pAlpha )		{ m_CoreDispInfo.DispUVToSurf( dispUV, surfPt, pNormal, pAlpha ); }
	void BaseFacePlaneToDispUV( Vector const &planePt, Vector2D &dispUV )							{ m_CoreDispInfo.BaseFacePlaneToDispUV( planePt, dispUV ); }
	bool SurfToBaseFacePlane( Vector const &surfPt, Vector &planePt )								{ return m_CoreDispInfo.SurfToBaseFacePlane( surfPt, planePt ); }

	CCoreDispInfo *GetCoreDispInfo( void )										{ return &m_CoreDispInfo; }

	//=========================================================================
	//
	// Load/Save Functions
	//
	ChunkFileResult_t LoadVMF(CChunkFile *pFile);
	ChunkFileResult_t SaveVMF(CChunkFile *pFile, CSaveInfo *pSaveInfo);
	bool SerializedLoadMAP( std::fstream &file, CMapFace *pFace, UINT version );
	bool SerializedLoadRMF( std::fstream &file, CMapFace *pFace, float version );
	bool SaveDXF(ExportDXFInfo_s *pInfo);

	void PostLoad( void );

	void UpdateVertPositionForSubdiv( int iVert, const Vector &vecNewSubdivPos );


private:

	enum { NUM_EDGES_CORNERS = 4 };
	enum { MAX_CORNER_NEIGHBORS = 4 };

	EditDispHandle_t	m_EditHandle;														// id of displacement in global manager's list

	CCoreDispInfo	m_CoreDispInfo;															// core displacement info

	int				m_HitTexelIndex;														// the displacement map texel that was "hit"
	int				m_HitDispIndex;															// the displacement map that was hit (this or one of its neighbors)

	Vector			m_LightPosition;
	float			m_LightColor[3];

	EditDispHandle_t	m_EdgeNeighbors[NUM_EDGES_CORNERS];										// four possible edge neighbors (W, N, E, S)
	int				m_EdgeNeighborOrientations[NUM_EDGES_CORNERS];							// neighbor edge orientations
	int				m_CornerNeighborCounts[NUM_EDGES_CORNERS];								// number of corner neighbors (not counting edge neighbors)
	EditDispHandle_t	m_CornerNeighbors[NUM_EDGES_CORNERS][MAX_CORNER_NEIGHBORS];				// four corners/multiple corner neighbors possible (SW, SE, NW, NE)
	int				m_CornerNeighborOrientations[NUM_EDGES_CORNERS][MAX_CORNER_NEIGHBORS];	// neighbor corner orientations

	bool			m_bHasMappingAxes;
	Vector			m_MapAxes[2];															// for older files (.map, .rmf)

	Vector			m_BBox[2];																// axial-aligned bounding box

	float			m_Scale;

	static bool		m_bSelectMask;															// masks for the Displacement Tool (FaceEditSheet)
	static bool		m_bGridMask;

	bool			m_bSubdiv;
	bool			m_bReSubdiv;

	CUtlVector<CoreDispVert_t*>		m_aWalkableVerts;
	CUtlVector<unsigned short>		m_aWalkableIndices;
	CUtlVector<unsigned short>		m_aForcedWalkableIndices;
	CUtlVector<CoreDispVert_t*>		m_aBuildableVerts;
	CUtlVector<unsigned short>		m_aBuildableIndices;
	CUtlVector<unsigned short>		m_aForcedBuildableIndices;

	// Painting Data.
	struct PaintCanvas_t
	{
		enum { CANVAS_SIZE = MAPDISP_MAX_VERTS };

		int		m_nType;							// what does the canvas hold - position, alpha, etc.
		Vector	m_Values[CANVAS_SIZE];
		bool	m_bValuesDirty[CANVAS_SIZE];
		bool	m_bDirty;
	};

	PaintCanvas_t	m_Canvas;

	int				m_FoWTriSoupID;

	//=========================================================================
	//
	// Painting Functions
	//
	void PaintPosition_Update( int iVert );
	void PaintAlpha_Update( int iVert );
	
	//=========================================================================
	//
	// Update/Modification/Editing Functions
	//
	void UpSample( int oldPower );
	void DownSample( int oldPower );
	void GetValidSamplePoints( int index, int width, int height, bool *pValidPoints );
	void SamplePoints( int index, int width, int height, bool *pValidPoints, float *pValue, float *pAlpha, 
		               Vector& newDispVector, Vector& newSubdivPos, Vector &newSubdivNormal );

	void PostCreate( void );
	void UpdateBoundingBox( void );
	void UpdateLightmapExtents( void );
	bool ValidLightmapSize( void );
	void CheckAndUpdateOverlays( bool bFull );
	bool EntityInBoundingBox( Vector const &vOrigin );

	enum { FLIP_HORIZONTAL = 0,
		   FLIP_VERTICAL,
		   FLIP_TRANSPOSE };

	void Flip( int flipType );
	int GetAxisTypeBasedOnView( int majorAxis, int vertAxis, int horzAxis );
	int GetMajorAxis( Vector &v );

	//=========================================================================
	//
	// Collision Testing
	//
	void CreateBoundingBoxes( BBox_t *pBBox, int count, float bloat );
	void CreatePlanesFromBoundingBox( Plane_t *planes, const Vector& bbMin, const Vector& bbMax );
	void CollideWithBoundingBoxes( const Vector& rayStart, const Vector& rayEnd, BBox_t *pBBox, int bboxCount, Tri_t *pTris, int *triCount );
	float CollideWithTriangles( const Vector& RayStart, const Vector& RayEnd, Tri_t *pTris, int triCount, Vector& surfNormal );

	//=========================================================================
	//
	// Rendering
	//
    void RenderHitBox( CRender3D *pRender, bool bNudge );
	void RenderPaintSphere( CRender3D *pRender, CToolDisplace *pTool );
	void CalcColor( CRender3D *pRender, bool bIsSelected, SelectionState_t faceSelectionState, Color &pColor );

	void RenderSurface( CRender3D *pRender, bool bIsSelected, SelectionState_t faceSelectionState );
	void RenderOverlaySurface( CRender3D *pRender, bool bIsSelected, SelectionState_t faceSelectionState );
	void RenderWalkableSurface( CRender3D *pRender, bool bIsSelected, SelectionState_t faceSelectionState );
	void RenderBuildableSurface( CRender3D *pRender, bool bIsSelected, SelectionState_t faceSelectionState );
	void RenderWireframeSurface( CRender3D *pRender, bool bIsSelected, SelectionState_t faceSelectionState );

	void RenderDisAllowedVerts( CRender3D *pRender );

	void Render3DDebug( CRender3D *pRender, bool isSelected );

	//=========================================================================
	//
	// Neighboring Functions
	//
    inline void ResetNeighbors( void );
	void FindNeighbors( void );

	//=========================================================================
	//
	// Load/Save Functions
	//
	static ChunkFileResult_t LoadDispDistancesCallback(CChunkFile *pFile, CMapDisp *pDisp);
	static ChunkFileResult_t LoadDispDistancesKeyCallback(const char *szKey, const char *szValue, CMapDisp *pDisp);
	static ChunkFileResult_t LoadDispOffsetsCallback(CChunkFile *pFile, CMapDisp *pDisp);
	static ChunkFileResult_t LoadDispOffsetsKeyCallback(const char *szKey, const char *szValue, CMapDisp *pDisp);
	static ChunkFileResult_t LoadDispOffsetNormalsCallback(CChunkFile *pFile, CMapDisp *pDisp);
	static ChunkFileResult_t LoadDispOffsetNormalsKeyCallback(const char *szKey, const char *szValue, CMapDisp *pDisp);
	static ChunkFileResult_t LoadDispKeyCallback(const char *szKey, const char *szValue, CMapDisp *pDisp);
	static ChunkFileResult_t LoadDispNormalsCallback(CChunkFile *pFile, CMapDisp *pDisp);
	static ChunkFileResult_t LoadDispNormalsKeyCallback(const char *szKey, const char *szValue, CMapDisp *pDisp);
	static ChunkFileResult_t LoadDispAlphasCallback(CChunkFile *pFile, CMapDisp *pDisp);
	static ChunkFileResult_t LoadDispAlphasKeyCallback(const char *szKey, const char *szValue, CMapDisp *pDisp);
	static ChunkFileResult_t LoadDispMultiBlendCallback(CChunkFile *pFile, CMapDisp *pDisp);
	static ChunkFileResult_t LoadDispMultiBlendKeyCallback(const char *szKey, const char *szValue, CMapDisp *pDisp);
	static ChunkFileResult_t LoadDispAlphaBlendCallback(CChunkFile *pFile, CMapDisp *pDisp);
	static ChunkFileResult_t LoadDispAlphaBlendKeyCallback(const char *szKey, const char *szValue, CMapDisp *pDisp);
	static ChunkFileResult_t LoadDispMultiBlendColorCallback0(CChunkFile *pFile, CMapDisp *pDisp);
	static ChunkFileResult_t LoadDispMultiBlendColorCallback1(CChunkFile *pFile, CMapDisp *pDisp);
	static ChunkFileResult_t LoadDispMultiBlendColorCallback2(CChunkFile *pFile, CMapDisp *pDisp);
	static ChunkFileResult_t LoadDispMultiBlendColorCallback3(CChunkFile *pFile, CMapDisp *pDisp);
	static ChunkFileResult_t LoadDispMultiBlendColorKeyCallback(const char *szKey, const char *szValue, CMapDisp *pDisp);
	static ChunkFileResult_t LoadDispTriangleTagsCallback(CChunkFile *pFile, CMapDisp *pDisp);
	static ChunkFileResult_t LoadDispTriangleTagsKeyCallback(const char *szKey, const char *szValue, CMapDisp *pDisp);
	static ChunkFileResult_t LoadDispAllowedVertsCallback(CChunkFile *pFile, CMapDisp *pDisp);
	static ChunkFileResult_t LoadDispAllowedVertsKeyCallback(const char *szKey, const char *szValue, CMapDisp *pDisp);

	//=========================================================================
	//
	// Utility
	//
	bool ComparePoints( const Vector& pt1, const Vector& pt2, const float tolerance );
	int GetStartIndexFromLevel( int levelIndex );
	int GetEndIndexFromLevel( int levelIndex );
	void SnapPointToPlane( Vector const &vNormal, float dist, Vector &pt );
};


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::SetPower( int power )
{
	m_CoreDispInfo.SetPower( power );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CMapDisp::GetPower( void )
{
	return m_CoreDispInfo.GetPower();
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CMapDisp::CalcPower( int width )
{
    switch( width )
    {
    case 5:
        return 2;
    case 9:
        return 3;
    case 17:
        return 4;
    default:
        return -1;
    }
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CMapDisp::GetWidth( void )
{
	return m_CoreDispInfo.GetWidth();
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CMapDisp::GetHeight( void ) 
{ 
    return m_CoreDispInfo.GetHeight();
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CMapDisp::GetSize( void ) 
{ 
	return m_CoreDispInfo.GetSize();
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::SetElevation( float elevation )
{
	m_CoreDispInfo.SetElevation( elevation );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline float CMapDisp::GetElevation( void )
{
	return m_CoreDispInfo.GetElevation();
}

	
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline float CMapDisp::GetScale( void )
{
	return m_Scale;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::GetBoundingBox( Vector& boxMin, Vector& boxMax )
{
	boxMin = m_BBox[0];
	boxMax = m_BBox[1];
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline size_t CMapDisp::GetDataSize( void )
{
	return ( sizeof( CMapDisp ) );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline bool CMapDisp::IsTouched( void )
{
	return m_CoreDispInfo.IsTouched();
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::SetTouched( void )
{
	m_CoreDispInfo.SetTouched( true );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::ResetTouched( void )
{
	m_CoreDispInfo.SetTouched( false );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::SetHasMappingAxes( bool value )
{
	m_bHasMappingAxes = value;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::SetSubdivided( bool bSubdiv )
{
	m_bSubdiv = bSubdiv;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline bool CMapDisp::IsSubdivided( void )
{
	return m_bSubdiv;
}

	
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::SetReSubdivision( bool bReSubdiv )
{
	m_bReSubdiv = bReSubdiv;
}

	
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline bool CMapDisp::NeedsReSubdivision( void )
{
	return m_bReSubdiv;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::GetSurfPoint( int index, Vector& pt )
{
	CCoreDispSurface *pSurf = m_CoreDispInfo.GetSurface();
	pSurf->GetPoint( index, pt );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::GetSurfNormal( Vector& normal )
{
	CCoreDispSurface *pSurf = m_CoreDispInfo.GetSurface();
	pSurf->GetNormal( normal );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CMapDisp::GetSurfPointStartIndex( void )
{
	CCoreDispSurface *pSurf = m_CoreDispInfo.GetSurface();
	return pSurf->GetPointStartIndex();
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::SetSurfPointStartIndex( int index )
{
	CCoreDispSurface *pSurf = m_CoreDispInfo.GetSurface();
	pSurf->SetPointStartIndex( index );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::GetSurfTexCoord( int ndx, Vector2D &texCoord )
{
	CCoreDispSurface *pSurf = m_CoreDispInfo.GetSurface();
	pSurf->GetTexCoord( ndx, texCoord );
}

	
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------	
inline void CMapDisp::SetSurfTexCoord( int ndx, Vector2D const &texCoord )
{
	CCoreDispSurface *pSurf = m_CoreDispInfo.GetSurface();
	pSurf->SetTexCoord( ndx, texCoord );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::SetVert( int index, Vector const &v )
{
	m_CoreDispInfo.SetVert( index, v );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::GetVert( int index, Vector& v )
{
	m_CoreDispInfo.GetVert( index, v );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::SetAlpha( int index, float alpha )
{
	m_CoreDispInfo.SetAlpha( index, alpha );
}

	
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline float CMapDisp::GetAlpha( int index )
{
	return m_CoreDispInfo.GetAlpha( index );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::GetFlatVert( int index, Vector& v )
{
	m_CoreDispInfo.GetFlatVert( index, v );
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::SetFlatVert( int index, const Vector &v )
{
	m_CoreDispInfo.SetFlatVert( index, v );
}

inline void CMapDisp::GetMultiBlend( int index, Vector4D &vBlend, Vector4D &vAlphaBlend, Vector &vColor1, Vector &vColor2, Vector &vColor3, Vector &vColor4 )
{
	m_CoreDispInfo.GetMultiBlend( index, vBlend, vAlphaBlend, vColor1, vColor2, vColor3, vColor4 );
}

inline void CMapDisp::SetMultiBlend( int index, Vector4D &vBlend, Vector4D &vAlphaBlend, Vector &vColor1, Vector &vColor2, Vector &vColor3, Vector &vColor4 )
{
	m_CoreDispInfo.SetMultiBlend( index, vBlend, vAlphaBlend, vColor1, vColor2, vColor3, vColor4 );
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::ResetFieldVectors( void )
{
	m_CoreDispInfo.ResetFieldVectors();
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::SetFieldVector( int index, Vector const &v )
{
	m_CoreDispInfo.SetFieldVector( index, v );
}

	
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::GetFieldVector( int index, Vector& v )
{
	m_CoreDispInfo.GetFieldVector( index, v );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::ResetSubdivPositions( void )
{
	m_CoreDispInfo.ResetSubdivPositions();
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::SetSubdivPosition( int ndx, Vector const &v )
{
	m_CoreDispInfo.SetSubdivPosition( ndx, v );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::GetSubdivPosition( int ndx, Vector& v )
{
	m_CoreDispInfo.GetSubdivPosition( ndx, v );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::ResetSubdivNormals( void )
{
	m_CoreDispInfo.ResetSubdivNormals();
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::SetSubdivNormal( int ndx, Vector const &v )
{
	m_CoreDispInfo.SetSubdivNormal( ndx, v );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::GetSubdivNormal( int ndx, Vector &v )
{
	m_CoreDispInfo.GetSubdivNormal( ndx, v );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::ResetFieldDistances( void )
{
	m_CoreDispInfo.ResetFieldDistances();
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::SetFieldDistance( int index, float dist )
{
	m_CoreDispInfo.SetFieldDistance( index, dist );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline float CMapDisp::GetFieldDistance( int index )
{
	return m_CoreDispInfo.GetFieldDistance( index );
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::ResetNeighbors( void )
{
	for( int i = 0; i < NUM_EDGES_CORNERS; i++ )
	{
		m_EdgeNeighbors[i] = EDITDISPHANDLE_INVALID;
		m_EdgeNeighborOrientations[i] = -1;

		m_CornerNeighborCounts[i] = 0;
		for( int j = 0; j < MAX_CORNER_NEIGHBORS; j++ )
		{
			m_CornerNeighbors[i][j] = EDITDISPHANDLE_INVALID;
			m_CornerNeighborOrientations[i][j] = -1;
		}
	}
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::SetEdgeNeighbor( int direction, EditDispHandle_t handle, int orient )
{
	assert( direction >= 0 );
	assert( direction < NUM_EDGES_CORNERS );
	m_EdgeNeighbors[direction] = handle;
	m_EdgeNeighborOrientations[direction] = orient;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::GetEdgeNeighbor( int direction, EditDispHandle_t &handle, int &orient )
{
	assert( direction >= 0 );
	assert( direction < NUM_EDGES_CORNERS );
	handle = m_EdgeNeighbors[direction];
	orient = m_EdgeNeighborOrientations[direction];
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline EditDispHandle_t CMapDisp::GetEdgeNeighbor( int direction )
{
	assert( direction >= 0 );
	assert( direction < NUM_EDGES_CORNERS );
	return m_EdgeNeighbors[direction];
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::AddCornerNeighbor( int direction, EditDispHandle_t handle, int orient )
{
	assert( direction >= 0 );
	assert( direction < NUM_EDGES_CORNERS );
	if( m_CornerNeighborCounts[direction] >= MAX_CORNER_NEIGHBORS )
		return;

	m_CornerNeighbors[direction][m_CornerNeighborCounts[direction]] = handle;
	m_CornerNeighborOrientations[direction][m_CornerNeighborCounts[direction]] = orient;
	m_CornerNeighborCounts[direction]++;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline int CMapDisp::GetCornerNeighborCount( int direction )
{
	assert( direction >= 0 );
	assert( direction < NUM_EDGES_CORNERS );
	return m_CornerNeighborCounts[direction];
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CMapDisp::GetCornerNeighbor( int direction, int cornerIndex, EditDispHandle_t &handle, int &orient )
{
	assert( direction >= 0 );
	assert( direction < NUM_EDGES_CORNERS );
	assert( cornerIndex >= 0 );
	assert( cornerIndex < MAX_CORNER_NEIGHBORS );

	handle = EDITDISPHANDLE_INVALID;
	orient = 0;
	
	if( cornerIndex >= m_CornerNeighborCounts[direction] )
		return;

	handle = m_CornerNeighbors[direction][cornerIndex];
	orient = m_CornerNeighborOrientations[direction][cornerIndex];
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline EditDispHandle_t CMapDisp::GetCornerNeighbor( int direction, int cornerIndex )
{
	assert( direction >= 0 );
	assert( direction < NUM_EDGES_CORNERS );

	assert( cornerIndex >= 0 );
	assert( cornerIndex < MAX_CORNER_NEIGHBORS );

	if( cornerIndex >= m_CornerNeighborCounts[direction] )
		return NULL;

	return m_CornerNeighbors[direction][cornerIndex];
}

inline void CMapDisp::ResetTexelHitIndex( void ) { m_HitTexelIndex = -1; }
inline void CMapDisp::SetTexelHitIndex( int index ) { m_HitTexelIndex = index; }
inline int  CMapDisp::GetTexelHitIndex( void ) { return m_HitTexelIndex; }
inline void CMapDisp::SetDispMapHitIndex( int index ) { m_HitDispIndex = index; }
inline void CMapDisp::ResetDispMapHitIndex( void ) { m_HitDispIndex = -1; }

inline bool CMapDisp::Paint_IsDirty( void ) { return m_Canvas.m_bDirty; }

#endif // MAPDISP_H