1HEADmaster

1 files changed, 947 insertions, 0 deletions

diff --git a/hammer/mapdisp.h b/hammer/mapdisp.h
new file mode 100644
index 0000000..ec07cb8
--- /dev/null
+++ b/hammer/mapdisp.h
@@ -0,0 +1,947 @@
+//========= Copyright 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 UpdateTriRemove( void );
+
+    void CreateShoreOverlays( CMapFace *pFace, Shoreline_t *pShoreline );
+
+    //=========================================================================
+    //
+    // 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 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 ); }
+
+	// this is gone in m_CoreDispInfo.
+    inline bool IsTriRemove( int iTri )                                                               { return false; } //m_CoreDispInfo.IsTriRemove( 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;
+    CUtlVector<CoreDispVert_t*>     m_aRemoveVerts;
+    CUtlVector<unsigned short>      m_aRemoveIndices;
+
+    // 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;
+
+    //=========================================================================
+    //
+    // 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 RenderRemoveSurface( 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 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::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