324 lines
9.4 KiB
C++
324 lines
9.4 KiB
C++
// Filename:- autocaulk.cpp
|
|
//
|
|
#include "stdafx.h"
|
|
#include "qe3.h"
|
|
#include "oddbits.h"
|
|
//
|
|
#include "autocaulk.h"
|
|
|
|
|
|
#pragma warning( disable : 4786)
|
|
#include <list>
|
|
using namespace std;
|
|
#pragma warning( disable : 4786)
|
|
|
|
|
|
// for some tedious reason, I can't include "brush.h" here, so...
|
|
//
|
|
extern void ClearBounds (vec3_t mins, vec3_t maxs);
|
|
extern void AddPointToBounds (const vec3_t v, vec3_t mins, vec3_t maxs);
|
|
|
|
static void FloorBounds(vec3_t mins, vec3_t maxs)
|
|
{
|
|
for (int i=0 ; i<3 ; i++)
|
|
{
|
|
mins[i] = floor(mins[i] + 0.5);
|
|
maxs[i] = floor(maxs[i] + 0.5);
|
|
}
|
|
}
|
|
|
|
/*
|
|
typedef struct
|
|
{
|
|
vec3_t v3Mins;
|
|
vec3_t v3Maxs;
|
|
vec3_t v3TL,v3TR,v3BL,v3BR;
|
|
vec3_t v3NormalisedRotationVector;
|
|
vec3_t v3NormalisedElevationVector;
|
|
|
|
} SquaredFace_t;
|
|
|
|
// make an artificial square face that encompasses all the points in the winding...
|
|
//
|
|
static void WindingToSquaredFace( SquaredFace_t *pSquareFaceDest, winding_t *pWinding)
|
|
{
|
|
// memset(pSquareFaceDest,0,sizeof(*pSquareFaceDest);
|
|
|
|
ClearBounds(pSquareFaceDest->v3Mins, pSquareFaceDest->v3Maxs);
|
|
|
|
for (int i=0; i<pWinding->numpoints ; i++)
|
|
{
|
|
AddPointToBounds( pWinding->points[i], pSquareFaceDest->v3Mins, pSquareFaceDest->v3Maxs );
|
|
}
|
|
|
|
VectorCopy(pSquareFaceDest->v3Mins, pSquareFaceDest->v3BL);
|
|
VectorCopy(pSquareFaceDest->v3Maxs, pSquareFaceDest->v3TR);
|
|
|
|
VectorCopy(pSquareFaceDest->v3Mins, pSquareFaceDest->v3TL);
|
|
pSquareFaceDest->v3TL[2] = pSquareFaceDest->v3Maxs[2];
|
|
VectorCopy(pSquareFaceDest->v3Maxs, pSquareFaceDest->v3BR);
|
|
pSquareFaceDest->v3BR[2] = pSquareFaceDest->v3Mins[2];
|
|
|
|
VectorSubtract( pSquareFaceDest->v3TR, pSquareFaceDest->v3TL, pSquareFaceDest->v3NormalisedRotationVector);
|
|
VectorNormalize(pSquareFaceDest->v3NormalisedRotationVector);
|
|
|
|
VectorSubtract( pSquareFaceDest->v3TL, pSquareFaceDest->v3BL, pSquareFaceDest->v3NormalisedElevationVector);
|
|
VectorNormalize(pSquareFaceDest->v3NormalisedElevationVector);
|
|
}
|
|
*/
|
|
|
|
static LPCSTR vtos(vec3_t v3)
|
|
{
|
|
return va("%.3ff,%.3f,%.3f",v3[0],v3[1],v3[2]);
|
|
}
|
|
list < pair < face_t*, brush_t*> > FacesToCaulk;
|
|
void Select_AutoCaulk(bool bMakeDetail)
|
|
{
|
|
Sys_Printf ("Caulking...\n");
|
|
|
|
FacesToCaulk.clear();
|
|
|
|
int iSystemBrushesSkipped = 0;
|
|
|
|
brush_t *next;
|
|
for (brush_t *pSelectedBrush = selected_brushes.next ; pSelectedBrush != &selected_brushes ; pSelectedBrush = next)
|
|
{
|
|
next = pSelectedBrush->next;
|
|
|
|
if (pSelectedBrush->owner->eclass->fixedsize)
|
|
continue; // apparently this means it's a model, so skip it...
|
|
|
|
// new check, we can't caulk a brush that has any "system/" faces...
|
|
//
|
|
bool bSystemFacePresent = false;
|
|
for (face_t *pSelectedFace = pSelectedBrush->brush_faces; pSelectedFace; pSelectedFace = pSelectedFace->next)
|
|
{
|
|
if (!strnicmp(pSelectedFace->d_texture->name,"system/",7))
|
|
{
|
|
bSystemFacePresent = true;
|
|
break;
|
|
}
|
|
}
|
|
if (bSystemFacePresent)
|
|
{
|
|
iSystemBrushesSkipped++;
|
|
continue; // verboten to caulk this.
|
|
}
|
|
|
|
for (int iBrushListToScan = 0; iBrushListToScan<2; iBrushListToScan++)
|
|
{
|
|
brush_t *snext;
|
|
for (brush_t *pScannedBrush = (iBrushListToScan?active_brushes.next:selected_brushes.next); pScannedBrush != (iBrushListToScan?&active_brushes:&selected_brushes) ; pScannedBrush = snext)
|
|
{
|
|
snext = pScannedBrush->next;
|
|
|
|
if ( pScannedBrush == pSelectedBrush)
|
|
continue;
|
|
|
|
if (pScannedBrush->owner->eclass->fixedsize || pScannedBrush->patchBrush || pScannedBrush->hiddenBrush)
|
|
continue;
|
|
|
|
if (FilterBrush(pScannedBrush))
|
|
continue;
|
|
|
|
//face_t *pFace = pScannedBrush->brush_faces;
|
|
if (pScannedBrush->brush_faces->d_texture->bFromShader && (pScannedBrush->brush_faces->d_texture->nShaderFlags & QER_NOCARVE))
|
|
continue;
|
|
|
|
// basic-reject first to see if brushes can even possibly touch (coplanar counts as touching)
|
|
//
|
|
for (int i=0 ; i<3 ; i++)
|
|
{
|
|
if (pSelectedBrush->mins[i] > pScannedBrush->maxs[i] ||
|
|
pSelectedBrush->maxs[i] < pScannedBrush->mins[i])
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if (i != 3)
|
|
continue; // can't be touching
|
|
|
|
// ok, now for the clever stuff, we need to detect only those faces that are both coplanar and smaller
|
|
// or equal to the face they're coplanar with...
|
|
//
|
|
for (pSelectedFace = pSelectedBrush->brush_faces; pSelectedFace; pSelectedFace = pSelectedFace->next)
|
|
{
|
|
winding_t *pSelectedWinding = pSelectedFace->face_winding;
|
|
|
|
if (!pSelectedWinding)
|
|
continue; // freed face, probably won't happen here, but who knows with this program?
|
|
|
|
// SquaredFace_t SelectedSquaredFace;
|
|
// WindingToSquaredFace( &SelectedSquaredFace, pSelectedWinding);
|
|
|
|
for (face_t *pScannedFace = pScannedBrush->brush_faces; pScannedFace; pScannedFace = pScannedFace->next)
|
|
{
|
|
// don't even try caulking against a system face, because these are often transparent and will leave holes
|
|
//
|
|
if (!strnicmp(pScannedFace->d_texture->name,"system/",7))
|
|
continue;
|
|
|
|
// and don't try caulking against something inherently transparent...
|
|
//
|
|
if (pScannedFace->d_texture->nShaderFlags & QER_TRANS)
|
|
continue;
|
|
|
|
winding_t *pScannedWinding = pScannedFace->face_winding;
|
|
|
|
if (!pScannedWinding)
|
|
continue; // freed face, probably won't happen here, but who knows with this program?
|
|
|
|
// SquaredFace_t ScannedSquaredFace;
|
|
// WindingToSquaredFace( &ScannedSquaredFace, pScannedWinding);
|
|
|
|
/* if (VectorCompare(ScannedSquaredFace.v3NormalisedRotationVector, SelectedSquaredFace.v3NormalisedRotationVector)
|
|
&&
|
|
VectorCompare(ScannedSquaredFace.v3NormalisedElevationVector, SelectedSquaredFace.v3NormalisedElevationVector)
|
|
)
|
|
*/
|
|
{
|
|
// brush faces are in parallel planes to each other, so check that their normals
|
|
// are opposite, by adding them together and testing for zero...
|
|
// (if normals are opposite, then faces can be against/touching each other?)
|
|
//
|
|
vec3_t v3ZeroTest;
|
|
static vec3_t v3Zero={0,0,0};
|
|
VectorAdd(pSelectedFace->plane.normal,pScannedFace->plane.normal,v3ZeroTest);
|
|
if (VectorCompare(v3ZeroTest,v3Zero))
|
|
{
|
|
// planes are facing each other...
|
|
//
|
|
// coplanar? (this is some maths of Gil's, which I don't even pretend to understand)
|
|
//
|
|
float fTotalDist = 0;
|
|
for (int _i=0; _i<3; _i++)
|
|
{
|
|
fTotalDist += fabs( DotProduct(pSelectedFace->plane.normal,pSelectedWinding->points[0])
|
|
-
|
|
DotProduct(pSelectedFace->plane.normal,pScannedWinding->points[i])
|
|
);
|
|
}
|
|
//OutputDebugString(va("Dist = %g\n",fTotalDist));
|
|
|
|
if (fTotalDist > 0.01)
|
|
continue;
|
|
|
|
// every point in the selected face must be within (or equal to) the bounds of the
|
|
// scanned face...
|
|
//
|
|
// work out the bounds first...
|
|
//
|
|
vec3_t v3ScannedBoundsMins, v3ScannedBoundsMaxs;
|
|
ClearBounds (v3ScannedBoundsMins, v3ScannedBoundsMaxs);
|
|
for (int iPoint=0; iPoint<pScannedWinding->numpoints; iPoint++)
|
|
{
|
|
AddPointToBounds( pScannedWinding->points[iPoint], v3ScannedBoundsMins, v3ScannedBoundsMaxs);
|
|
}
|
|
// floor 'em... (or .001 differences mess things up...
|
|
//
|
|
FloorBounds(v3ScannedBoundsMins, v3ScannedBoundsMaxs);
|
|
|
|
|
|
// now check points from selected face...
|
|
//
|
|
bool bWithin = true;
|
|
for (iPoint=0; iPoint < pSelectedWinding->numpoints; iPoint++)
|
|
{
|
|
for (int iXYZ=0; iXYZ<3; iXYZ++)
|
|
{
|
|
float f = floor(pSelectedWinding->points[iPoint][iXYZ] + 0.5);
|
|
if (!
|
|
(
|
|
f >= v3ScannedBoundsMins[iXYZ]
|
|
&&
|
|
f <= v3ScannedBoundsMaxs[iXYZ]
|
|
)
|
|
)
|
|
{
|
|
bWithin = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bWithin)
|
|
{
|
|
FacesToCaulk.push_back( pair<face_t*, brush_t*>(pSelectedFace,pSelectedBrush));
|
|
|
|
/*
|
|
OutputDebugString("Pair:\n");
|
|
OutputDebugString(vtos(pSelectedFace->plane.normal));
|
|
OutputDebugString("\n");
|
|
OutputDebugString(vtos(pScannedFace->plane.normal));
|
|
OutputDebugString("\n");
|
|
|
|
int z=1;
|
|
*/
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// apply caulk...
|
|
//
|
|
int iFacesCaulked = 0;
|
|
if (FacesToCaulk.size())
|
|
{
|
|
LPCSTR psCaulkName = "system/caulk";
|
|
qtexture_t *pCaulk = Texture_ForName(psCaulkName);
|
|
|
|
if (pCaulk)
|
|
{
|
|
//
|
|
// and call some other junk that Radiant wants so so we can use it later...
|
|
//
|
|
texdef_t tex;
|
|
memset (&tex, 0, sizeof(tex));
|
|
tex.scale[0] = 1;
|
|
tex.scale[1] = 1;
|
|
tex.flags = pCaulk->flags;
|
|
tex.value = pCaulk->value;
|
|
tex.contents = pCaulk->contents;
|
|
strcpy (tex.name, pCaulk->name);
|
|
|
|
//Texture_SetTexture (&tex);
|
|
|
|
for (list< pair < face_t*, brush_t*> >::iterator it = FacesToCaulk.begin(); it!= FacesToCaulk.end(); ++it)
|
|
{
|
|
face_t *pFace = (*it).first;
|
|
brush_t*pBrush= (*it).second;
|
|
|
|
memcpy(&pFace->texdef,&tex,sizeof(tex));
|
|
|
|
Face_FitTexture(pFace, 1, 1); // this doesn't work here for some reason... duh.
|
|
Brush_Build(pBrush);
|
|
|
|
iFacesCaulked++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Sys_Printf(" Unable to locate caulk texture at: \"%s\"!\n",psCaulkName);
|
|
}
|
|
}
|
|
|
|
Sys_Printf("( %d faces caulked )\n",iFacesCaulked);
|
|
|
|
if (iSystemBrushesSkipped)
|
|
{
|
|
Sys_Printf("( %d system-faced brushes skipped )\n",iSystemBrushesSkipped);
|
|
}
|
|
|
|
if (bMakeDetail)
|
|
{
|
|
Select_MakeDetail( false );
|
|
}
|
|
|
|
Sys_UpdateWindows (W_ALL);
|
|
}
|
|
|