Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

947 lines
35 KiB

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