//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#include "stdafx.h"
#include "Box3D.h"
#include "BrushOps.h"
#include "GlobalFunctions.h"
#include "MapDefs.h" // dvs: For COORD_NOTINIT
#include "MapView2D.h" // dvs FIXME: For HitTest2D implementation
#include "MapWorld.h"
#include "MapSolid.h"
#include "Options.h"
#include "Render2D.h"
#include "Render3D.h"
#include "SaveInfo.h"
#include "MapDoc.h"
#include "MapDisp.h"
#include "camera.h"
#include "ssolid.h"
// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>
IMPLEMENT_MAPCLASS(CMapSolid)
#define CENTER_HANDLE_RADIUS 3
int CMapSolid::g_nBadSolidCount = 0;
//-----------------------------------------------------------------------------
// Purpose: Constructor. Sets this solid's color to a random blue-green color.
// Input : Parent0 - The parent of this solid. Typically this is the world.
//-----------------------------------------------------------------------------
CMapSolid::CMapSolid(CMapClass *Parent0)
: m_bValid(FALSE) // well, no faces
{
m_pParent = Parent0;
m_eSolidType = btSolid;
m_bIsCordonBrush = false;
PickRandomColor();
}
//-----------------------------------------------------------------------------
// Purpose: Destructor.
//-----------------------------------------------------------------------------
CMapSolid::~CMapSolid(void)
{
Faces.SetCount(0);
}
//-----------------------------------------------------------------------------
// Purpose: Adds the plane to the given solid.
// Input : pSolid - Solid to which the plane is being added.
// p - Plane to add to the solid.
// Output : Returns true if the solid is still valid after the addition of the
// plane, false if it was entirely behind the plane.
//-----------------------------------------------------------------------------
bool CMapSolid::AddPlane(const CMapFace *p)
{
CMapFace NewFace;
//
// Copy the info from the carving face, including the plane, but not the points.
//
NewFace.CopyFrom(p, COPY_FACE_PLANE);
//
// Use texture from our first face - this function adds a plane
// from the subtraction brush itself.
//
const CMapFace *pSolidFace = GetFace(0);
NewFace.SetTexture(pSolidFace->texture.texture);
NewFace.texture.q2contents = pSolidFace->texture.q2contents;
NewFace.texture.q2surface = pSolidFace->texture.q2surface;
NewFace.texture.nLightmapScale = pSolidFace->texture.nLightmapScale;
//
// Set up the texture axes for the new face.
//
NewFace.InitializeTextureAxes(Options.GetTextureAlignment(), INIT_TEXTURE_ALL | INIT_TEXTURE_FORCE);
//
// Add the face to the solid and rebuild the solid.
//
AddFace(&NewFace);
CreateFromPlanes();
SetValid(TRUE);
PostUpdate(Notify_Changed);
RemoveEmptyFaces();
return(GetFaceCount() >= 4);
}
//-----------------------------------------------------------------------------
// Purpose: Carves this solid using another.
// Input : Inside - Receives the pieces of this solid that were inside the carver.
// Outside - Receives the pieces of this solid that were outside the carver.
// pCarver - The solid that is being subtracted from us.
//-----------------------------------------------------------------------------
bool CMapSolid::Carve(CMapObjectList *pInside, CMapObjectList *pOutside, CMapSolid *pCarver)
{
int i;
CMapSolid *front = NULL;
CMapSolid *back = NULL;
Vector bmins, bmaxs;
Vector carvemins, carvemaxs;
GetRender2DBox(bmins, bmaxs);
pCarver->GetRender2DBox(carvemins, carvemaxs);
//
// If this solid doesn't intersect the carving solid at all, add a copy
// to the outside list and exit.
//
for (i=0 ; i<3 ; i++)
{
if ((bmins[i] >= carvemaxs[i]) || (bmaxs[i] <= carvemins[i]))
{
if (pOutside != NULL)
{
CMapSolid *pCopy = (CMapSolid *)Copy(false);
pOutside->AddToTail(pCopy);
}
return(false);
}
}
//
// Build a duplicate of this solid to carve from.
//
CMapSolid CarveFrom;
CarveFrom.CopyFrom(this, false);
//
// Carve the solid by the faces in the carving solid.
//
for (i = 0; i < pCarver->GetFaceCount(); i++)
{
const CMapFace *pFace = pCarver->GetFace(i);
//
// Split the solid by this face, into a front and a back piece.
//
CarveFrom.ClipByFace(pFace, pOutside != NULL ? &front : NULL, &back);
//
// If there was a front piece, add it to the outside list.
//
if ((front != NULL) && (pOutside != NULL))
{
pOutside->AddToTail(front);
}
else
{
delete front;
}
//
// If there was no back piece, we have found a face the solid is completely in front of.
// Per the separating axis theorem, the two solids cannot intersect, so we are done.
//
if (back == NULL)
{
return(false);
}
//
// The next clip uses the back piece from this clip to prevent the carve results
// from overlapping.
//
CarveFrom.CopyFrom(back, false);
//
// Add the back piece of the carved solid to the inside list.
//
if (pInside != NULL)
{
pInside->AddToTail(back);
}
else
{
delete back;
}
}
return(true);
}
//-----------------------------------------------------------------------------
// Purpose: Clips the given solid by the given face, returning the results.
// Input : pSolid - Solid to clip.
// fa - Face to use for the clipping operation.
// f - Returns the part of the solid that was in front of the clipping
// face (in the direction of the face normal).
// b - Returns the part of the solid that was in back of the clipping
// face (in the opposite direction of the face normal).
//-----------------------------------------------------------------------------
void CMapSolid::ClipByFace(const CMapFace *fa, CMapSolid **fsolid, CMapSolid **bSolid)
{
CMapSolid *front = new CMapSolid;
CMapSolid *back = new CMapSolid;
CMapFace fb;
//
// Build a back facing version of the clip face by reversing the plane points
// and recalculate the plane normal and distance.
//
fb.CopyFrom(fa);
Vector temp = fb.plane.planepts[0];
fb.plane.planepts[0] = fb.plane.planepts[2];
fb.plane.planepts[2] = temp;
fb.CalcPlane();
front->CopyFrom(this, false);
front->SetParent(NULL);
back->CopyFrom(this, false);
back->SetParent(NULL);
if (!back->AddPlane(fa))
{
delete back;
back = NULL;
}
if (!front->AddPlane(&fb))
{
delete front;
front = NULL;
}
if (fsolid != NULL)
{
*fsolid = front;
}
else
{
delete front;
}
if (bSolid != NULL)
{
*bSolid = back;
}
else
{
delete back;
}
}
//-----------------------------------------------------------------------------
// Purpose: Returns true if this solid contains a face with the given ID, false if not.
// Input : nFaceID - unique face ID to look for.
//-----------------------------------------------------------------------------
CMapFace *CMapSolid::FindFaceID(int nFaceID)
{
int nFaceCount = GetFaceCount();
for (int nFace = 0; nFace < nFaceCount; nFace++)
{
CMapFace *pFace = GetFace(nFace);
if (pFace->GetFaceID() == nFaceID)
{
return(pFace);
}
}
return(NULL);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pWorld -
//-----------------------------------------------------------------------------
void CMapSolid::GenerateNewFaceIDs(CMapWorld *pWorld)
{
int nFaceCount = GetFaceCount();
for (int nFace = 0; nFace < nFaceCount; nFace++)
{
CMapFace *pFace = GetFace(nFace);
pFace->SetFaceID(pWorld->FaceID_GetNext());
}
}
//-----------------------------------------------------------------------------
// Purpose: Allows the solid to generate new face IDs before being added to the
// world because of a clone.
// Input : pClone - The clone of this object that is being added to the world.
// pWorld - The world that the clone is being added to.
// OriginalList - The list of objects that were cloned.
// NewList - The list of clones.
//-----------------------------------------------------------------------------
void CMapSolid::OnPreClone(CMapClass *pClone, CMapWorld *pWorld, const CMapObjectList &OriginalList, CMapObjectList &NewList)
{
((CMapSolid *)pClone)->GenerateNewFaceIDs(pWorld);
}
//-----------------------------------------------------------------------------
// Purpose: Notifies the object that a copy of it is being pasted from the
// clipboard before the copy is added to the world.
// Input : pCopy - The copy of this object that is being added to the world.
// pSourceWorld - The world that the originals were in.
// pDestWorld - The world that the copies are being added to.
// OriginalList - The list of original objects that were copied.
// NewList - The list of copied.
//-----------------------------------------------------------------------------
void CMapSolid::OnPrePaste(CMapClass *pCopy, CMapWorld *pSourceWorld, CMapWorld *pDestWorld, const CMapObjectList &OriginalList, CMapObjectList &NewList)
{
((CMapSolid *)pCopy)->GenerateNewFaceIDs(pDestWorld);
}
//-----------------------------------------------------------------------------
// Purpose: to split the solid by the given plane into frontside and backside
// solids; memory is allocated in the function for the solids;
// solids are only generated for (pointers to) CMapSolid pointers that
// exist -- if a pointer is NULL that sidedness is ignored; the
// function returns whether or not an actual split happened (TRUE/FALSE)
// Input: pPlane - the plane to split the solid with
// pFront - the front sided solid (if any)
// pBack - the back sided solid (if any)
// Output: 0 - on front side
// 1 - on back side
// 2 - split
//-----------------------------------------------------------------------------
int CMapSolid::Split( PLANE *pPlane, CMapSolid **pFront, CMapSolid **pBack )
{
const float SPLIT_DIST_EPSILON = 0.001f;
CMapSolid *pFrontSolid = NULL;
CMapSolid *pBackSolid = NULL;
CMapFace face;
//
// The newly added face should get its texture from face zero of the solid.
//
CMapFace *pFirstFace = GetFace(0);
if (pFirstFace != NULL)
{
face.SetTexture(pFirstFace->GetTexture());
}
//
// check for plane intersection with solid
//
int frontCount = 0;
int backCount = 0;
int faceCount = GetFaceCount();
for( int i = 0; i < faceCount; i++ )
{
CMapFace *pFace = GetFace( i );
for( int j = 0; j < pFace->nPoints; j++ )
{
float dist = DotProduct( pFace->Points[j], pPlane->normal ) - pPlane->dist;
if( dist > SPLIT_DIST_EPSILON )
{
frontCount++;
}
else if( dist < -SPLIT_DIST_EPSILON )
{
backCount++;
}
}
}
//
// If we're all on one side of the splitting plane, copy ourselves into the appropriate
// destination solid.
//
if ((frontCount == 0) || (backCount == 0))
{
CMapSolid **pReturn;
if (frontCount == 0)
{
pReturn = pBack;
}
else
{
pReturn = pFront;
}
if (pReturn == NULL)
{
return -1;
}
//
// The returned solid is just a copy of ourselves.
//
CMapSolid *pReturnSolid = new CMapSolid;
pReturnSolid->CopyFrom(this, false);
pReturnSolid->SetParent(NULL);
pReturnSolid->SetTemporary(TRUE);
//
// Rebuild the solid because mappers are accustomed to using the clipper tool as a way of
// verifying that geometry is valid.
//
if (pReturnSolid->CreateFromPlanes( CREATE_FROM_PLANES_CLIPPING ))
{
// Initialize the texture axes only of the newly created faces. Leave the others alone.
pReturnSolid->InitializeTextureAxes(Options.GetTextureAlignment(), INIT_TEXTURE_ALL);
pReturnSolid->PostUpdate(Notify_Changed);
}
*pReturn = pReturnSolid;
return 1;
}
//
// split the solid and create the "front" solid
//
if( pFront )
{
//
// copy the original solid info
//
pFrontSolid = new CMapSolid;
pFrontSolid->CopyFrom(this, false);
pFrontSolid->SetParent(NULL);
pFrontSolid->SetTemporary( TRUE );
face.plane.normal = pPlane->normal;
VectorNegate( face.plane.normal );
face.plane.dist = -pPlane->dist;
pFrontSolid->AddFace( &face );
//
// The new face doesn't have plane points, only a normal and a distance, so we tell CreateFromPlanes
// to generate new plane points for us after creation.
//
if (pFrontSolid->CreateFromPlanes(CREATE_BUILD_PLANE_POINTS | CREATE_FROM_PLANES_CLIPPING))
{
// Initialize the texture axes only of the newly created faces. Leave the others alone.
pFrontSolid->InitializeTextureAxes( Options.GetTextureAlignment(), INIT_TEXTURE_ALL );
pFrontSolid->PostUpdate(Notify_Clipped_Intermediate);
*pFront = pFrontSolid;
}
}
//
// split the solid and create the "back" solid
//
if( pBack )
{
//
// copy the original solid info
//
pBackSolid = new CMapSolid;
pBackSolid->CopyFrom(this, false);
pBackSolid->SetParent(NULL);
pBackSolid->SetTemporary( TRUE );
face.plane.normal = pPlane->normal;
face.plane.dist = pPlane->dist;
pBackSolid->AddFace( &face );
//
// The new face doesn't have plane points, only a normal and a distance, so we tell CreateFromPlanes
// to generate new plane points for us after creation.
//
if (pBackSolid->CreateFromPlanes(CREATE_BUILD_PLANE_POINTS | CREATE_FROM_PLANES_CLIPPING))
{
// Initialize the texture axes only of the newly created faces. Leave the others alone.
pBackSolid->InitializeTextureAxes( Options.GetTextureAlignment(), INIT_TEXTURE_ALL );
pBackSolid->PostUpdate(Notify_Clipped_Intermediate);
*pBack = pBackSolid;
}
}
return 2;
}
//-----------------------------------------------------------------------------
// Purpose: Returns the index (you could use it with GetFace) or -1 if the face doesn't exist in this solid.
//-----------------------------------------------------------------------------
int CMapSolid::GetFaceIndex( CMapFace *pFace )
{
for ( int i=0; i < Faces.GetCount(); i++ )
{
if ( pFace == &Faces[i] )
return i;
}
return -1;
}
//-----------------------------------------------------------------------------
// Purpose: Adds a face to this solid.
// Input : pFace - The face to add. The face is copied into this solid's face
// array, so it can be safely freed when AddFace returns.
//-----------------------------------------------------------------------------
void CMapSolid::AddFace(CMapFace *pFace)
{
int nFaces = Faces.GetCount();
Faces.SetCount(nFaces + 1);
CMapFace *pNewFace = &Faces[nFaces];
pNewFace->CopyFrom(pFace, COPY_FACE_POINTS);
pNewFace->SetRenderColor(r, g, b);
pNewFace->SetCordonFace( m_bIsCordonBrush );
pNewFace->SetParent(this);
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : CMapClass
//-----------------------------------------------------------------------------
CMapClass *CMapSolid::Copy(bool bUpdateDependencies)
{
CMapSolid *pNew = new CMapSolid;
pNew->CopyFrom(this, bUpdateDependencies);
return pNew;
}
//-----------------------------------------------------------------------------
// Purpose: Turns this solid into a duplicate of the given solid.
// Input : pobj - Object to copy, must be a CMapSolid.
// Output : Returns a pointer to this object.
//-----------------------------------------------------------------------------
CMapClass *CMapSolid::CopyFrom(CMapClass *pobj, bool bUpdateDependencies)
{
Assert(pobj->IsMapClass(MAPCLASS_TYPE(CMapSolid)));
CMapSolid *pFrom = (CMapSolid *)pobj;
CMapClass::CopyFrom(pobj, bUpdateDependencies);
m_eSolidType = pFrom->GetHL1SolidType();
m_bIsCordonBrush = pFrom->m_bIsCordonBrush;
int nFaces = pFrom->Faces.GetCount();
Faces.SetCount(nFaces);
// copy faces
CMapFace *pFromFace;
CMapFace *pToFace;
for (int i = nFaces - 1; i >= 0; i--)
{
pToFace = &Faces[i];
pFromFace = &pFrom->Faces[i];
if (!pToFace)
{
continue;
}
pToFace->SetParent(this);
pToFace->CopyFrom(pFromFace, COPY_FACE_POINTS, bUpdateDependencies);
Assert(pToFace->GetPointCount() != 0);
}
return(this);
}
//-----------------------------------------------------------------------------
// Purpose: Walks the faces of a solid for debugging.
//-----------------------------------------------------------------------------
#ifdef _DEBUG
#pragma warning (disable:4189)
void CMapSolid::DebugSolid(void)
{
int nFaceCount = Faces.GetCount();
for (int nFace = 0; nFace < nFaceCount; nFace++)
{
CMapFace *pFace = GetFace(nFace);
}
}
#pragma warning (default:4189)
#endif // _DEBUG
//-----------------------------------------------------------------------------
// Purpose:
// Input : iIndex -
//-----------------------------------------------------------------------------
void CMapSolid::DeleteFace(int iIndex)
{
// shifts 'em down.
int nFaces = Faces.GetCount();
for(int j = iIndex; j < nFaces-1; j++)
{
Faces[j].CopyFrom(&Faces[j+1]);
}
Faces.SetCount(nFaces-1);
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
const char* CMapSolid::GetDescription(void)
{
static char szBuf[128];
sprintf(szBuf, "solid with %d faces", Faces.GetCount());
return szBuf;
}
//-----------------------------------------------------------------------------
// Purpose: Calculates this solid's axis aligned bounding box.
// Input : bFullUpdate - Whether to evaluate all children when calculating.
//-----------------------------------------------------------------------------
void CMapSolid::CalcBounds(BOOL bFullUpdate)
{
CMapClass::CalcBounds(bFullUpdate);
//
// Update mins/maxes based on our faces.
//
int nFaces = Faces.GetCount();
for( int i = 0; i < nFaces; i++ )
{
// check for valid face
if (!Faces[i].Points)
continue;
//
// Get the 2d render bounds of this face and update the solid. 2D render bounds
// can be different from 3D culling bounds because the 2D bounds do not consider
// displacement faces.
//
Vector mins, maxs;
bool result = Faces[i].GetRender2DBox( mins, maxs );
if( result )
{
m_Render2DBox.UpdateBounds( mins, maxs );
}
//
// Get the culling bounds and update the solid
//
result = Faces[i].GetCullBox( mins, maxs );
if( result )
{
m_CullBox.UpdateBounds( mins, maxs );
}
}
m_Render2DBox.GetBoundsCenter(m_Origin);
m_BoundingBox = m_CullBox;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : t -
//-----------------------------------------------------------------------------
void CMapSolid::DoTransform(const VMatrix &matrix)
{
// get all points, transform them
int nFaces = Faces.GetCount();
for (int i = 0; i < nFaces; i++)
{
Faces[i].DoTransform( matrix );
}
BaseClass::DoTransform(matrix);
}
//-----------------------------------------------------------------------------
// Purpose: Sets the render color of all of our faces when our render color is set.
//-----------------------------------------------------------------------------
void CMapSolid::SetRenderColor(color32 rgbColor)
{
CMapClass::SetRenderColor(rgbColor);
int nFaces = Faces.GetCount();
for (int i = 0; i < nFaces; i++)
{
Faces[i].SetRenderColor(rgbColor);
}
}
//-----------------------------------------------------------------------------
// Purpose: Sets the render color of all of our faces when our render color is set.
//-----------------------------------------------------------------------------
void CMapSolid::SetRenderColor(unsigned char uchRed, unsigned char uchGreen, unsigned char uchBlue)
{
CMapClass::SetRenderColor(uchRed, uchGreen, uchBlue);
int nFaces = Faces.GetCount();
for (int i = 0; i < nFaces; i++)
{
Faces[i].SetRenderColor(uchRed, uchGreen, uchBlue);
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output : size_t
//-----------------------------------------------------------------------------
size_t CMapSolid::GetSize(void)
{
size_t size = CMapClass::GetSize();
size += sizeof *this;
int nFaces = Faces.GetCount();
for( int i = 0; i < nFaces; i++ )
{
size += Faces[i].GetDataSize();
}
return size;
}
//-----------------------------------------------------------------------------
// Purpose: Sets the texture for a given face.
// Input : pszTex - Texture name.
// iFace - Index of face for which to set texture.
//-----------------------------------------------------------------------------
void CMapSolid::SetTexture(LPCTSTR pszTex, int iFace)
{
if(iFace == -1)
{
int nFaces = Faces.GetCount();
for(int i = 0 ; i < nFaces; i++)
{
Faces[i].SetTexture(pszTex);
}
}
else
{
Faces[iFace].SetTexture(pszTex);
}
CMapDoc *pMapDoc = CMapDoc::GetActiveMapDoc();
pMapDoc->RemoveFromAutoVisGroups( this );
pMapDoc->AddToAutoVisGroup( this );
}
//-----------------------------------------------------------------------------
// Purpose: Returns the texture name of a given face.
// Input : iFace - Index of face. If -1, returns the texture of face 0.
// Output : Returns the texture name.
//-----------------------------------------------------------------------------
LPCTSTR CMapSolid::GetTexture(int iFace)
{
return Faces[iFace == -1 ? 0 : iFace].texture.texture;
}
//-----------------------------------------------------------------------------
// Purpose: Creates the solid using the plane information from the solid's faces.
//
// ASSUMPTIONS: This solid's faces are assumed to have valid plane points.
//
// Input : dwFlags - Can be any or none of the following flags:
//
// CREATE_BUILD_PLANE_POINTS - if this flag is set, the 3-point
// definition of each face plane will be regenerated based
// on the face points after the solid is generated.
//
// Output : Returns TRUE if the solid is valid, FALSE if not.
//
// dvs: this should really use the public API of CMapSolid to add faces so that
// parentage and render color are set automatically.
//-----------------------------------------------------------------------------
int CMapSolid::CreateFromPlanes( DWORD dwFlags )
{
int i, j, k;
BOOL useplane[MAPSOLID_MAX_FACES];
m_Render2DBox.SetBounds(Vector(COORD_NOTINIT, COORD_NOTINIT, COORD_NOTINIT),
Vector(-COORD_NOTINIT, -COORD_NOTINIT, -COORD_NOTINIT));
m_bValid = TRUE;
//
// Free all points from all faces and assign parentage.
//
int nFaces = GetFaceCount();
for (i = 0; i < nFaces; i++)
{
CMapFace *pFace = GetFace(i);
pFace->AllocatePoints(0);
pFace->SetParent(this);
pFace->SetRenderColor(r, g, b);
useplane[i] = false;
}
//
// For every face that is not set to be ignored, check the plane and make sure
// it is unique. We mark each plane that we intend to keep with a TRUE in the
// 'useplane' array.
//
for (i = 0; i < nFaces; i++)
{
CMapFace *pFace = GetFace(i);
PLANE *f = &pFace->plane;
//
// Don't use this plane if it has a zero-length normal.
//
if (VectorCompare(f->normal, vec3_origin))
{
useplane[i] = FALSE;
continue;
}
//
// If the plane duplicates another plane, don't use it (assume it is a brush
// being edited that will be fixed).
//
useplane[i] = TRUE;
for (j = 0; j < i; j++)
{
CMapFace *pFaceCheck = GetFace(j);
Vector& f1 = f->normal;
Vector& f2 = pFaceCheck->plane.normal;
//
// Check for duplicate plane within some tolerance.
//
if ((DotProduct(f1, f2) > 0.999) && (fabs(f->dist - pFaceCheck->plane.dist) < 0.01))
{
useplane[j] = FALSE;
break;
}
}
}
//
// Now we have a set of planes, indicated by TRUE values in the 'useplanes' array,
// from which we will build a solid.
//
BOOL bGotFaces = FALSE;
for (i = 0; i < nFaces; i++)
{
CMapFace *pFace = GetFace(i);
if (!useplane[i])
continue;
//
// Create a huge winding from this face's plane, then clip it by all other
// face planes.
//
winding_t *w = CreateWindingFromPlane(&pFace->plane);
for (j = 0; j < nFaces && w; j++)
{
CMapFace *pFaceClip = GetFace(j);
//
// Flip the plane, because we want to keep the back side
//
if (j != i)
{
PLANE plane;
VectorSubtract(vec3_origin, pFaceClip->plane.normal, plane.normal);
plane.dist = -pFaceClip->plane.dist;
w = ClipWinding(w, &plane);
}
}
//
// If we still have a winding after all that clipping, build a face from
// the winding.
//
if (w != NULL)
{
//
// Round all points in the winding that are within ROUND_VERTEX_EPSILON of
// integer values.
//
for (j = 0; j < w->numpoints; j++)
{
for (k = 0; k < 3; k++)
{
float v = w->p[j][k];
float v1 = V_rint(v);
if ((v != v1) && (fabs(v - v1) < ROUND_VERTEX_EPSILON))
{
w->p[j][k] = v1;
}
}
}
//
// The above rounding process may have created duplicate points. Eliminate them.
//
RemoveDuplicateWindingPoints(w, MIN_EDGE_LENGTH_EPSILON);
bGotFaces = TRUE;
//
// Create a face from this winding. Leave the face plane
// alone because we are still in the process of building our solid.
//
if ( dwFlags & CREATE_FROM_PLANES_CLIPPING )
{
pFace->CreateFace( w, CREATE_FACE_PRESERVE_PLANE | CREATE_FACE_CLIPPING );
}
else
{
pFace->CreateFace(w, CREATE_FACE_PRESERVE_PLANE);
}
//
// Done with the winding, we can free it now.
//
FreeWinding(w);
}
}
if (!bGotFaces)
{
m_bValid = FALSE;
m_Render2DBox.SetBounds(vec3_origin, vec3_origin);
}
else
{
//
// Remove faces that don't contribute to this solid.
//
int nFace = GetFaceCount();
while (nFace > 0)
{
nFace--;
CMapFace *pFace = GetFace(nFace);
if ((!useplane[nFace]) || (pFace->GetPointCount() == 0))
{
DeleteFace(nFace);
memcpy(useplane + nFace, useplane + nFace + 1, MAPSOLID_MAX_FACES - (nFace + 1));
}
}
}
//
// Now that we have built the faces from the planes that we were given,
// calculate the plane normals, distances, and texture coordinates.
//
nFaces = GetFaceCount();
for (i = 0; i < nFaces; i++)
{
CMapFace *pFace = GetFace(i);
if (dwFlags & CREATE_BUILD_PLANE_POINTS)
{
pFace->CalcPlaneFromFacePoints();
}
else
{
pFace->CalcPlane();
}
pFace->CalcTextureCoords();
//
// Make sure the face is valid.
//
if (!pFace->CheckFace())
{
m_bValid = FALSE;
}
}
//
// remove faces that do not contribute -- not just "unused or ignored" faces
//
int faceCount = Faces.GetCount();
for( i = 0; i < faceCount; i++ )
{
if( Faces[i].nPoints == 0 )
{
DeleteFace( i );
i--;
faceCount--;
}
}
return(m_bValid ? TRUE : FALSE);
}
//-----------------------------------------------------------------------------
// Purpose: Initializes the texture axes for all faces in the solid.
// Input : eAlignment - See CMapFace::InitializeTextureAxes
// dwFlags - See CMapFace::InitializeTextureAxes
//-----------------------------------------------------------------------------
void CMapSolid::InitializeTextureAxes(TextureAlignment_t eAlignment, DWORD dwFlags)
{
int nFaces = Faces.GetCount();
for (int i = 0; i < nFaces; i++)
{
Faces[i].InitializeTextureAxes(eAlignment, dwFlags);
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pLoadInfo -
// *pSolid -
// Output : ChunkFileResult_t
//-----------------------------------------------------------------------------
ChunkFileResult_t CMapSolid::LoadSideCallback(CChunkFile *pFile, CMapSolid *pSolid)
{
ChunkFileResult_t eResult = ChunkFile_Ok;
//
// this is hear in place of the AddFace -- may want to handle this better later!!!
//
int faceCount = pSolid->Faces.GetCount();
pSolid->Faces.SetCount( faceCount + 1 );
CMapFace *pFace = &pSolid->Faces[faceCount];
eResult = pFace->LoadVMF(pFile);
if (eResult == ChunkFile_Ok)
{
pFace->SetRenderColor( pSolid->r, pSolid->g, pSolid->b );
pFace->SetParent( pSolid );
}
else
{
// UNDONE: need a better solution for user errors.
AfxMessageBox("Out of memory loading solid.");
eResult = ChunkFile_OutOfMemory;
}
return(eResult);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pFile -
// pData -
// Output : ChunkFileResult_t
//-----------------------------------------------------------------------------
ChunkFileResult_t CMapSolid::LoadVMF(CChunkFile *pFile, bool &bValid)
{
//
// Set up handlers for the subchunks that we are interested in.
//
CChunkHandlerMap Handlers;
Handlers.AddHandler("side", (ChunkHandler_t)LoadSideCallback, this);
Handlers.AddHandler("editor", (ChunkHandler_t)LoadEditorCallback, this);
pFile->PushHandlers(&Handlers);
ChunkFileResult_t eResult = pFile->ReadChunk((KeyHandler_t)LoadEditorKeyCallback, this);
pFile->PopHandlers();
bValid = false;
if (eResult == ChunkFile_Ok)
{
//
// Create the solid using the planes that were read from the MAP file.
//
if (CreateFromPlanes())
{
bValid = true;
CalcBounds();
//
// Set solid type based on texture name.
//
m_eSolidType = HL1SolidTypeFromTextureName(Faces[0].texture.texture);
//
// create all of the displacement surfaces for faces with the displacement property
//
int faceCount = GetFaceCount();
for( int i = 0; i < faceCount; i++ )
{
CMapFace *pFace = GetFace( i );
if( !pFace->HasDisp() )
continue;
EditDispHandle_t handle = pFace->GetDisp();
CMapDisp *pMapDisp = EditDispMgr()->GetDisp( handle );
pMapDisp->InitDispSurfaceData( pFace, false );
pMapDisp->Create();
pMapDisp->PostLoad();
}
// There once was a bug that caused black solids. Fix it here.
if ((r == 0) && (g == 0) || (b == 0))
{
PickRandomColor();
}
}
else
{
g_nBadSolidCount++;
}
}
return(eResult);
}
//-----------------------------------------------------------------------------
// Purpose: Picks a random shade of blue/green for this solid.
//-----------------------------------------------------------------------------
void CMapSolid::PickRandomColor()
{
SetRenderColor(0, 100 + (random() % 156), 100 + (random() % 156));
}
//-----------------------------------------------------------------------------
// Purpose: Called before loading a map file.
//-----------------------------------------------------------------------------
void CMapSolid::PreloadWorld(void)
{
g_nBadSolidCount = 0;
}
//-----------------------------------------------------------------------------
// Purpose: Returns the number of solids that could not be loaded due to errors
// in the VMF file. This should only occur after the first load of an
// old RMF file.
//-----------------------------------------------------------------------------
int CMapSolid::GetBadSolidCount(void)
{
return(g_nBadSolidCount);
}
//-----------------------------------------------------------------------------
// Purpose: Called after this object is added to the world.
//
// NOTE: This function is NOT called during serialization. Use PostloadWorld
// to do similar bookkeeping after map load.
//
// Input : pWorld - The world that we have been added to.
//-----------------------------------------------------------------------------
void CMapSolid::OnAddToWorld(CMapWorld *pWorld)
{
CMapClass::OnAddToWorld(pWorld);
//
// First, the common case: all our face IDs are zero. Assign new IDs to all faces
// with zero IDs. Add unhandled faces to a list. Those we will need to check against
// the world for uniqueness.
//
CMapFaceList CheckList;
int nFaceCount = GetFaceCount();
for (int i = 0; i < nFaceCount; i++)
{
CMapFace *pFace = GetFace(i);
if (pFace->GetFaceID() == 0)
{
pFace->SetFaceID(pWorld->FaceID_GetNext());
}
else
{
CheckList.AddToTail(pFace);
}
}
if (CheckList.Count() > 0)
{
//
// The less common case: make sure all our face IDs are unique in this world.
// We do it here instead of in CMapFace in order to save world tree traversals.
//
EnumChildrenPos_t pos;
CMapClass *pChild = pWorld->GetFirstDescendent(pos);
while (pChild != NULL)
{
CMapSolid *pSolid = dynamic_cast<CMapSolid *>(pChild);
if ( pSolid && pSolid != this )
{
CUtlRBTree<int,int> faceIDs;
SetDefLessFunc( faceIDs );
nFaceCount = GetFaceCount();
for (int nFace = 0; nFace < nFaceCount; nFace++)
{
CMapFace *pFace = GetFace(nFace);
faceIDs.Insert( pFace->GetFaceID() );
}
for (int i = CheckList.Count() - 1; i >= 0; i--)
{
CMapFace *pFace = CheckList.Element(i);
// If this face ID is not unique, assign it a new unique face ID
// and remove it from our list.
if ( faceIDs.Find( pFace->GetFaceID() ) != faceIDs.InvalidIndex() )
{
pFace->SetFaceID(pWorld->FaceID_GetNext());
CheckList.FastRemove(i);
}
}
if (CheckList.Count() <= 0)
{
// We've handled all the faces in our list, early out.
break;
}
}
pChild = pWorld->GetNextDescendent(pos);
}
}
//
// Notify all faces that we are being added to the world.
//
for (int i = 0; i < nFaceCount; i++)
{
CMapFace *pFace = GetFace(i);
pFace->OnAddToWorld(pWorld);
}
}
//-----------------------------------------------------------------------------
// Purpose: Called after the entire map has been loaded. This allows the object
// to perform any linking with other map objects or to do other operations
// that require all world objects to be present.
// Input : pWorld - The world that we are in.
//-----------------------------------------------------------------------------
void CMapSolid::PostloadWorld(CMapWorld *pWorld)
{
CMapClass::PostloadWorld(pWorld);
//
// Make sure all our faces have nonzero IDs. They might if the map was created
// before unique IDs were added.
//
int nFaces = GetFaceCount();
for (int i = 0; i < nFaces; i++)
{
CMapFace *pFace = GetFace(i);
if (pFace->GetFaceID() == 0)
{
pFace->SetFaceID(pWorld->FaceID_GetNext());
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : eSelectMode -
// Output : CMapClass
//-----------------------------------------------------------------------------
CMapClass *CMapSolid::PrepareSelection(SelectMode_t eSelectMode)
{
//
// If we have a parent who is not the world object, consider whether we should
// select it instead.
//
if ((eSelectMode != selectSolids) && (m_pParent != NULL) && !IsWorldObject(m_pParent) )
{
//
// If we are in group selection mode or our parent is an entity, select our
// parent.
//
if ( (eSelectMode == selectGroups) || (dynamic_cast <CMapEntity *>(m_pParent) != NULL))
{
return GetParent()->PrepareSelection(eSelectMode);
}
}
return this;
}
//-----------------------------------------------------------------------------
// Purpose: Called just after this object has been removed from the world so
// that it can unlink itself from other objects in the world.
// Input : pWorld - The world that we were just removed from.
// bNotifyChildren - Whether we should forward notification to our children.
//-----------------------------------------------------------------------------
void CMapSolid::OnRemoveFromWorld(CMapWorld *pWorld, bool bNotifyChildren)
{
CMapClass::OnRemoveFromWorld(pWorld, bNotifyChildren);
//
// Notify all faces that we are being removed from the world.
//
int nFaces = GetFaceCount();
for (int i = 0; i < nFaces; i++)
{
CMapFace *pFace = GetFace(i);
pFace->OnRemoveFromWorld();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapSolid::RemoveEmptyFaces(void)
{
int nFaces = GetFaceCount();
for (int i = 0; i < nFaces; i++)
{
//
// If this face has no points, delete it.
//
const CMapFace *pFace = GetFace(i);
if (pFace->Points == NULL)
{
DeleteFace(i);
i--;
nFaces--;
}
}
if (nFaces >= 4)
{
// dvs: test to verify that the SetFaceCount below is unnecessary
int nTest = GetFaceCount();
Assert(nTest == nFaces);
SetFaceCount(nFaces);
}
}
//-----------------------------------------------------------------------------
// for sorting
//-----------------------------------------------------------------------------
bool CMapSolid::ShouldRenderLast()
{
for (int nFace = 0; nFace < GetFaceCount(); nFace++)
{
CMapFace *pFace = GetFace(nFace);
if (pFace->ShouldRenderLast())
return true;
}
return false;
}
void CMapSolid::AddShadowingTriangles( CUtlVector<Vector> &tri_list )
{
for (int nFace = 0; nFace < GetFaceCount(); nFace++)
{
CMapFace *pFace = GetFace(nFace);
pFace->AddShadowingTriangles( tri_list );
if( pFace->HasDisp() )
{
EditDispHandle_t handle = pFace->GetDisp();
CMapDisp *pMapDisp = EditDispMgr()->GetDisp( handle );
pMapDisp->AddShadowingTriangles( tri_list );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Renders the solid using the default render mode. If the solid is
// currently selected, it will be rendered with a yellow wireframe
// in a second pass.
// Input : pRender - Rendering interface.
//-----------------------------------------------------------------------------
void CMapSolid::Render3D(CRender3D *pRender)
{
//
// determine whether or not this is a displacement solid - i.e. one of the faces
// on this solid is displaced
//
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
if( !pDoc )
return;
bool bMaskFaces = pDoc->IsDispSolidDrawMask() && HasDisp();
//
// Determine whether we need to render in one or two passes. If we are selected,
// and rendering in flat or textured mode, we need to render using two passes.
//
int nPasses = 1;
int iStartPass = 1;
SelectionState_t eSolidSelectionState = GetSelectionState();
EditorRenderMode_t eDefaultRenderMode = pRender->GetDefaultRenderMode();
if ((eSolidSelectionState != SELECT_NONE) && (eDefaultRenderMode != RENDER_MODE_WIREFRAME))
{
nPasses = 2;
}
if ( ( eSolidSelectionState == SELECT_MODIFY ) )
{
nPasses = 2;
iStartPass = 2;
}
for (int nPass = iStartPass; nPass <= nPasses; nPass++)
{
//
// Render the second pass in wireframe.
//
if (nPass == 1)
{
pRender->PushRenderMode(RENDER_MODE_CURRENT);
}
else
{
pRender->PushRenderMode(RENDER_MODE_WIREFRAME);
}
for (int nFace = 0; nFace < GetFaceCount(); nFace++)
{
CMapFace *pFace = GetFace(nFace);
// only render displaced faces on a displaced solid when the displacement
// solid render mask is set
if( bMaskFaces && !pFace->HasDisp() )
continue;
if( pRender->IsInLightingPreview() )
{
if( nPass == 1 )
{
if( pFace->GetSelectionState() != SELECT_NONE )
{
pRender->BeginRenderHitTarget(this, nFace);
pFace->Render3D( pRender );
pRender->EndRenderHitTarget();
}
}
else
{
pFace->Render3D( pRender );
}
}
else
{
pRender->BeginRenderHitTarget(this, nFace);
pFace->Render3D( pRender );
pRender->EndRenderHitTarget();
}
}
pRender->PopRenderMode();
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CMapSolid::HasDisp( void )
{
for( int ndxFace = 0; ndxFace < GetFaceCount(); ndxFace++ )
{
CMapFace *pFace = GetFace( ndxFace );
if( pFace->HasDisp() )
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Returns a solid type for the given texture name.
// Input : pszTexture -
//-----------------------------------------------------------------------------
HL1_SolidType_t CMapSolid::HL1SolidTypeFromTextureName(const char *pszTexture)
{
HL1_SolidType_t eSolidType;
if (pszTexture[0] == '*')
{
if (!strncmp(pszTexture + 1, "slime", 5))
{
eSolidType = btSlime;
}
else if (!strncmp(pszTexture + 1, "lava", 4))
{
eSolidType = btLava;
}
else
{
eSolidType = btWater;
}
}
else
{
eSolidType = btSolid;
}
return(eSolidType);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pFile -
// Output : ChunkFileResult_t
//-----------------------------------------------------------------------------
ChunkFileResult_t CMapSolid::SaveVMF(CChunkFile *pFile, CSaveInfo *pSaveInfo)
{
//
// Check rules before saving this object.
//
if (!pSaveInfo->ShouldSaveObject(this))
{
return(ChunkFile_Ok);
}
ChunkFileResult_t eResult = ChunkFile_Ok;
//
// If we are hidden, place this object inside of a hidden chunk.
//
if (!IsVisible())
{
eResult = pFile->BeginChunk("hidden");
}
//
// Begin the solid chunk.
//
if (eResult == ChunkFile_Ok)
{
eResult = pFile->BeginChunk("solid");
}
if (eResult == ChunkFile_Ok)
{
//
// Save the solid's ID.
//
if (eResult == ChunkFile_Ok)
{
eResult = pFile->WriteKeyValueInt("id", GetID());
}
//
// Save all the brush faces.
//
int nFaceCount = GetFaceCount();
for (int nFace = 0; nFace < nFaceCount; nFace++)
{
CMapFace *pFace = GetFace(nFace);
eResult = pFace->SaveVMF(pFile, pSaveInfo);
if (eResult != ChunkFile_Ok)
{
break;
}
}
//
// Save our base class' information within our chunk.
//
if (eResult == ChunkFile_Ok)
{
eResult = CMapClass::SaveVMF(pFile, pSaveInfo);
}
if (eResult == ChunkFile_Ok)
{
eResult = pFile->EndChunk();
}
}
//
// End the hidden chunk if we began it.
//
if (!IsVisible())
{
eResult = pFile->EndChunk();
}
return(eResult);
}
bool CMapSolid::ShouldAppearInLightingPreview(void)
{
return true;
}
bool CMapSolid::ShouldAppearInRaytracedLightingPreview(void)
{
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pFile -
// Output : ChunkFileResult_t
//-----------------------------------------------------------------------------
ChunkFileResult_t CMapSolid::SaveEditorData(CChunkFile *pFile)
{
if (m_bIsCordonBrush)
{
return(pFile->WriteKeyValueBool("cordonsolid", true));
}
return(ChunkFile_Ok);
}
//-----------------------------------------------------------------------------
// Purpose: Sets whether this brush was created by the cordon tool. Brushes that
// were created by the cordon tool are not loaded.
// Input : bSet - true to set, false to clear.
//-----------------------------------------------------------------------------
void CMapSolid::SetCordonBrush(bool bSet)
{
m_bIsCordonBrush = bSet;
for ( int i = 0; i < GetFaceCount(); i++ )
{
CMapFace *pFace = GetFace( i );
pFace->SetCordonFace( bSet );
}
}
//-----------------------------------------------------------------------------
// Purpose: Subtracts one solid from another.
// Input : pSubtraction - Solid (or group of solids) to subtract with.
// pOther - Solid (or group of solids) to subtract from.
// pSubParent - Receives the results of the subtraction as children.
// Output : Returns true if the objects intersected (subtraction was performed),
// false if the objects did not intersect (no subtraction was performed).
//-----------------------------------------------------------------------------
bool CMapSolid::Subtract(CMapObjectList *pInside, CMapObjectList *pOutside, CMapClass *pSubtractWith)
{
//
// Build a list of solids to subtract with.
//
CMapObjectList SubList;
if (pSubtractWith->IsMapClass(MAPCLASS_TYPE(CMapSolid)))
{
SubList.AddToTail(pSubtractWith);
}
EnumChildrenPos_t pos;
CMapClass *pChild = pSubtractWith->GetFirstDescendent(pos);
while (pChild != NULL)
{
CMapSolid *pSolid = dynamic_cast <CMapSolid *> (pChild);
if (pSolid != NULL)
{
SubList.AddToTail(pSolid);
}
pChild = pSubtractWith->GetNextDescendent(pos);
}
//
// For every solid that we are subtracting with...
//
bool bIntersected = false;
FOR_EACH_OBJ( SubList, p )
{
CMapSolid *pCarver = (CMapSolid *)SubList.Element(p);
//
// Subtract the 'with' solid from the 'from' solid, and place the
// results in the carve_in and carve_out lists.
//
CMapObjectList carve_in;
CMapObjectList carve_out;
CMapObjectList *pCarveIn = NULL;
CMapObjectList *pCarveOut = NULL;
if (pInside != NULL)
{
pCarveIn = &carve_in;
}
if (pOutside != NULL)
{
pCarveOut = &carve_out;
}
bIntersected |= Carve(pCarveIn, pCarveOut, pCarver);
if (pInside != NULL)
{
pInside->AddVectorToTail(carve_in);
carve_in.RemoveAll();
}
if (pOutside != NULL)
{
pOutside->AddVectorToTail(carve_out);
carve_out.RemoveAll();
}
}
return(bIntersected);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
color32 CMapSolid::GetLineColor( CRender2D *pRender )
{
//
// If the solid is not selected, determine the appropriate pen color.
//
if ( !IsSelected() )
{
//
// If this is a solid entity, use the entity pen color.
//
CMapEntity *pEntity = dynamic_cast<CMapEntity *>(GetParent());
if (pEntity != NULL)
{
GDclass *pClass = pEntity->GetClass();
if (pClass)
{
return pClass->GetColor();
}
else
{
color32 clr;
clr.r = GetRValue(Options.colors.clrEntity);
clr.g = GetGValue(Options.colors.clrEntity);
clr.b = GetBValue(Options.colors.clrEntity);
clr.a = 255;
return clr;
}
}
//
// Otherwise, use the solid color.
//
else
{
if (Options.view2d.bUsegroupcolors)
{
return GetRenderColor();
}
else
{
color32 clr;
clr.r = GetRValue(Options.colors.clrBrush);
clr.g = GetGValue(Options.colors.clrBrush);
clr.b = GetBValue(Options.colors.clrBrush);
clr.a = 255;
return clr;
}
}
}
//
// The solid is selected, use the selected pen color.
//
else
{
color32 clr;
clr.r = GetRValue(Options.colors.clrSelection);
clr.g = GetGValue(Options.colors.clrSelection);
clr.b = GetBValue(Options.colors.clrSelection);
clr.a = 255;
return clr;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pRender -
//-----------------------------------------------------------------------------
void CMapSolid::Render2D(CRender2D *pRender)
{
Vector vecMins, vecMaxs, vViewNormal;
GetRender2DBox(vecMins, vecMaxs);
pRender->GetCamera()->GetViewForward( vViewNormal );
Vector2D pt, pt2;
pRender->TransformPoint(pt, vecMins);
pRender->TransformPoint(pt2, vecMaxs);
int sizex = abs(pt2.x-pt.x)+1;
int sizey = abs(pt2.y-pt.y)+1;
color32 rgbLineColor = GetLineColor( pRender );
// check if we should draw handles & vertices
bool bIsSmall = sizex < (HANDLE_RADIUS*2) || sizey < (HANDLE_RADIUS*2);
bool bIsTiny = sizex < 2 || sizey < 2;
bool bDrawHandles = pRender->IsActiveView() && !bIsSmall && IsEditable();
bool bDrawVertices = Options.view2d.bDrawVertices && !bIsTiny;
pRender->SetDrawColor( rgbLineColor.r, rgbLineColor.g, rgbLineColor.b );
//
// Draw center handle if the solid is larger than the handle along either axis.
//
if ( bDrawHandles )
{
// draw center handle as cross
pRender->SetHandleStyle( HANDLE_RADIUS, CRender::HANDLE_CROSS );
pRender->SetHandleColor( rgbLineColor.r, rgbLineColor.g, rgbLineColor.b );
pRender->DrawHandle( (vecMins+vecMaxs)/2 );
}
if ( bDrawVertices )
{
// set handle style for upcoming vertex drawing
pRender->SetHandleStyle( 2, CRender::HANDLE_SQUARE );
pRender->SetHandleColor( GetRValue(Options.colors.clrVertex), GetGValue(Options.colors.clrVertex), GetBValue(Options.colors.clrVertex) );
}
// is solid projection is too small, draw simple line
if ( bIsTiny )
{
pRender->DrawLine( vecMins, vecMaxs );
}
else
{
int nFaces = GetFaceCount();
for ( int i = 0; i < nFaces; i++)
{
CMapFace *pFace = GetFace(i);
pFace->Render2D( pRender );
}
if ( bDrawVertices )
{
bool bPop = pRender->BeginClientSpace();
for ( int i = 0; i < nFaces; i++)
{
CMapFace *pFace = GetFace(i);
pFace->RenderVertices( pRender );
}
if ( bPop )
pRender->EndClientSpace();
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pView -
// vecPoint -
// nHitData -
// Output :
//-----------------------------------------------------------------------------
bool CMapSolid::HitTest2D(CMapView2D *pView, const Vector2D &point, HitInfo_t &HitData)
{
if (!IsVisible())
return false;
//
// First check center X.
//
Vector vecCenter, vecViewPoint;
GetBoundsCenter(vecCenter);
Vector2D vecClientCenter;
pView->WorldToClient(vecClientCenter, vecCenter);
pView->GetCamera()->GetViewPoint( vecViewPoint );
HitData.pObject = this;
HitData.nDepth = vecViewPoint[pView->axThird]-vecCenter[pView->axThird];
HitData.uData = 0;
if (pView->CheckDistance(point, vecClientCenter, HANDLE_RADIUS))
{
return true;
}
else if (!Options.view2d.bSelectbyhandles || !IsEditable() )
{
//
// See if any edges are within certain distance from the the point.
//
int iSelUnits = 2;
int x1 = point.x - iSelUnits;
int x2 = point.x + iSelUnits;
int y1 = point.y - iSelUnits;
int y2 = point.y + iSelUnits;
int nFaces = GetFaceCount();
for (int i = 0; i < nFaces; i++)
{
CMapFace *pFace = GetFace(i);
int nPoints = pFace->nPoints;
if (nPoints > 0)
{
Vector *pPoints = pFace->Points;
Vector2D vec1;
pView->WorldToClient(vec1, pPoints[0]);
for (int j = 1; j < nPoints; j++)
{
Vector2D vec2;
pView->WorldToClient(vec2, pPoints[j]);
if (IsLineInside(vec1, vec2, x1, y1, x2, y2))
{
return true;
}
else
{
vec1 = vec2;
}
}
}
}
}
HitData.pObject = NULL;
return false;
}
bool CMapSolid::SaveDXF(ExportDXFInfo_s *pInfo)
{
if (pInfo->bVisOnly)
{
if (!IsVisible())
{
return true;
}
}
CSSolid *pStrucSolid = new CSSolid;
pStrucSolid->Attach(this);
pStrucSolid->Convert( true, true );
pStrucSolid->SerializeDXF(pInfo->fp, pInfo->nObject++);
delete pStrucSolid;
// Serialize displacements
for (int i = 0; i < GetFaceCount(); ++i)
{
CMapFace *pMapFace = GetFace( i );
if (pMapFace->HasDisp())
{
EditDispHandle_t hDisp = pMapFace->GetDisp();
CMapDisp *pDisp = EditDispMgr()->GetDisp( hDisp );
if (!pDisp->SaveDXF( pInfo ))
return FALSE;
}
}
return TRUE;
}
//-----------------------------------------------------------------------------
// Called any time this object is modified by Undo or Redo.
//-----------------------------------------------------------------------------
void CMapSolid::OnUndoRedo()
{
int nFaces = GetFaceCount();
for (int i = 0; i < nFaces; i++)
{
CMapFace *pFace = GetFace(i);
pFace->OnUndoRedo();
}
}