1712 lines
38 KiB
C++
1712 lines
38 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Structured Solid (CSSolid) implementation.
|
|
//
|
|
// Method of identifying different parts of solid (vertices/edges/faces) is
|
|
// a unique-id system. The AddFace/AddEdge/AddVertex functions assign each
|
|
// new "part" an id using GetNewID(). External objects referencing the CSSolid
|
|
// do not have to worry about keeping track of indices into the private
|
|
// arrays, since an ID is valid only if the part still exists. To get
|
|
// information about an ID, use the GetHandleInfo() function -> it returns
|
|
// FALSE if the given ID is no longer valid.
|
|
//
|
|
//=============================================================================
|
|
|
|
#include "stdafx.h"
|
|
#include "BrushOps.h"
|
|
#include "GameConfig.h"
|
|
#include "MapSolid.h"
|
|
#include "MapWorld.h"
|
|
#include "SSolid.h"
|
|
#include "StockSolids.h"
|
|
#include "Options.h"
|
|
#include "WorldSize.h"
|
|
#include "mapdisp.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include <tier0/memdbgon.h>
|
|
|
|
BOOL CheckFace(Vector *Points, int nPoints, Vector* pNormal, float dist, CCheckFaceInfo *pInfo)
|
|
{
|
|
int j;
|
|
float d, edgedist;
|
|
Vector dir, edgenormal;
|
|
|
|
if(!pInfo)
|
|
{
|
|
static CCheckFaceInfo dummyinfo;
|
|
pInfo = &dummyinfo;
|
|
pInfo->iPoint = -1; // make sure it's reset to default
|
|
}
|
|
|
|
if(pInfo->iPoint == -2)
|
|
return TRUE; // stop!!!!!
|
|
|
|
// do we need to create a normal?
|
|
if(!pNormal)
|
|
{
|
|
static Vector _normal;
|
|
pNormal = &_normal;
|
|
|
|
// calc a plane from the points
|
|
Vector t1, t2, t3;
|
|
|
|
for(int i = 0; i < 3; i++)
|
|
{
|
|
t1[i] = Points[0][i] - Points[1][i];
|
|
t2[i] = Points[2][i] - Points[1][i];
|
|
t3[i] = Points[1][i];
|
|
}
|
|
|
|
CrossProduct(t1, t2, *pNormal);
|
|
VectorNormalize(*pNormal);
|
|
dist = DotProduct(t3, *pNormal);
|
|
}
|
|
|
|
if(!nPoints)
|
|
{
|
|
strcpy(pInfo->szDescription, "no points");
|
|
pInfo->iPoint = -2;
|
|
return FALSE;
|
|
}
|
|
|
|
if(nPoints < 3)
|
|
{
|
|
strcpy(pInfo->szDescription, "fewer than three points");
|
|
pInfo->iPoint = -2;
|
|
return FALSE;
|
|
}
|
|
|
|
for(int i = pInfo->iPoint + 1; i < nPoints; i++ )
|
|
{
|
|
pInfo->iPoint = i;
|
|
|
|
Vector& p1 = Points[i];
|
|
|
|
for (j=0 ; j<3 ; j++)
|
|
{
|
|
if (p1[j] > MAX_COORD_INTEGER || p1[j] < MIN_COORD_INTEGER)
|
|
{
|
|
strcpy(pInfo->szDescription, "out of range");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
// check the point is on the face plane
|
|
d = DotProduct (p1, *pNormal) - dist;
|
|
if (d < -ON_PLANE_EPSILON || d > ON_PLANE_EPSILON)
|
|
{
|
|
strcpy(pInfo->szDescription, "point off plane");
|
|
return FALSE;
|
|
}
|
|
|
|
// check the edge isn't degenerate
|
|
Vector& p2 = Points[i+1 == nPoints ? 0 : i+1]; // (next point)
|
|
VectorSubtract (p2, p1, dir);
|
|
|
|
if (VectorLength (dir) < MIN_EDGE_LENGTH_EPSILON)
|
|
{
|
|
strcpy(pInfo->szDescription, "edge is too small");
|
|
return FALSE;
|
|
}
|
|
|
|
CrossProduct(*pNormal, dir, edgenormal);
|
|
VectorNormalize (edgenormal);
|
|
edgedist = DotProduct(p1, edgenormal);
|
|
edgedist += ON_PLANE_EPSILON;
|
|
|
|
// all other points must be on front side
|
|
for (j=0 ; j< nPoints; j++)
|
|
{
|
|
if (j == i)
|
|
continue;
|
|
d = DotProduct (Points[j], edgenormal);
|
|
if (d > edgedist)
|
|
{
|
|
strcpy(pInfo->szDescription, "face is not convex");
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
pInfo->iPoint = -2;
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Constructor.
|
|
//-----------------------------------------------------------------------------
|
|
CSSolid::CSSolid()
|
|
{
|
|
m_nVertices = 0;
|
|
m_nEdges = 0;
|
|
m_nFaces = 0;
|
|
m_curid = 1;
|
|
m_pMapSolid = NULL;
|
|
m_bShowVertices = TRUE;
|
|
m_bShowEdges = TRUE;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Destructor.
|
|
//-----------------------------------------------------------------------------
|
|
CSSolid::~CSSolid()
|
|
{
|
|
memset(this, 0, sizeof(this));
|
|
}
|
|
|
|
|
|
SSHANDLE CSSolid::GetNewID()
|
|
{
|
|
return m_curid++;
|
|
}
|
|
|
|
|
|
PVOID CSSolid::GetHandleData(SSHANDLE id)
|
|
{
|
|
SSHANDLEINFO hi;
|
|
if(!GetHandleInfo(&hi, id))
|
|
return NULL;
|
|
return hi.pData;
|
|
}
|
|
|
|
|
|
BOOL CSSolid::GetHandleInfo(SSHANDLEINFO *pInfo, SSHANDLE id)
|
|
{
|
|
// try vertices ..
|
|
for(int i = 0; i < m_nVertices; i++)
|
|
{
|
|
if(m_Vertices[i].id != id)
|
|
continue; // not this one
|
|
|
|
pInfo->Type = shtVertex;
|
|
pInfo->iIndex = i;
|
|
pInfo->pData = PVOID(& m_Vertices[i]);
|
|
pInfo->p2DHandle = & m_Vertices[i];
|
|
pInfo->pos = m_Vertices[i].pos;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// try edges ..
|
|
for(int i = 0; i < m_nEdges; i++)
|
|
{
|
|
if(m_Edges[i].id != id)
|
|
continue; // not this one
|
|
|
|
pInfo->Type = shtEdge;
|
|
pInfo->iIndex = i;
|
|
pInfo->pData = PVOID(& m_Edges[i]);
|
|
pInfo->p2DHandle = & m_Edges[i];
|
|
pInfo->pos = m_Edges[i].ptCenter;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// try faces ..
|
|
for(int i = 0; i < m_nFaces; i++)
|
|
{
|
|
if(m_Faces[i].id != id)
|
|
continue; // not this one
|
|
|
|
pInfo->Type = shtFace;
|
|
pInfo->iIndex = i;
|
|
pInfo->pData = PVOID(& m_Faces[i]);
|
|
pInfo->p2DHandle = & m_Faces[i];
|
|
pInfo->pos = m_Faces[i].ptCenter;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
pInfo->Type = shtNothing;
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// Find data functions ->
|
|
int CSSolid::GetEdgeIndex(SSHANDLE v1, SSHANDLE v2)
|
|
{
|
|
for(int i = 0; i < m_nEdges; i++)
|
|
{
|
|
CSSEdge & theEdge = m_Edges[i];
|
|
if((theEdge.hvStart == v1 && theEdge.hvEnd == v2) ||
|
|
(theEdge.hvStart == v2 && theEdge.hvEnd == v1))
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : Point -
|
|
// fLeniency -
|
|
// Output :
|
|
//-----------------------------------------------------------------------------
|
|
int CSSolid::GetEdgeIndex(const Vector &Point, float fLeniency)
|
|
{
|
|
for (int i = 0; i < m_nEdges; i++)
|
|
{
|
|
Vector ptEdgeCenter = m_Edges[i].ptCenter;
|
|
|
|
float fDiff = 0.0f;
|
|
for (int j = 0; j < 3; j++)
|
|
{
|
|
fDiff += (Point[j] - ptEdgeCenter[j]) * (Point[j] - ptEdgeCenter[j]);
|
|
}
|
|
|
|
if (fDiff > fLeniency * fLeniency)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// if we are here, the 3 axes compare ok.
|
|
return i;
|
|
}
|
|
|
|
// no edge matches
|
|
return -1;
|
|
}
|
|
|
|
|
|
int CSSolid::GetVertexIndex(const Vector &Point, float fLeniency)
|
|
{
|
|
for(int i = 0; i < m_nVertices; i++)
|
|
{
|
|
Vector Vertex = m_Vertices[i].pos;
|
|
|
|
float fDiff = 0.0f;
|
|
for(int j = 0; j < 3; j++)
|
|
{
|
|
fDiff += (Point[j] - Vertex[j]) * (Point[j] - Vertex[j]);
|
|
}
|
|
|
|
if (fDiff > (fLeniency*fLeniency))
|
|
continue;
|
|
|
|
// if we are here, the 3 axes compare ok.
|
|
return i;
|
|
}
|
|
|
|
// no vertex matches.
|
|
return -1;
|
|
}
|
|
|
|
|
|
int CSSolid::GetFaceIndex(const Vector &Point, float fLeniency)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Calculates the center of an edge.
|
|
// Input : pEdge -
|
|
//-----------------------------------------------------------------------------
|
|
void CSSolid::CalcEdgeCenter(CSSEdge *pEdge)
|
|
{
|
|
SSHANDLEINFO hi;
|
|
|
|
GetHandleInfo(&hi, pEdge->hvStart);
|
|
Vector &pt1 = m_Vertices[hi.iIndex].pos;
|
|
|
|
GetHandleInfo(&hi, pEdge->hvEnd);
|
|
Vector &pt2 = m_Vertices[hi.iIndex].pos;
|
|
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
pEdge->ptCenter[i] = (pt1[i] + pt2[i]) / 2.0f;
|
|
}
|
|
}
|
|
|
|
// get common vertex from two edges ->
|
|
|
|
SSHANDLE CSSolid::GetConnectionVertex(CSSEdge *pEdge1, CSSEdge *pEdge2)
|
|
{
|
|
if((pEdge1->hvStart == pEdge2->hvStart) ||
|
|
(pEdge1->hvStart == pEdge2->hvEnd))
|
|
return pEdge1->hvStart;
|
|
|
|
if((pEdge1->hvEnd == pEdge2->hvStart) ||
|
|
(pEdge1->hvEnd == pEdge2->hvEnd))
|
|
return pEdge1->hvEnd;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
// Create list of points from face ->
|
|
Vector * CSSolid::CreatePointList(CSSFace & face)
|
|
{
|
|
Vector * pts = new Vector[face.nEdges+1];
|
|
|
|
for(int i = 0; i < face.nEdges; i++)
|
|
{
|
|
// calc next edge so we can see which is the next clockwise point
|
|
int iNextEdge = i+1;
|
|
if(iNextEdge == face.nEdges)
|
|
iNextEdge = 0;
|
|
|
|
CSSEdge * edgeCur = (CSSEdge*) GetHandleData(face.Edges[i]);
|
|
CSSEdge * edgeNext = (CSSEdge*) GetHandleData(face.Edges[iNextEdge]);
|
|
|
|
if(!edgeCur || !edgeNext)
|
|
{
|
|
CString str;
|
|
str.Format("Conversion error!\n"
|
|
"edgeCur = %p, edgeNext = %p", edgeCur, edgeNext);
|
|
AfxMessageBox(str);
|
|
return NULL;
|
|
}
|
|
|
|
SSHANDLE hVertex = GetConnectionVertex(edgeCur, edgeNext);
|
|
|
|
if(!hVertex)
|
|
{
|
|
CString str;
|
|
str.Format("Conversion error!\n"
|
|
"hVertex = %08X", hVertex);
|
|
AfxMessageBox(str);
|
|
return NULL;
|
|
}
|
|
|
|
CSSVertex *pVertex = (CSSVertex*) GetHandleData(hVertex);
|
|
|
|
pts[i] = pVertex->pos;
|
|
}
|
|
|
|
return pts;
|
|
}
|
|
|
|
|
|
// Create point list, but return indices instead of positions ->
|
|
PINT CSSolid::CreatePointIndexList(CSSFace & face, PINT piPoints)
|
|
{
|
|
PINT pts;
|
|
if(piPoints)
|
|
pts = piPoints;
|
|
else
|
|
pts = new int[face.nEdges+1];
|
|
|
|
SSHANDLEINFO hi;
|
|
|
|
for(int i = 0; i < face.nEdges; i++)
|
|
{
|
|
// calc next edge so we can see which is the next clockwise point
|
|
int iNextEdge = i+1;
|
|
if(iNextEdge == face.nEdges)
|
|
iNextEdge = 0;
|
|
|
|
CSSEdge * edgeCur = (CSSEdge*) GetHandleData(face.Edges[i]);
|
|
CSSEdge * edgeNext = (CSSEdge*) GetHandleData(face.Edges[iNextEdge]);
|
|
|
|
SSHANDLE hVertex = GetConnectionVertex(edgeCur, edgeNext);
|
|
Assert(hVertex);
|
|
|
|
GetHandleInfo(&hi, hVertex);
|
|
pts[i] = hi.iIndex;
|
|
}
|
|
|
|
return pts;
|
|
}
|
|
|
|
// Create point list, and use handles ->
|
|
|
|
SSHANDLE* CSSolid::CreatePointHandleList(CSSFace & face, SSHANDLE* phPoints)
|
|
{
|
|
SSHANDLE* pts;
|
|
if(phPoints)
|
|
pts = phPoints;
|
|
else
|
|
pts = new SSHANDLE[face.nEdges+1];
|
|
|
|
for(int i = 0; i < face.nEdges; i++)
|
|
{
|
|
// calc next edge so we can see which is the next clockwise point
|
|
int iNextEdge = i+1;
|
|
if(iNextEdge == face.nEdges)
|
|
iNextEdge = 0;
|
|
|
|
CSSEdge * edgeCur = (CSSEdge*) GetHandleData(face.Edges[i]);
|
|
CSSEdge * edgeNext = (CSSEdge*) GetHandleData(face.Edges[iNextEdge]);
|
|
|
|
SSHANDLE hVertex = GetConnectionVertex(edgeCur, edgeNext);
|
|
Assert(hVertex);
|
|
|
|
pts[i] = hVertex;
|
|
}
|
|
|
|
return pts;
|
|
}
|
|
|
|
|
|
void CSSolid::Attach(CMapSolid *pMapSolid)
|
|
{
|
|
m_pMapSolid = pMapSolid;
|
|
}
|
|
|
|
|
|
CMapSolid *CSSolid::Detach()
|
|
{
|
|
CMapSolid *pTmp = m_pMapSolid;
|
|
m_pMapSolid = NULL;
|
|
return pTmp;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns whether or not the SSolid has displacements.
|
|
//-----------------------------------------------------------------------------
|
|
bool CSSolid::HasDisps( void )
|
|
{
|
|
for ( int iFace = 0; iFace < m_nFaces; ++iFace )
|
|
{
|
|
CSSFace *pFace = &m_Faces[iFace];
|
|
if ( pFace->m_hDisp != EDITDISPHANDLE_INVALID )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Check to see if the SSolid with displacement surfaces has valid
|
|
// base face surfaces.
|
|
//-----------------------------------------------------------------------------
|
|
bool CSSolid::IsValidWithDisps( void )
|
|
{
|
|
if ( !HasDisps() )
|
|
return true;
|
|
|
|
for ( int iFace = 0; iFace < m_nFaces; ++iFace )
|
|
{
|
|
// Get the face(s) that have displacements.
|
|
CSSFace *pFace = &m_Faces[iFace];
|
|
if ( pFace->m_hDisp == EDITDISPHANDLE_INVALID )
|
|
continue;
|
|
|
|
// Create a face point list.
|
|
Vector *pFacePoints = CreatePointList( *pFace );
|
|
|
|
// If the face has changed the number of points - via merges, etc.
|
|
if ( pFace->nEdges != 4 )
|
|
return false;
|
|
|
|
// Check the face for validity.
|
|
CCheckFaceInfo faceInfo;
|
|
if ( !CheckFace( pFacePoints, pFace->nEdges, NULL, 0.0f, &faceInfo ) )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Destroy all the displacement data on the SSolid.
|
|
//-----------------------------------------------------------------------------
|
|
void CSSolid::DestroyDisps( void )
|
|
{
|
|
for ( int iFace = 0; iFace < m_nFaces; ++iFace )
|
|
{
|
|
CSSFace *pFace = &m_Faces[iFace];
|
|
if ( pFace->m_hDisp != EDITDISPHANDLE_INVALID )
|
|
{
|
|
EditDispMgr()->Destroy( pFace->m_hDisp );
|
|
pFace->m_hDisp = EDITDISPHANDLE_INVALID;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CSSolid::Convert(BOOL bFromMap, bool bSkipDisplacementFaces )
|
|
{
|
|
if(bFromMap)
|
|
FromMapSolid(NULL, bSkipDisplacementFaces);
|
|
else
|
|
ToMapSolid();
|
|
}
|
|
|
|
|
|
void CSSolid::ToMapSolid(CMapSolid *p)
|
|
{
|
|
// so we can pass NULL (default) or another solid (to copy):
|
|
CMapSolid *pSolid;
|
|
if (p)
|
|
{
|
|
pSolid = p;
|
|
}
|
|
else
|
|
{
|
|
pSolid = m_pMapSolid;
|
|
}
|
|
|
|
pSolid->SetFaceCount(m_nFaces);
|
|
|
|
unsigned char r, g, b;
|
|
pSolid->GetRenderColor( r,g,b );
|
|
|
|
for (int i = 0; i < m_nFaces; i++)
|
|
{
|
|
CSSFace &pFace = m_Faces[i];
|
|
CMapFace SolidFace;
|
|
|
|
//
|
|
// Copy original texture information and face ID back.
|
|
//
|
|
Q_memcpy(&SolidFace.texture, &pFace.texture, sizeof(TEXTURE));
|
|
SolidFace.SetTexture(SolidFace.texture.texture);
|
|
SolidFace.SetFaceID(pFace.m_nFaceID);
|
|
|
|
//
|
|
// Create face from new points.
|
|
//
|
|
Vector *pts = CreatePointList(pFace);
|
|
|
|
SolidFace.CreateFace(pts, pFace.nEdges);
|
|
|
|
//
|
|
// Vertex manipulation; the face orientation may have changed. If one of the texture axes is now
|
|
// perpendicular to the face, recalculate the texture axes using the default alignment (world or face).
|
|
// Ideally we would transform the texture axes so that their orientation relative to the face is preserved.
|
|
// By reinitializing the axes we risk having the axes rotate unpredictably.
|
|
//
|
|
if (!SolidFace.IsTextureAxisValid())
|
|
{
|
|
SolidFace.InitializeTextureAxes(Options.GetTextureAlignment(), INIT_TEXTURE_AXES | INIT_TEXTURE_FORCE);
|
|
}
|
|
|
|
// Attempt to update the displacement - if there is one.
|
|
if ( pFace.m_hDisp != EDITDISPHANDLE_INVALID )
|
|
{
|
|
EditDispHandle_t hDisp = EditDispMgr()->Create();
|
|
CMapDisp *pSolidDisp = EditDispMgr()->GetDisp( hDisp );
|
|
CMapDisp *pDisp = EditDispMgr()->GetDisp( pFace.m_hDisp );
|
|
pSolidDisp->CopyFrom( pDisp, false );
|
|
int iStart = pSolidDisp->GetSurfPointStartIndex();
|
|
pSolidDisp->SetSurfPointStartIndex( (iStart+3)%4 );
|
|
pSolidDisp->InitDispSurfaceData( &SolidFace, false );
|
|
pSolidDisp->Create();
|
|
SolidFace.SetDisp( hDisp );
|
|
}
|
|
|
|
CMapFace *pNewFace = pSolid->GetFace( i );
|
|
pNewFace->CopyFrom( &SolidFace, COPY_FACE_POINTS);
|
|
pNewFace->SetRenderColor(r, g, b);
|
|
pNewFace->SetParent(pSolid);
|
|
|
|
delete[] pts;
|
|
}
|
|
|
|
pSolid->PostUpdate(Notify_Changed);
|
|
}
|
|
|
|
|
|
CSSFace* CSSolid::AddFace(int* piNewIndex)
|
|
{
|
|
m_Faces.SetCount(++m_nFaces);
|
|
if(piNewIndex)
|
|
piNewIndex[0] = m_nFaces-1;
|
|
CSSFace *pFace = & m_Faces[m_nFaces-1];
|
|
pFace->id = GetNewID();
|
|
return pFace;
|
|
}
|
|
|
|
// Add Edge ->
|
|
|
|
CSSEdge* CSSolid::AddEdge(int* piNewIndex)
|
|
{
|
|
m_Edges.SetCount(++m_nEdges);
|
|
if(piNewIndex)
|
|
piNewIndex[0] = m_nEdges-1;
|
|
CSSEdge *pEdge = & m_Edges[m_nEdges-1];
|
|
pEdge->id = GetNewID();
|
|
return pEdge;
|
|
}
|
|
|
|
// Add Vertex ->
|
|
|
|
CSSVertex* CSSolid::AddVertex(int* piNewIndex)
|
|
{
|
|
m_Vertices.SetCount(++m_nVertices);
|
|
if(piNewIndex)
|
|
piNewIndex[0] = m_nVertices-1;
|
|
CSSVertex *pVertex = & m_Vertices[m_nVertices-1];
|
|
pVertex->id = GetNewID();
|
|
return pVertex;
|
|
}
|
|
|
|
// Assign a face to an edge ->
|
|
|
|
void CSSolid::AssignFace(CSSEdge* pEdge, SSHANDLE hFace, BOOL bRemove)
|
|
{
|
|
if(!bRemove)
|
|
{
|
|
if(pEdge->Faces[0] == 0 || pEdge->Faces[0] == hFace)
|
|
pEdge->Faces[0] = hFace;
|
|
else if(pEdge->Faces[1] == 0)
|
|
pEdge->Faces[1] = hFace;
|
|
}
|
|
else
|
|
{
|
|
if(pEdge->Faces[0] == hFace)
|
|
pEdge->Faces[0] = 0;
|
|
if(pEdge->Faces[1] == hFace)
|
|
pEdge->Faces[1] = 0;
|
|
}
|
|
}
|
|
|
|
// Convert From Map Solid ->
|
|
|
|
void CSSolid::FromMapSolid(CMapSolid *p, bool bSkipDisplacementFaces)
|
|
{
|
|
// so we can pass NULL (default) or another solid (to copy):
|
|
CMapSolid *pSolid;
|
|
if(p)
|
|
pSolid = p;
|
|
else
|
|
pSolid = m_pMapSolid;
|
|
|
|
m_nFaces = 0;
|
|
m_nEdges = 0;
|
|
m_nVertices = 0;
|
|
|
|
// Create vertices, edges, faces.
|
|
int nSolidFaces = pSolid->GetFaceCount();
|
|
for(int i = 0; i < nSolidFaces; i++)
|
|
{
|
|
CMapFace *pSolidFace = pSolid->GetFace(i);
|
|
|
|
if (bSkipDisplacementFaces)
|
|
{
|
|
if (pSolidFace->HasDisp())
|
|
continue;
|
|
}
|
|
|
|
// Add a face
|
|
CSSFace *pFace = AddFace();
|
|
|
|
memcpy(pFace->PlanePts, pSolidFace->plane.planepts, sizeof(Vector) * 3);
|
|
pFace->texture = pSolidFace->texture;
|
|
pFace->normal = pSolidFace->plane.normal;
|
|
pFace->m_nFaceID = pSolidFace->GetFaceID();
|
|
|
|
// Displacement.
|
|
if ( pSolidFace->HasDisp() )
|
|
{
|
|
pFace->m_hDisp = EditDispMgr()->Create();
|
|
CMapDisp *pDisp = EditDispMgr()->GetDisp( pFace->m_hDisp );
|
|
CMapDisp *pSolidDisp = EditDispMgr()->GetDisp( pSolidFace->GetDisp() );
|
|
pDisp->CopyFrom( pSolidDisp, false );
|
|
}
|
|
|
|
// Convert vertices and edges
|
|
int nFacePoints = pSolidFace->nPoints;
|
|
Vector *pFacePoints = pSolidFace->Points;
|
|
SSHANDLE hLastVertex = 0; // valid IDs start at 1
|
|
SSHANDLE hThisVertex, hFirstVertex = 0;
|
|
for(int pt = 0; pt <= nFacePoints; pt++)
|
|
{
|
|
int iVertex;
|
|
|
|
if(pt < nFacePoints)
|
|
{
|
|
// YWB: Change leniency from 1.0 down to 0.1
|
|
iVertex = GetVertexIndex(pFacePoints[pt], 0.1f);
|
|
if (iVertex == -1)
|
|
{
|
|
// not found - add the vertex
|
|
CSSVertex *pVertex = AddVertex(&iVertex);
|
|
pVertex->pos = pFacePoints[pt];
|
|
}
|
|
|
|
// assign this vertex handle
|
|
hThisVertex = m_Vertices[iVertex].id;
|
|
|
|
if (pt == 0)
|
|
hFirstVertex = hThisVertex;
|
|
}
|
|
else
|
|
{
|
|
// connect last to first
|
|
hThisVertex = hFirstVertex;
|
|
}
|
|
|
|
if (hLastVertex)
|
|
{
|
|
// create the edge from the last vertex to current vertex.
|
|
// first check to see if this edge already exists..
|
|
int iEdge = GetEdgeIndex(hLastVertex, hThisVertex);
|
|
CSSEdge *pEdge;
|
|
if (iEdge == -1)
|
|
{
|
|
// not found - add new edge
|
|
pEdge = AddEdge(&iEdge);
|
|
pEdge->hvStart = hLastVertex;
|
|
pEdge->hvEnd = hThisVertex;
|
|
|
|
// make sure edge center is valid:
|
|
CalcEdgeCenter(pEdge);
|
|
}
|
|
else
|
|
{
|
|
pEdge = &m_Edges[iEdge];
|
|
}
|
|
|
|
// add the edge to the face
|
|
pFace->Edges[pFace->nEdges++] = pEdge->id;
|
|
|
|
// set edge's face array
|
|
if(!pEdge->Faces[0])
|
|
pEdge->Faces[0] = pFace->id;
|
|
else if(!pEdge->Faces[1])
|
|
pEdge->Faces[1] = pFace->id;
|
|
else
|
|
{
|
|
// YWB try filling in front side
|
|
// rather than Assert(0) crash
|
|
pEdge->Faces[0] = pFace->id;
|
|
AfxMessageBox("Edge with both face id's already filled, skipping...");
|
|
}
|
|
}
|
|
|
|
hLastVertex = hThisVertex;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Find edges that reference a vertex ->
|
|
|
|
CSSEdge ** CSSolid::FindAffectedEdges(SSHANDLE *pHandles, int iNumHandles, int& iNumEdges)
|
|
{
|
|
static CSSEdge *ppEdges[128];
|
|
iNumEdges = 0;
|
|
|
|
for(int h = 0; h < iNumHandles; h++)
|
|
{
|
|
for(int i = 0; i < m_nEdges; i++)
|
|
{
|
|
CSSEdge *pEdge = &m_Edges[i];
|
|
if(pEdge->hvStart == pHandles[h] ||
|
|
pEdge->hvEnd == pHandles[h])
|
|
{
|
|
// ensure it's not already stored
|
|
int s;
|
|
for(s = 0; s < iNumEdges; s++)
|
|
{
|
|
if(ppEdges[s] == pEdge)
|
|
break;
|
|
}
|
|
if(s == iNumEdges)
|
|
ppEdges[iNumEdges++] = pEdge;
|
|
}
|
|
}
|
|
}
|
|
|
|
return ppEdges;
|
|
}
|
|
|
|
|
|
// tell drawing code to show/hide kinds of handles
|
|
void CSSolid::ShowHandles(BOOL bShowVertices, BOOL bShowEdges)
|
|
{
|
|
m_bShowEdges = bShowEdges;
|
|
m_bShowVertices = bShowVertices;
|
|
}
|
|
|
|
|
|
// Move handle(s) to a new location ->
|
|
void CSSolid::MoveSelectedHandles(const Vector &Delta)
|
|
{
|
|
SSHANDLE MoveVertices[128];
|
|
int nMoveVertices = 0;
|
|
|
|
SSHANDLEINFO hi;
|
|
|
|
for(int i = 0; i < m_nVertices; i++)
|
|
{
|
|
if(m_Vertices[i].m_bSelected)
|
|
MoveVertices[nMoveVertices++] = m_Vertices[i].id;
|
|
}
|
|
|
|
for(int i = 0; i < m_nEdges; i++)
|
|
{
|
|
CSSEdge* pEdge = &m_Edges[i];
|
|
|
|
if(!pEdge->m_bSelected) // make sure it's selected
|
|
continue;
|
|
|
|
// add edge's vertices to the movement list
|
|
BOOL bAddStart = TRUE, bAddEnd = TRUE;
|
|
for(int i2 = 0; i2 < nMoveVertices; i2++)
|
|
{
|
|
if(pEdge->hvStart == MoveVertices[i2])
|
|
bAddStart = FALSE; // already got this one
|
|
if(pEdge->hvEnd == MoveVertices[i2])
|
|
bAddEnd = FALSE; // already got this one
|
|
}
|
|
|
|
if(bAddStart)
|
|
MoveVertices[nMoveVertices++] = pEdge->hvStart;
|
|
if(bAddEnd)
|
|
MoveVertices[nMoveVertices++] = pEdge->hvEnd;
|
|
}
|
|
|
|
// move vertices now
|
|
for(int i = 0; i < nMoveVertices; i++)
|
|
{
|
|
GetHandleInfo(&hi, MoveVertices[i]);
|
|
CSSVertex* pVertex = (CSSVertex*) hi.pData;
|
|
SetVertexPosition(hi.iIndex, pVertex->pos[0] + Delta[0], pVertex->pos[1] + Delta[1], pVertex->pos[2] + Delta[2]);
|
|
}
|
|
|
|
// calculate center of moved edges
|
|
int nEdges;
|
|
CSSEdge ** ppEdges = FindAffectedEdges(MoveVertices, nMoveVertices, nEdges);
|
|
for(int i = 0; i < nEdges; i++)
|
|
{
|
|
CalcEdgeCenter(ppEdges[i]);
|
|
}
|
|
}
|
|
|
|
|
|
// check faces for irregularities ->
|
|
void CSSolid::CheckFaces()
|
|
{
|
|
for(int i = 0; i < m_nFaces; i++)
|
|
{
|
|
CSSFace &face = m_Faces[i];
|
|
|
|
// get points for face
|
|
Vector *pts = CreatePointList(face);
|
|
|
|
// call checkface function
|
|
CCheckFaceInfo cfi;
|
|
|
|
while(CheckFace(pts, face.nEdges, NULL, 0, &cfi) == FALSE)
|
|
{
|
|
CString str;
|
|
str.Format("face %d - %s", i, cfi.szDescription);
|
|
AfxMessageBox(str);
|
|
}
|
|
|
|
delete[] pts;
|
|
}
|
|
}
|
|
|
|
|
|
void CSSolid::SetVertexPosition(int iVertex, float x, float y, float z)
|
|
{
|
|
m_Vertices[iVertex].pos = Vector(x, y, z);
|
|
}
|
|
|
|
|
|
static int GetNext(int iIndex, int iDirection, int iMax)
|
|
{
|
|
iIndex += iDirection;
|
|
if(iIndex == iMax)
|
|
iIndex = 0;
|
|
if(iIndex == -1)
|
|
iIndex = iMax-1;
|
|
return iIndex;
|
|
}
|
|
|
|
|
|
BOOL CSSolid::SplitFace(SSHANDLE h1, SSHANDLE h2)
|
|
{
|
|
SSHANDLEINFO hi;
|
|
GetHandleInfo(&hi, h1);
|
|
|
|
if(m_nFaces == MAX_FACES-1)
|
|
return FALSE;
|
|
|
|
BOOL bRvl = FALSE;
|
|
|
|
if(hi.Type == shtEdge)
|
|
{
|
|
// edge-based face split
|
|
bRvl = SplitFaceByEdges((CSSEdge*) hi.pData,
|
|
(CSSEdge*) GetHandleData(h2));
|
|
}
|
|
else if(hi.Type == shtVertex)
|
|
{
|
|
// vertex-based face split
|
|
bRvl = SplitFaceByVertices((CSSVertex*) hi.pData,
|
|
(CSSVertex*) GetHandleData(h2));
|
|
}
|
|
|
|
return bRvl;
|
|
}
|
|
|
|
|
|
BOOL CSSolid::SplitFaceByVertices(CSSVertex *pVertex1, CSSVertex *pVertex2)
|
|
{
|
|
if(GetEdgeIndex(pVertex1->id, pVertex2->id) != -1)
|
|
return FALSE; // already an edge there!
|
|
|
|
// find the face, first - get a list of affected edges and find
|
|
// two with a common face
|
|
int iNumEdges1, iNumEdges2;
|
|
SSHANDLE hFace = 0;
|
|
CSSEdge *pEdges1[64], *pEdges2[64], **pTmp;
|
|
|
|
pTmp = FindAffectedEdges(&pVertex1->id, 1, iNumEdges1);
|
|
memcpy(pEdges1, pTmp, iNumEdges1 * sizeof(CSSEdge*));
|
|
pTmp = FindAffectedEdges(&pVertex2->id, 1, iNumEdges2);
|
|
memcpy(pEdges2, pTmp, iNumEdges2 * sizeof(CSSEdge*));
|
|
|
|
for(int i = 0; i < iNumEdges1; i++)
|
|
{
|
|
SSHANDLE hFace0 = pEdges1[i]->Faces[0];
|
|
SSHANDLE hFace1 = pEdges1[i]->Faces[1];
|
|
for(int i2 = 0; i2 < iNumEdges2; i2++)
|
|
{
|
|
if(hFace0 == pEdges2[i2]->Faces[0] ||
|
|
hFace0 == pEdges2[i2]->Faces[1])
|
|
{
|
|
hFace = hFace0;
|
|
break;
|
|
}
|
|
else if(hFace1 == pEdges2[i2]->Faces[0] ||
|
|
hFace1 == pEdges2[i2]->Faces[1])
|
|
{
|
|
hFace = hFace1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// couldn't find a common face
|
|
if(hFace == 0)
|
|
return FALSE;
|
|
|
|
CSSFace *pFace = (CSSFace*) GetHandleData(hFace);
|
|
|
|
// create a new face
|
|
CSSFace *pNewFace = AddFace();
|
|
memcpy(&pNewFace->texture, &pFace->texture, sizeof(TEXTURE));
|
|
|
|
// create a new edge between two vertices
|
|
CSSEdge *pNewEdge = AddEdge();
|
|
pNewEdge->hvStart = pVertex1->id;
|
|
pNewEdge->hvEnd = pVertex2->id;
|
|
CalcEdgeCenter(pNewEdge);
|
|
|
|
// assign face ids to the new edge
|
|
AssignFace(pNewEdge, pFace->id);
|
|
AssignFace(pNewEdge, pNewFace->id);
|
|
|
|
// set up edges - start with newvertex1
|
|
SSHANDLE hNewEdges[64];
|
|
int nNewEdges;
|
|
BOOL bFirst = TRUE;
|
|
CSSFace *pStoreFace = pFace;
|
|
|
|
SSHANDLE *phVertexList = CreatePointHandleList(*pFace);
|
|
int nVertices = pFace->nEdges;
|
|
|
|
int v1index = 0, v2index = 0;
|
|
|
|
// find where the vertices are and
|
|
// kill face references in edges first
|
|
for(int i = 0; i < nVertices; i++)
|
|
{
|
|
int iNextVertex = GetNext(i, 1, nVertices);
|
|
int iEdgeIndex = GetEdgeIndex(phVertexList[i],
|
|
phVertexList[iNextVertex]);
|
|
CSSEdge *pEdge = &m_Edges[iEdgeIndex];
|
|
AssignFace(pEdge, pFace->id, TRUE);
|
|
|
|
if(phVertexList[i] == pVertex1->id)
|
|
v1index = i;
|
|
else if(phVertexList[i] == pVertex2->id)
|
|
v2index = i;
|
|
}
|
|
|
|
DoNextFace:
|
|
nNewEdges = 0;
|
|
for(int i = v1index; ; i++)
|
|
{
|
|
if(i == nVertices)
|
|
i = 0;
|
|
|
|
if(i == v2index)
|
|
break;
|
|
|
|
int iNextVertex = GetNext(i, 1, nVertices);
|
|
int iEdgeIndex = GetEdgeIndex(phVertexList[i], phVertexList[iNextVertex]);
|
|
Assert(iEdgeIndex != -1);
|
|
|
|
hNewEdges[nNewEdges++] = m_Edges[iEdgeIndex].id;
|
|
|
|
AssignFace(&m_Edges[iEdgeIndex], pFace->id);
|
|
}
|
|
// now add the middle edge
|
|
hNewEdges[nNewEdges++] = pNewEdge->id;
|
|
// now set up in face
|
|
pStoreFace->nEdges = nNewEdges;
|
|
memcpy(pStoreFace->Edges, hNewEdges, sizeof(SSHANDLE) * nNewEdges);
|
|
|
|
if(bFirst)
|
|
{
|
|
int tmp = v1index;
|
|
v1index = v2index;
|
|
v2index = tmp;
|
|
pStoreFace = pNewFace;
|
|
bFirst = FALSE;
|
|
goto DoNextFace;
|
|
}
|
|
|
|
delete phVertexList;
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
BOOL CSSolid::SplitFaceByEdges(CSSEdge *pEdge1, CSSEdge *pEdge2)
|
|
{
|
|
SSHANDLE hFace;
|
|
|
|
// find the handle of the face
|
|
if(pEdge1->Faces[0] == pEdge2->Faces[0] ||
|
|
pEdge1->Faces[0] == pEdge2->Faces[1])
|
|
{
|
|
hFace = pEdge1->Faces[0];
|
|
}
|
|
else if(pEdge1->Faces[1] == pEdge2->Faces[0] ||
|
|
pEdge1->Faces[1] == pEdge2->Faces[1])
|
|
{
|
|
hFace = pEdge1->Faces[1];
|
|
}
|
|
else return FALSE; // not the same face
|
|
|
|
// get pointer to face
|
|
CSSFace *pFace = (CSSFace*) GetHandleData(hFace);
|
|
|
|
// create new objects
|
|
CSSFace *pNewFace = AddFace();
|
|
CSSEdge *pNewEdgeMid = AddEdge();
|
|
int iNewVertex1, iNewVertex2;
|
|
CSSVertex *pNewVertex1 = AddVertex(&iNewVertex1);
|
|
CSSVertex *pNewVertex2 = AddVertex(&iNewVertex2);
|
|
|
|
// assign faces to new edge
|
|
AssignFace(pNewEdgeMid, pFace->id);
|
|
AssignFace(pNewEdgeMid, pNewFace->id);
|
|
|
|
// copy texture info from one face to the other
|
|
memcpy(&pNewFace->texture, &pFace->texture, sizeof(TEXTURE));
|
|
|
|
// set vertex positions
|
|
m_Vertices[iNewVertex1].pos = pEdge1->ptCenter;
|
|
m_Vertices[iNewVertex2].pos = pEdge2->ptCenter;
|
|
|
|
// set up middle edge
|
|
pNewEdgeMid->hvStart = pNewVertex1->id;
|
|
pNewEdgeMid->hvEnd = pNewVertex2->id;
|
|
CalcEdgeCenter(pNewEdgeMid);
|
|
|
|
// set up new side edges
|
|
CSSEdge *pEdgeTmp = AddEdge();
|
|
pEdgeTmp->hvStart = pEdge1->hvStart;
|
|
pEdgeTmp->hvEnd = pNewVertex1->id;
|
|
CalcEdgeCenter(pEdgeTmp);
|
|
|
|
pEdgeTmp = AddEdge();
|
|
pEdgeTmp->hvStart = pEdge1->hvEnd;
|
|
pEdgeTmp->hvEnd = pNewVertex1->id;
|
|
CalcEdgeCenter(pEdgeTmp);
|
|
|
|
pEdgeTmp = AddEdge();
|
|
pEdgeTmp->hvStart = pEdge2->hvStart;
|
|
pEdgeTmp->hvEnd = pNewVertex2->id;
|
|
CalcEdgeCenter(pEdgeTmp);
|
|
|
|
pEdgeTmp = AddEdge();
|
|
pEdgeTmp->hvStart = pEdge2->hvEnd;
|
|
pEdgeTmp->hvEnd = pNewVertex2->id;
|
|
CalcEdgeCenter(pEdgeTmp);
|
|
|
|
/*
|
|
FILE *fp = fopen("split", "w");
|
|
for(i = 0; i < nVertices; i++)
|
|
{
|
|
fprintf(fp, "%lu\n", phVertexList[i]);
|
|
}
|
|
fclose(fp);
|
|
*/
|
|
|
|
// set up edges - start with newvertex1
|
|
SSHANDLE hNewEdges[64];
|
|
int nNewEdges;
|
|
BOOL bFirst = TRUE;
|
|
CSSFace *pStoreFace = pFace;
|
|
|
|
// ** do two new faces first **
|
|
|
|
int nv1index, nv2index;
|
|
SSHANDLE *phVertexList = CreateNewVertexList(pFace, pEdge1, pEdge2,
|
|
nv1index, nv2index, pNewVertex1, pNewVertex2);
|
|
int nVertices = pFace->nEdges;
|
|
if(nv1index != -1)
|
|
++nVertices;
|
|
if(nv2index != -1)
|
|
++nVertices;
|
|
|
|
// kill face references in edges first
|
|
for(int i = 0; i < nVertices; i++)
|
|
{
|
|
int iNextVertex = GetNext(i, 1, nVertices);
|
|
int iEdgeIndex = GetEdgeIndex(phVertexList[i],
|
|
phVertexList[iNextVertex]);
|
|
CSSEdge *pEdge = &m_Edges[iEdgeIndex];
|
|
Assert(pEdge->id != pEdge1->id);
|
|
Assert(pEdge->id != pEdge2->id);
|
|
AssignFace(pEdge, pFace->id, TRUE);
|
|
}
|
|
|
|
DoNextFace:
|
|
nNewEdges = 0;
|
|
for(int i = nv1index; ; i++)
|
|
{
|
|
if(i == nVertices)
|
|
i = 0;
|
|
|
|
if(i == nv2index)
|
|
break;
|
|
|
|
int iNextVertex = GetNext(i, 1, nVertices);
|
|
int iEdgeIndex = GetEdgeIndex(phVertexList[i], phVertexList[iNextVertex]);
|
|
Assert(iEdgeIndex != -1);
|
|
|
|
hNewEdges[nNewEdges++] = m_Edges[iEdgeIndex].id;
|
|
|
|
AssignFace(&m_Edges[iEdgeIndex], pStoreFace->id);
|
|
}
|
|
// now add the middle edge
|
|
hNewEdges[nNewEdges++] = pNewEdgeMid->id;
|
|
// now set up in face
|
|
pStoreFace->nEdges = nNewEdges;
|
|
memcpy(pStoreFace->Edges, hNewEdges, sizeof(SSHANDLE) * nNewEdges);
|
|
|
|
if(bFirst)
|
|
{
|
|
int tmp = nv1index;
|
|
nv1index = nv2index;
|
|
nv2index = tmp;
|
|
pStoreFace = pNewFace;
|
|
bFirst = FALSE;
|
|
goto DoNextFace;
|
|
}
|
|
|
|
delete phVertexList;
|
|
|
|
// ** now regular faces **
|
|
for(int iFace = 0; iFace < m_nFaces; iFace++)
|
|
{
|
|
CSSFace *pUpdFace = &m_Faces[iFace];
|
|
|
|
if(pUpdFace == pNewFace || pUpdFace == pFace)
|
|
continue;
|
|
|
|
phVertexList = CreateNewVertexList(pUpdFace, pEdge1, pEdge2,
|
|
nv1index, nv2index, pNewVertex1, pNewVertex2);
|
|
|
|
if(phVertexList == NULL) // don't need to update this face
|
|
continue;
|
|
|
|
nNewEdges = 0;
|
|
nVertices = pUpdFace->nEdges;
|
|
if(nv1index != -1)
|
|
++nVertices;
|
|
if(nv2index != -1)
|
|
++nVertices;
|
|
for(int i = 0; i < nVertices; i++)
|
|
{
|
|
int iNextVertex = GetNext(i, 1, nVertices);
|
|
int iEdgeIndex = GetEdgeIndex(phVertexList[i], phVertexList[iNextVertex]);
|
|
Assert(iEdgeIndex != -1);
|
|
|
|
AssignFace(&m_Edges[iEdgeIndex], pUpdFace->id);
|
|
hNewEdges[nNewEdges++] = m_Edges[iEdgeIndex].id;
|
|
}
|
|
|
|
// now set up in face
|
|
pUpdFace->nEdges = nNewEdges;
|
|
memcpy(pUpdFace->Edges, hNewEdges, sizeof(SSHANDLE) * nNewEdges);
|
|
|
|
delete phVertexList;
|
|
}
|
|
|
|
SSHANDLE id1 = pEdge1->id;
|
|
SSHANDLE id2 = pEdge2->id;
|
|
|
|
// delete old edges
|
|
for(int i = 0; i < m_nEdges; i++)
|
|
{
|
|
if(m_Edges[i].id == id1 || m_Edges[i].id == id2)
|
|
{
|
|
DeleteEdge(i);
|
|
--i;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void CSSolid::DeleteEdge(int iEdge)
|
|
{
|
|
SSHANDLE edgeid = m_Edges[iEdge].id;
|
|
|
|
// kill this edge
|
|
for(int i2 = iEdge; i2 < m_nEdges-1; i2++)
|
|
{
|
|
memcpy(&m_Edges[i2], &m_Edges[i2+1], sizeof(CSSEdge));
|
|
}
|
|
--m_nEdges;
|
|
|
|
memset(&m_Edges[m_nEdges], 0, sizeof(CSSEdge));
|
|
|
|
// kill all references to this edge in faces
|
|
for(int f = 0; f < m_nFaces; f++)
|
|
{
|
|
CSSFace& face = m_Faces[f];
|
|
for(int e = 0; e < face.nEdges; e++)
|
|
{
|
|
if(face.Edges[e] != edgeid)
|
|
continue;
|
|
|
|
memcpy(&face.Edges[e], &face.Edges[e+1], (face.nEdges-e) *
|
|
sizeof(face.Edges[0]));
|
|
--face.nEdges;
|
|
break; // no more in this face
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CSSolid::DeleteVertex(int iVertex)
|
|
{
|
|
for(int i2 = iVertex; i2 < m_nVertices-1; i2++)
|
|
{
|
|
memcpy(&m_Vertices[i2], &m_Vertices[i2+1], sizeof(CSSVertex));
|
|
}
|
|
--m_nVertices;
|
|
|
|
memset(&m_Vertices[m_nVertices], 0, sizeof(CSSVertex));
|
|
}
|
|
|
|
|
|
void CSSolid::DeleteFace(int iFace)
|
|
{
|
|
// Destroy the displacement if there is one.
|
|
CSSFace *pFace = &m_Faces[iFace];
|
|
if ( pFace )
|
|
{
|
|
if ( pFace->m_hDisp != EDITDISPHANDLE_INVALID )
|
|
{
|
|
EditDispMgr()->Destroy( pFace->m_hDisp );
|
|
pFace->m_hDisp = EDITDISPHANDLE_INVALID;
|
|
}
|
|
}
|
|
|
|
for(int i2 = iFace; i2 < m_nFaces-1; i2++)
|
|
{
|
|
memcpy(&m_Faces[i2], &m_Faces[i2+1], sizeof(CSSFace));
|
|
}
|
|
--m_nFaces;
|
|
|
|
m_Faces[m_nFaces].Init();
|
|
}
|
|
|
|
|
|
SSHANDLE* CSSolid::CreateNewVertexList(CSSFace *pFace, CSSEdge *pEdge1,
|
|
CSSEdge *pEdge2, int& nv1index, int& nv2index,
|
|
CSSVertex *pNewVertex1, CSSVertex *pNewVertex2)
|
|
{
|
|
// get original vertex list
|
|
CUtlVector<SSHANDLE> hVertexList;
|
|
hVertexList.SetCount(pFace->nEdges+4);
|
|
CreatePointHandleList(*pFace, hVertexList.Base());
|
|
|
|
// add vertex1 and vertex2.
|
|
nv1index = -1;
|
|
nv2index = -1;
|
|
|
|
int nVertices = pFace->nEdges;
|
|
int iPass = 0;
|
|
DoAgain:
|
|
for(int i = 0; i < nVertices; i++)
|
|
{
|
|
int iPrevIndex = GetNext(i, -1, nVertices);
|
|
int iNextIndex = GetNext(i, 1, nVertices);
|
|
|
|
if(nv1index == -1 && (hVertexList[i] == pEdge1->hvEnd ||
|
|
hVertexList[i] == pEdge1->hvStart))
|
|
{
|
|
// find pEdge1->hvStart
|
|
if(hVertexList[iPrevIndex] == pEdge1->hvStart ||
|
|
hVertexList[iPrevIndex] == pEdge1->hvEnd)
|
|
{
|
|
// add at i.
|
|
nv1index = i;
|
|
}
|
|
if(hVertexList[iNextIndex] == pEdge1->hvStart ||
|
|
hVertexList[iNextIndex] == pEdge1->hvEnd)
|
|
{
|
|
// add at iNextIndex
|
|
nv1index = iNextIndex;
|
|
}
|
|
|
|
if(nv1index != -1)
|
|
{
|
|
hVertexList.InsertBefore(nv1index, pNewVertex1->id);
|
|
++nVertices;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(nv2index == -1 && (hVertexList[i] == pEdge2->hvEnd ||
|
|
hVertexList[i] == pEdge2->hvStart))
|
|
{
|
|
// find pEdge1->hvStart
|
|
if(hVertexList[iPrevIndex] == pEdge2->hvStart ||
|
|
hVertexList[iPrevIndex] == pEdge2->hvEnd)
|
|
{
|
|
// add at i.
|
|
nv2index = i;
|
|
}
|
|
if(hVertexList[iNextIndex] == pEdge2->hvStart ||
|
|
hVertexList[iNextIndex] == pEdge2->hvEnd)
|
|
{
|
|
// add at iNextIndex
|
|
nv2index = iNextIndex;
|
|
}
|
|
|
|
if(nv2index != -1)
|
|
{
|
|
hVertexList.InsertBefore(nv2index, pNewVertex2->id);
|
|
++nVertices;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
SSHANDLE hTmp[64];
|
|
memcpy(hTmp, hVertexList.Base(), sizeof(SSHANDLE) * nVertices);
|
|
|
|
if(nv1index == -1 && nv2index == -1)
|
|
return NULL; // not used here.
|
|
|
|
if(nv1index == -1 || nv2index == -1)
|
|
{
|
|
if(++iPass != 2)
|
|
goto DoAgain;
|
|
}
|
|
|
|
SSHANDLE *rvl = new SSHANDLE[nVertices];
|
|
memcpy(rvl, hVertexList.Base(), sizeof(SSHANDLE) * nVertices);
|
|
|
|
return rvl;
|
|
}
|
|
|
|
// merge same vertices ->
|
|
|
|
BOOL CSSolid::CanMergeVertices()
|
|
{
|
|
for(int v1 = 0; v1 < m_nVertices; v1++)
|
|
{
|
|
for(int v2 = 0; v2 < m_nVertices; v2++)
|
|
{
|
|
if(v1 == v2)
|
|
continue; // no!
|
|
if(VectorCompare(m_Vertices[v1].pos, m_Vertices[v2].pos))
|
|
return TRUE; // got a match
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
SSHANDLE * CSSolid::MergeSameVertices(int& nDeleted)
|
|
{
|
|
int nMerged = 0;
|
|
nDeleted = 0;
|
|
static SSHANDLE hDeletedList[128];
|
|
|
|
DoVertices:
|
|
for(int v1 = 0; v1 < m_nVertices; v1++)
|
|
{
|
|
for(int v2 = 0; v2 < m_nVertices; v2++)
|
|
{
|
|
if(v1 == v2)
|
|
continue; // no!
|
|
if(!VectorCompare(m_Vertices[v1].pos, m_Vertices[v2].pos))
|
|
{ // no match
|
|
continue;
|
|
}
|
|
|
|
++nMerged;
|
|
|
|
// same vertices - kill v1, set edge refs to use v2.
|
|
SSHANDLE hV1 = m_Vertices[v1].id;
|
|
SSHANDLE hV2 = m_Vertices[v2].id;
|
|
|
|
hDeletedList[nDeleted++] = hV1;
|
|
|
|
DeleteVertex(v1);
|
|
|
|
int nAffected;
|
|
CSSEdge **ppEdges = FindAffectedEdges(&hV1, 1, nAffected);
|
|
|
|
// run through edges and change references
|
|
for(int e = 0; e < nAffected; e++)
|
|
{
|
|
if(ppEdges[e]->hvStart == hV1)
|
|
ppEdges[e]->hvStart = hV2;
|
|
if(ppEdges[e]->hvEnd == hV1)
|
|
ppEdges[e]->hvEnd = hV2;
|
|
CalcEdgeCenter(ppEdges[e]);
|
|
}
|
|
|
|
goto DoVertices;
|
|
}
|
|
}
|
|
|
|
if(!nMerged)
|
|
return NULL;
|
|
|
|
int e;
|
|
|
|
// kill edges that have same vertices
|
|
for(e = 0; e < m_nEdges; e++)
|
|
{
|
|
CSSEdge &edge = m_Edges[e];
|
|
|
|
if(edge.hvStart != edge.hvEnd)
|
|
continue; // edge is OK
|
|
|
|
hDeletedList[nDeleted++] = edge.id;
|
|
|
|
DeleteEdge(e);
|
|
--e;
|
|
}
|
|
|
|
// kill similar edges (replace in faces too)
|
|
DoEdges:
|
|
for(e = 0; e < m_nEdges; e++)
|
|
{
|
|
CSSEdge &edge = m_Edges[e];
|
|
|
|
for(int e2 = 0; e2 < m_nEdges; e2++)
|
|
{
|
|
if(e == e2)
|
|
continue;
|
|
|
|
CSSEdge &edge2 = m_Edges[e2];
|
|
|
|
if(!((edge2.hvStart == edge.hvStart && edge2.hvEnd == edge.hvEnd) ||
|
|
(edge2.hvEnd == edge.hvStart && edge2.hvStart == edge.hvEnd)))
|
|
continue;
|
|
|
|
// we're going to delete edge2.
|
|
SSHANDLE id2 = edge2.id;
|
|
SSHANDLE id1 = edge.id;
|
|
|
|
for(int f = 0; f < m_nFaces; f++)
|
|
{
|
|
CSSFace& face = m_Faces[f];
|
|
for(int ef = 0; ef < face.nEdges; ef++)
|
|
{
|
|
if(face.Edges[ef] == id2)
|
|
{
|
|
face.Edges[ef] = id1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
hDeletedList[nDeleted++] = id2;
|
|
DeleteEdge(e2);
|
|
|
|
goto DoEdges;
|
|
}
|
|
}
|
|
|
|
// delete concurrent edge references in face
|
|
for(int f = 0; f < m_nFaces; f++)
|
|
{
|
|
CSSFace& face = m_Faces[f];
|
|
|
|
DoConcurrentEdges:
|
|
for(int ef1 = 0; ef1 < face.nEdges; ef1++)
|
|
{
|
|
for(int ef2 = 0; ef2 < face.nEdges; ef2++)
|
|
{
|
|
if(ef2 == ef1)
|
|
continue;
|
|
|
|
if(face.Edges[ef1] != face.Edges[ef2])
|
|
continue;
|
|
|
|
// delete this ref
|
|
memcpy(&face.Edges[ef2], &face.Edges[ef2+1], (face.nEdges-ef2) *
|
|
sizeof(face.Edges[0]));
|
|
--face.nEdges;
|
|
|
|
goto DoConcurrentEdges;
|
|
}
|
|
}
|
|
|
|
if(face.nEdges < 3)
|
|
{
|
|
// kill this face
|
|
hDeletedList[nDeleted++] = face.id;
|
|
DeleteFace(f);
|
|
--f;
|
|
}
|
|
}
|
|
|
|
return hDeletedList;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Constructor.
|
|
//-----------------------------------------------------------------------------
|
|
CSSFace::CSSFace(void)
|
|
{
|
|
Init();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Initialize the SSFace.
|
|
//-----------------------------------------------------------------------------
|
|
void CSSFace::Init(void)
|
|
{
|
|
nEdges = 0;
|
|
bModified = FALSE;
|
|
|
|
m_nFaceID = 0;
|
|
m_hDisp = EDITDISPHANDLE_INVALID;
|
|
|
|
memset(&texture, 0, sizeof(TEXTURE));
|
|
|
|
texture.scale[0] = g_pGameConfig->GetDefaultTextureScale();
|
|
texture.scale[1] = g_pGameConfig->GetDefaultTextureScale();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Destructor.
|
|
//-----------------------------------------------------------------------------
|
|
CSSFace::~CSSFace(void)
|
|
{
|
|
if ( m_hDisp != EDITDISPHANDLE_INVALID )
|
|
{
|
|
EditDispMgr()->Destroy( m_hDisp );
|
|
m_hDisp = EDITDISPHANDLE_INVALID;
|
|
}
|
|
|
|
memset(this, 0, sizeof(this));
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Constructor.
|
|
//-----------------------------------------------------------------------------
|
|
CSSEdge::CSSEdge(void)
|
|
{
|
|
Faces[0] = Faces[1] = 0;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Destructor.
|
|
//-----------------------------------------------------------------------------
|
|
CSSEdge::~CSSEdge()
|
|
{
|
|
memset(this, 0, sizeof(this));
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Gets the world coordinates of the center point of this edge.
|
|
// Input : Point - Receives the world coordinates of the center point.
|
|
//-----------------------------------------------------------------------------
|
|
void CSSEdge::GetCenterPoint(Vector& Point)
|
|
{
|
|
Point = ptCenter;
|
|
}
|
|
|
|
|
|
CSSVertex::CSSVertex(void)
|
|
{
|
|
}
|
|
|
|
|
|
CSSVertex::~CSSVertex(void)
|
|
{
|
|
pos[0] = pos[1] = pos[2] = 0;
|
|
id = 0;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Gets the world coordinates of this vertex.
|
|
// Input : Position - Receives the world coordinates.
|
|
//-----------------------------------------------------------------------------
|
|
void CSSVertex::GetPosition(Vector& Position)
|
|
{
|
|
Position = pos;
|
|
}
|
|
|
|
|
|
//
|
|
// save to .DXF
|
|
//
|
|
void CSSolid::SerializeDXF(FILE *stream, int nObject)
|
|
{
|
|
char szName[128];
|
|
sprintf(szName, "OBJECT%03d", nObject);
|
|
|
|
// count number of triangulated faces
|
|
int nTriFaces = 0;
|
|
for(int i = 0; i < m_nFaces; i++)
|
|
{
|
|
CSSFace &face = m_Faces[i];
|
|
nTriFaces += face.nEdges-2;
|
|
}
|
|
|
|
fprintf(stream,"0\nPOLYLINE\n8\n%s\n66\n1\n70\n64\n71\n%u\n72\n%u\n", szName, m_nVertices, nTriFaces);
|
|
fprintf(stream,"62\n50\n");
|
|
|
|
for (int i = 0; i < m_nVertices; i++)
|
|
{
|
|
Vector &pos = m_Vertices[i].pos;
|
|
fprintf(stream, "0\nVERTEX\n8\n%s\n10\n%.6f\n20\n%.6f\n30\n%.6f\n70\n192\n", szName, pos[0], pos[1], pos[2]);
|
|
}
|
|
|
|
// triangulate each face and write
|
|
for(int i = 0; i < m_nFaces; i++)
|
|
{
|
|
CSSFace &face = m_Faces[i];
|
|
PINT pVerts = CreatePointIndexList(face);
|
|
|
|
for(int v = 0; v < face.nEdges; v++)
|
|
pVerts[v]++;
|
|
|
|
for(int v = 0; v < face.nEdges-2; v++)
|
|
{
|
|
fprintf(stream, "0\nVERTEX\n8\n%s\n10\n0\n20\n0\n30\n"
|
|
"0\n70\n128\n71\n%d\n72\n%d\n73\n%d\n", szName,
|
|
v == 0 ? pVerts[0] : -pVerts[0],
|
|
pVerts[v+1],
|
|
v == (face.nEdges-3) ? pVerts[v+2] : -pVerts[v+2]
|
|
);
|
|
}
|
|
}
|
|
|
|
fprintf(stream, "0\nSEQEND\n8\n%s\n", szName);
|
|
}
|