948 lines
35 KiB
C++
948 lines
35 KiB
C++
//========= 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
|