Serious-Engine/Sources/Engine/Brushes/BrushTriangularize.cpp
2016-03-11 15:57:17 +02:00

959 lines
30 KiB
C++

/* Copyright (c) 2002-2012 Croteam Ltd. All rights reserved. */
#include "stdh.h"
#include <Engine/Brushes/Brush.h>
#include <Engine/Templates/DynamicArray.cpp>
#include <Engine/Templates/StaticArray.cpp>
#include <Engine/Templates/StaticStackArray.cpp>
#include <Engine/Math/Float.h>
#include <Engine/Math/Geometry.inl>
#include <Engine/Base/Stream.h>
#include <Engine/Base/Console.h>
// define this to dump all triangularization steps to debugging output
//#define DUMP_ALLSTEPS 1
//#define OPERATEIN2D 1
// this must not be caught by the dependency catcher!
static CTFileName _fnmDebugOutput(CTString("Temp\\Triangularization.out"));
// set if debug output file is open
static BOOL _bDebugOutputOpen = FALSE;
// file where debugging output is written to
static CTFileStream _strmDebugOutput;
// edge splitting epsilon
//#define EPSILON 0.0
//#define EPSILON (1.0/8388608.0) // 1/2^23
#define EPSILON (1.0f/65536.0f) // 1/2^16
//#define EPSILON DOUBLE(0.00390625) // 1/2^8
//#define EPSILON 0.0009765625f // 1/2^10
//#define EPSILON 0.03125f // 1/2^5
//#define EPSILON 0.00390625f // 1/2^8
// minimum triangle quality that is trivially accepted
#define QUALITY_ACCEPTTRIVIALLY DOUBLE(0.01)
// this function is here to satisfy compiler's weird need when compiling
// the template for CDynamicArray<CBrushVertex *>
inline void Clear(CBrushVertex *pbvx) {
(void)pbvx;
};
/*
Algorithm used:
We take each edge and each vertex that is left of that edge, and try to find out
if the edge and the vertex can span a triangle on the polygon without itersecting
any other edges.
A simple convex BSP is used for testing intersection. The triangle edges are
represented by planes oriented outwards (to the right side of the edge).
Triangle quality is defined as division of the area and square of the length of
the longest edge. We always try to extract the triangle with the best quality. Note
that clockwise triangles will have negative area.
Also we remember if there is left and/or right edge that connects
the edge and the vertex. That makes it posible to geometricaly remove the triangle
from the array of edges if it satisfies.
Although it is teoretically true that every polygon can be triangularized this way,
it is not always possible to find triangle with positive area that doesn't intersect
any edges in the polygon. This is due to the numerical inprecisions created during CSG
or similar operations.
Therefore, we define comparation between two triangles this way:
(1) Triangle that doesn't intersect any edges is better than one that does.
(2) When (1) is indeterminate, the one with greater quality is considered better.
Note that a triangle with negative area can be found best. In such case, it is not really
created, but only removed from the polygon. This is mostly the case with some small
degenerate parts of polygons. This way, the problematic case is just eliminated without
loosing too much precision in the triangularized representation of the polygon.
This method can diverge by adding and removing same triangle repeatedly. Therefore,
we don't always start at testing at the first edge in polygon, but move the starting
point when we find some triangle, 'shuffling' the choices of new triangles that way.
*/
// a class that handles triangularization of a polygon
class CTriangularizer {
public:
DOUBLE3D tr_vPolygonNormal;
// reference to original polygon (just for debugging)
CBrushPolygon &tr_bpoOriginalPolygon;
// reference to original array of polygon edges
CStaticArray<CBrushPolygonEdge> &tr_abpeOriginalEdges;
// temporary array of edges
CDynamicArray<CBrushEdge> tr_abedEdges;
// major axes of the polygon plane
INDEX tr_iAxis0;
INDEX tr_iAxis1;
// these describe the triangle curently considered
CBrushEdge *tr_pbedLeft; // left edge of the triangle if found
CBrushEdge *tr_pbedRight; // right edge of the triangle if found
CBrushEdge *tr_pbedBottom; // bottom edge of the triangle
CBrushVertex *tr_pbvxTopVertex; // top vertex of the triangle
DOUBLEplane3D tr_plLeft; // splitter plane of left edge
DOUBLEplane3D tr_plRight; // splitter plane of right edge
DOUBLEplane3D tr_plBottom; // splitter plane of bottom edge
DOUBLEplane3D tr_plEdgeConsidered; // splitter plane of the edge considered bottom
// these describe the best triangle found yet
DOUBLE tr_fQualityBest; // quality of the best triangle
BOOL tr_bIntersectedBest; // set if best triangle intersects some edges
CBrushEdge *tr_pbedLeftBest; // left edge of the triangle if found
CBrushEdge *tr_pbedRightBest; // right edge of the triangle if found
CBrushEdge *tr_pbedBottomBest; // bottom edge of the triangle
CBrushVertex *tr_pbvxTopVertexBest; // top vertex of the triangle
// get a vertex coordinates
inline DOUBLE3D GetVertex(CBrushVertex *pbvx) const;
/* Create a splitter plane for an edge. */
inline void EdgeToPlane(const DOUBLE3D &vVertex0, const DOUBLE3D &vVertex1,
DOUBLEplane3D &plPlane) const;
/* Clip edge to a plane and check if something remains behind. */
BOOL ClipEdge(DOUBLE3D &vVertex0, DOUBLE3D &vVertex1, const DOUBLEplane3D &plPlane) const;
/* Check if an edge is entirely or partially inside considered triangle. */
BOOL EdgeInsideTriangle(const CBrushEdge *pbed) const;
/* Calculate the quality of currently considered triangle. */
DOUBLE TriangleQuality(void) const;
/* Check that duplicate or reverse edges do not exist. */
void CheckForInvalidEdges(void);
/* Add given edge to temporary array. */
void AddEdge(CBrushVertex *pbvxVertex0, CBrushVertex *pbvxVertex1);
/* Create an array of forward oriented edges from polygon edges of a polygon. */
void MakeEdgesForTriangularization(void);
/* Test all edges for intersection with considered triangle. */
BOOL CheckTriangleAgainstEdges(void);
/* Find best triangle in array of edges. */
void FindBestTriangle(void);
/* Find if left/right triangle edges already exist. */
void FindExistingTriangleEdges(void);
/* Remove best triangle from edges. */
void RemoveBestTriangleFromPolygon(void);
/* Add best triangle to triangles. */
void AddBestTriangleToTriangles(void);
/* Print a statement to debugging output file. */
void DPrintF(char *strFormat, ...);
/* Dump triangle edges to debug output. */
void DumpEdges(void);
// find vertices used without duplication
void FindVerticesUsed(void);
// build array of element indices
void MakeElements(void);
public:
// target array for resulting triangles
CDynamicArray<CBrushVertex *> tr_apbvxTriangleVertices;
// array for vertices without duplicates
CStaticStackArray<CBrushVertex *> tr_apbvxVertices;
// array for triangle elements
CStaticArray<INDEX> tr_aiElements;
/* Constructor - do triangularization for a polygon. */
CTriangularizer(CBrushPolygon &bpoOriginalPolygon);
INDEX tr_iError;
};
// get a vertex coordinates
inline DOUBLE3D CTriangularizer::GetVertex(CBrushVertex *pbvx) const
{
#ifdef OPERATEIN2D
return DOUBLE3D(
pbvx->bvx_vdPreciseRelative(tr_iAxis0),
pbvx->bvx_vdPreciseRelative(tr_iAxis1),
0);
#else
return pbvx->bvx_vdPreciseRelative;
#endif
}
/*
* Create a splitter plane for an edge.
*/
inline void CTriangularizer::EdgeToPlane(const DOUBLE3D &vVertex0, const DOUBLE3D &vVertex1,
DOUBLEplane3D &plPlane) const
{
// make a plane containing the edge, perpendicular to the polygon plane, looking
// to the right of the edge
plPlane = DOUBLEplane3D((vVertex1-vVertex0)*tr_vPolygonNormal, vVertex0);
}
/*
* Clip edge to a plane and check if something remains behind.
*/
BOOL CTriangularizer::ClipEdge(DOUBLE3D &vVertex0, DOUBLE3D &vVertex1,
const DOUBLEplane3D &plPlane) const
{
// calculate point distances from clip plane
DOUBLE fDistance0 = plPlane.PointDistance(vVertex0);
DOUBLE fDistance1 = plPlane.PointDistance(vVertex1);
/* ---- first point behind plane ---- */
if (fDistance0 < -EPSILON) {
// if both are back
if (fDistance1 < -EPSILON) {
// whole edge is behind
return TRUE;
// if first is back, second front
} else if (fDistance1 > +EPSILON) {
// calculate intersection coordinates
vVertex1 = vVertex0-(vVertex0-vVertex1)*fDistance0/(fDistance0-fDistance1);
// the remaining part is behind
return TRUE;
// if first is back, second on the plane
} else {
// the whole edge is back
return TRUE;
}
/* ---- first point in front of plane ---- */
} else if (fDistance0 > +EPSILON) {
// if first is front, second back
if (fDistance1 < -EPSILON) {
// calculate intersection coordinates
vVertex0 = vVertex1-(vVertex1-vVertex0)*fDistance1/(fDistance1-fDistance0);
// the remaining part is behind
return TRUE;
// if both are front
} else if (fDistance1 > +EPSILON) {
// whole edge is front
return FALSE;
// if first is front, second on the plane
} else {
// whole edge is front
return FALSE;
}
/* ---- first point on the plane ---- */
} else {
// if first is on the plane, second back
if (fDistance1 < -EPSILON) {
// the whole edge is back
return TRUE;
// if first is on the plane, second front
} else if (fDistance1 > +EPSILON) {
// whole edge is front
return FALSE;
// if both are on the plane
} else {
// assume the whole edge is back (!!!! is this correct?)
return TRUE;
}
}
}
/*
* Check if an edge is entirely or partially inside considered triangle.
*/
BOOL CTriangularizer::EdgeInsideTriangle(const CBrushEdge *pbed) const
{
// copy edge vertices
DOUBLE3D vVertex0, vVertex1;
vVertex0 = GetVertex(pbed->bed_pbvxVertex0);
vVertex1 = GetVertex(pbed->bed_pbvxVertex1);
// try to clip it to each triangle edge in turn,
// if anything remains behind - it is inside
return (ClipEdge(vVertex0, vVertex1, tr_plLeft)
&&ClipEdge(vVertex0, vVertex1, tr_plRight)
&&ClipEdge(vVertex0, vVertex1, tr_plBottom));
}
/*
* Calculate the quality of currently considered triangle.
*/
DOUBLE CTriangularizer::TriangleQuality(void) const
{
DOUBLE3D vEdgeBottom = GetVertex(tr_pbedBottom->bed_pbvxVertex1)
- GetVertex(tr_pbedBottom->bed_pbvxVertex0);
DOUBLE3D vEdgeLeft = GetVertex(tr_pbedBottom->bed_pbvxVertex0)
- GetVertex(tr_pbvxTopVertex);
DOUBLE3D vEdgeRight = GetVertex(tr_pbvxTopVertex)
- GetVertex(tr_pbedBottom->bed_pbvxVertex1);
// calculate triangle normal as cross product of two edges
DOUBLE3D vNormal = vEdgeLeft*(-vEdgeRight);
// calculate area as half the length of the normal
DOUBLE fArea = vNormal.Length()/ DOUBLE(2.0);
// area must be initially positive
ASSERT(fArea>=0);
// if triangle normal is opposite to the polygon normal
if (vNormal%tr_vPolygonNormal<0) {
// make area negative
fArea = -fArea;
}
// find length of all edges
DOUBLE fLengthBottom = vEdgeBottom.Length();
DOUBLE fLengthLeft = vEdgeLeft .Length();
DOUBLE fLengthRight = vEdgeRight .Length();
// find maximum length
DOUBLE fLengthMax = Max(fLengthBottom, Max(fLengthLeft, fLengthRight));
// maximum length must be positive
ASSERT(fLengthMax>0.0f);
// quality is division of the area and square of the length of the longest edge
return fArea/(fLengthMax*fLengthMax);
}
/*
* Create an array of forward oriented edges from polygon edges of a polygon.
*/
void CTriangularizer::MakeEdgesForTriangularization(void)
{
// get number of edges in polygon
INDEX ctEdges = tr_abpeOriginalEdges.Count();
// create that much edges in the array
CBrushEdge *pbedEdges = tr_abedEdges.New(ctEdges);
tr_abedEdges.Lock();
// for each edge
for(INDEX iEdge=0; iEdge<ctEdges; iEdge++) {
CBrushPolygonEdge &bpe = tr_abpeOriginalEdges[iEdge];
CBrushEdge &bed = tr_abedEdges[iEdge];
// if polygon edge is reversed
if (bpe.bpe_bReverse) {
// make edge in array reversed
bed.bed_pbvxVertex0 = bpe.bpe_pbedEdge->bed_pbvxVertex1;
bed.bed_pbvxVertex1 = bpe.bpe_pbedEdge->bed_pbvxVertex0;
// if polygon edge is not reversed
} else {
// make edge in array normal
bed.bed_pbvxVertex0 = bpe.bpe_pbedEdge->bed_pbvxVertex0;
bed.bed_pbvxVertex1 = bpe.bpe_pbedEdge->bed_pbvxVertex1;
}
}
tr_abedEdges.Unlock();
}
/*
* Add given edge to temporary array.
*/
void CTriangularizer::AddEdge(CBrushVertex *pbvxVertex0, CBrushVertex *pbvxVertex1)
{
#ifndef NDEBUG
// for each edge
{FOREACHINDYNAMICARRAY(tr_abedEdges, CBrushEdge, itbed) {
// must not exist
if (itbed->bed_pbvxVertex0 == pbvxVertex0
&&itbed->bed_pbvxVertex1 == pbvxVertex1) {
return;
}
ASSERT(itbed->bed_pbvxVertex0 != pbvxVertex0
||itbed->bed_pbvxVertex1 != pbvxVertex1);
// must not have reverse
ASSERT(itbed->bed_pbvxVertex0 != pbvxVertex1
||itbed->bed_pbvxVertex1 != pbvxVertex0);
}}
#endif
// add new edge
CBrushEdge *pbedNew = tr_abedEdges.New(1);
pbedNew->bed_pbvxVertex0 = pbvxVertex0;
pbedNew->bed_pbvxVertex1 = pbvxVertex1;
}
/*
* Check that duplicate or reverse edges do not exist.
*/
void CTriangularizer::CheckForInvalidEdges(void)
{
// for each edge
{FOREACHINDYNAMICARRAY(tr_abedEdges, CBrushEdge, itbed1) {
// for each edge
{FOREACHINDYNAMICARRAY(tr_abedEdges, CBrushEdge, itbed2) {
// if same edge
if (&*itbed1 == &*itbed2) {
// skip
continue;
}
CBrushEdge *pbed1 = itbed1;
CBrushEdge *pbed2 = itbed2;
// must not exist
ASSERT(pbed1->bed_pbvxVertex0 != pbed2->bed_pbvxVertex0
||pbed1->bed_pbvxVertex1 != pbed2->bed_pbvxVertex1);
// must not have reverse
ASSERT(pbed1->bed_pbvxVertex0 != pbed2->bed_pbvxVertex1
||pbed1->bed_pbvxVertex1 != pbed2->bed_pbvxVertex0);
}}
}}
}
/*
* Add best triangle to triangles.
*/
void CTriangularizer::AddBestTriangleToTriangles(void)
{
// add the triangle to triangles
CBrushVertex **ppbvxTriangle = tr_apbvxTriangleVertices.New(3);
ppbvxTriangle[0] = tr_pbedBottomBest->bed_pbvxVertex0;
ppbvxTriangle[1] = tr_pbedBottomBest->bed_pbvxVertex1;
ppbvxTriangle[2] = tr_pbvxTopVertexBest;
}
/*
* Remove best triangle from edges.
*/
void CTriangularizer::RemoveBestTriangleFromPolygon(void)
{
tr_pbedBottom = tr_pbedBottomBest;
tr_pbvxTopVertex = tr_pbvxTopVertexBest;
FindExistingTriangleEdges();
tr_pbedLeftBest = tr_pbedLeft;
tr_pbedRightBest = tr_pbedRight;
tr_pbedBottomBest = tr_pbedBottom;
tr_pbvxTopVertexBest = tr_pbvxTopVertex;
// if left edge was found
if (tr_pbedLeftBest!=NULL) {
// remove the left edge from the edges
tr_abedEdges.Delete(tr_pbedLeftBest);
// if left edge was not found
} else {
// add reverse of the left edge to the edges
AddEdge(tr_pbedBottomBest->bed_pbvxVertex0, tr_pbvxTopVertexBest);
}
// if right edge was found
if (tr_pbedRightBest!=NULL) {
// remove the right edge from the edges
tr_abedEdges.Delete(tr_pbedRightBest);
// if right edge was not found
} else {
// add reverse of the right edge to the edges
AddEdge(tr_pbvxTopVertexBest, tr_pbedBottomBest->bed_pbvxVertex1);
}
// remove the base edge from the edges
tr_abedEdges.Delete(tr_pbedBottomBest);
}
/*
* Find if left/right triangle edges already exist.
*/
void CTriangularizer::FindExistingTriangleEdges(void)
{
// initialize left edge as not existing
tr_pbedLeft = NULL;
// initialize right edge as not existing
tr_pbedRight = NULL;
// for each edge
FOREACHINDYNAMICARRAY(tr_abedEdges, CBrushEdge, itbed) {
CBrushEdge *pbed = itbed;
// if it is the bottom edge of the triangle
if (tr_pbedBottom == itbed) {
// do not test it for intersection
NOTHING;
// if it is not bottom edge of triangle
} else {
ASSERT(itbed->bed_pbvxVertex0 != tr_pbedBottom->bed_pbvxVertex0
||itbed->bed_pbvxVertex1 != tr_pbedBottom->bed_pbvxVertex1);
// if it is the left edge of the triangle
if (itbed->bed_pbvxVertex1 == tr_pbedBottom->bed_pbvxVertex0
&&itbed->bed_pbvxVertex0 == tr_pbvxTopVertex) {
// remember it as the left edge
ASSERT(tr_pbedLeft==NULL);
tr_pbedLeft = itbed;
// if it is the right edge of the triangle
} else if (itbed->bed_pbvxVertex0 == tr_pbedBottom->bed_pbvxVertex1
&&itbed->bed_pbvxVertex1 == tr_pbvxTopVertex) {
// remember it as the right edge
ASSERT(tr_pbedRight==NULL);
tr_pbedRight = itbed;
}
}
}
}
/*
* Test all edges for intersection with considered triangle.
*/
BOOL CTriangularizer::CheckTriangleAgainstEdges(void)
{
// for each edge
FOREACHINDYNAMICARRAY(tr_abedEdges, CBrushEdge, itbed) {
CBrushEdge *pbed = itbed;
// if it is the bottom edge of the triangle
if (tr_pbedBottom == itbed) {
// do not test it for intersection
NOTHING;
// if it is not bottom edge of triangle
} else {
ASSERT(itbed->bed_pbvxVertex0 != tr_pbedBottom->bed_pbvxVertex0
||itbed->bed_pbvxVertex1 != tr_pbedBottom->bed_pbvxVertex1);
// if it is the left edge of the triangle
if (itbed->bed_pbvxVertex1 == tr_pbedBottom->bed_pbvxVertex0
&&itbed->bed_pbvxVertex0 == tr_pbvxTopVertex) {
// do not test it for intersection
NOTHING;
// if it is the right edge of the triangle
} else if (itbed->bed_pbvxVertex0 == tr_pbedBottom->bed_pbvxVertex1
&&itbed->bed_pbvxVertex1 == tr_pbvxTopVertex) {
// do not test it for intersection
NOTHING;
// if it is neither of triangle edges
} else {
// if this edge intersects with any of the triangle edges
if (EdgeInsideTriangle(itbed)) {
return TRUE;
}
}
}
}
// if no intersections are found
return FALSE;
}
// calculate edge direction (COPIED FROM CTMATH!)
void EdgeDir(const DOUBLE3D &vPoint0, const DOUBLE3D &vPoint1,
DOUBLE3D &vDirection, DOUBLE3D &vReferencePoint)
{
// if the vertices are reversed
/* if (CompareVertices(vPoint0, vPoint1)<0) {
// swap them
Swap(vPoint0, vPoint1);
// mark edge as reversed
edx_bReverse = TRUE;
// if the vertices are not reversed
} else {
// mark edge as not reversed
edx_bReverse = FALSE;
}
*/
// normalize the direction
vDirection = (vPoint1-vPoint0).Normalize();
/* calculate the reference point on the line from any point on line (p) and direction (d):
r = p - ((p.d)/(d.d))*d
*/
vReferencePoint = vPoint0 -
vDirection * ((vPoint0 % vDirection))/(vDirection % vDirection);
}
/*
* Print a statement to debugging output file.
*/
void CTriangularizer::DPrintF(char *strFormat, ...)
{
char strBuffer[256];
// format the message in buffer
va_list arg;
va_start(arg, strFormat);
vsprintf(strBuffer, strFormat, arg);
// if the debug output file is not open
if (!_bDebugOutputOpen) {
// open it
try {
_strmDebugOutput.Create_t(_fnmDebugOutput, CTStream::CM_TEXT);
_bDebugOutputOpen = TRUE;
// if not successful
} catch (char *strError) {
(void) strError;
// print nothing
return;
}
}
// write the message to the file
_strmDebugOutput.Write_t(strBuffer, strlen(strBuffer));
}
/*
* Dump triangle edges to debug output.
*/
void CTriangularizer::DumpEdges(void)
{
DPrintF("%d\n", tr_abedEdges.Count());
FOREACHINDYNAMICARRAY(tr_abedEdges, CBrushEdge, itbed) {
DPrintF("(%f, %f) ->",
GetVertex(itbed->bed_pbvxVertex0)(1),
GetVertex(itbed->bed_pbvxVertex0)(2));
DPrintF(" (%f, %f) ",
GetVertex(itbed->bed_pbvxVertex1)(1),
GetVertex(itbed->bed_pbvxVertex1)(2));
DOUBLE3D vDirection, vReferencePoint;
EdgeDir(
GetVertex(itbed->bed_pbvxVertex0), GetVertex(itbed->bed_pbvxVertex1),
vDirection, vReferencePoint);
DPrintF("[(%f, %f), ",
vDirection(1),
vDirection(2));
DPrintF("(%f, %f)]\n",
vReferencePoint(1),
vReferencePoint(2));
}
}
// edge offsets used to 'shuffle' triangularization
static INDEX iBottomEdgeOffset;
static INDEX iTopEdgeOffset;
/*
* Find best triangle in array of edges.
*/
/* NOTE: Currently only searching for first acceptable triangle.
*/
void CTriangularizer::FindBestTriangle(void)
{
// clear best triangle description
tr_fQualityBest = DOUBLE(-1E30);
tr_bIntersectedBest = TRUE;
tr_pbedLeftBest = NULL;
tr_pbedRightBest = NULL;
tr_pbedBottomBest = NULL;
tr_pbvxTopVertexBest = NULL;
iBottomEdgeOffset++;
// for each edge
tr_abedEdges.Lock();
INDEX ctEdges = tr_abedEdges.Count();
for(INDEX ibedBottom=0; ibedBottom<tr_abedEdges.Count(); ibedBottom++) {
// consider this edge as bottom edge of triangle
tr_pbedBottom = &tr_abedEdges[(ibedBottom+iBottomEdgeOffset)%ctEdges];
ASSERT(tr_pbedBottom->bed_pbvxVertex0 != tr_pbedBottom->bed_pbvxVertex1);
// create bottom splitter
EdgeToPlane(GetVertex(tr_pbedBottom->bed_pbvxVertex0),
GetVertex(tr_pbedBottom->bed_pbvxVertex1), tr_plEdgeConsidered);
iTopEdgeOffset++;
// for each edge
for(INDEX ibedTop=0; ibedTop<ctEdges; ibedTop++) {
// consider first vertex of this edge as top vertex of triangle
tr_pbvxTopVertex = tr_abedEdges[(ibedTop+ibedBottom+iTopEdgeOffset)%ctEdges].bed_pbvxVertex0;
// if the top vertex is one of the vertices of bottom edge
if ( tr_pbvxTopVertex == tr_pbedBottom->bed_pbvxVertex0
|| tr_pbvxTopVertex == tr_pbedBottom->bed_pbvxVertex1) {
// skip this triangle
continue;
}
// create bottom splitter from the bottom edge splitter
tr_plBottom = tr_plEdgeConsidered;
// create left splitter
EdgeToPlane(GetVertex(tr_pbvxTopVertex),
GetVertex(tr_pbedBottom->bed_pbvxVertex0), tr_plLeft);
// create right splitter
EdgeToPlane(GetVertex(tr_pbedBottom->bed_pbvxVertex1),
GetVertex(tr_pbvxTopVertex), tr_plRight);
// calculate its quality
DOUBLE fCurrentQuality = TriangleQuality();
// if triangle is clockwise
if (fCurrentQuality<0) {
continue;
// reverse its splitters
tr_plLeft.Flip();
tr_plRight.Flip();
tr_plBottom.Flip();
}
// check if no edges intersect with considered triangle
BOOL bCurrentIntersected = CheckTriangleAgainstEdges();
// if the current triangle is better than the best triangle yet
if ((tr_bIntersectedBest && !bCurrentIntersected)
||(tr_bIntersectedBest==bCurrentIntersected && fCurrentQuality>tr_fQualityBest)) {
// find if left/right triangle edges already exist.
FindExistingTriangleEdges();
// set current triangle as best triangle
tr_bIntersectedBest = bCurrentIntersected;
tr_fQualityBest = fCurrentQuality;
tr_pbedLeftBest = tr_pbedLeft;
tr_pbedRightBest = tr_pbedRight;
tr_pbedBottomBest = tr_pbedBottom;
tr_pbvxTopVertexBest = tr_pbvxTopVertex;
// if the triangle is trivially acceptable
if (!bCurrentIntersected && fCurrentQuality>=QUALITY_ACCEPTTRIVIALLY) {
// finish searching
tr_abedEdges.Unlock();
return;
}
}
}
}
tr_abedEdges.Unlock();
#if 0
// if no acceptable triangles have been found
if (tr_fQualityBest<???) {
/* dump all sector's vertices */
/*
FOREACHINSTATICARRAY(tr_bpoOriginalPolygon.bpo_pbscSector->bsc_abvxVertices,
CBrushVertex, itbvx) {
DPrintF("(0x%p, %f, %f, %f)\n", &(*itbvx),
(*itbvx)(1), (*itbvx)(2), (*itbvx)(3));
}
*/
// dump remaining edges
DPrintF("Triangularization failed!\n");
DPrintF("best quality found: %f\n", tr_fQualityBest);
DPrintF("Remaining edges:\n");
DumpEdges();
/* // dump all edges
tr_abedEdges.Clear();
MakeEdgesForTriangularization();
DumpEdges();
*/
// error!
ASSERTALWAYS("No acceptable triangles found for triangularization!");
FatalError("No acceptable triangles found for triangularization!\n"
"Debugging information written to file '%s'.", _fnmDebugOutput);
}
#endif
}
// find vertices used without duplication
void CTriangularizer::FindVerticesUsed(void)
{
// make an empty array that will contain the vertices
tr_apbvxVertices.PopAll();
// for each triangle vertex
tr_apbvxTriangleVertices.Lock();
for(INDEX ipbvx=0; ipbvx<tr_apbvxTriangleVertices.Count(); ipbvx++) {
CBrushVertex *pbvx = tr_apbvxTriangleVertices[ipbvx];
// for each vertex already added
BOOL bFound=FALSE;
for(INDEX ipbvxAdded=0; ipbvxAdded<tr_apbvxVertices.Count(); ipbvxAdded++) {
// if it is the same one, stop searching
if (tr_apbvxVertices[ipbvxAdded]==pbvx) {
bFound = TRUE;
break;
}
}
// if not found
if (!bFound) {
// add it to the array
tr_apbvxVertices.Push() = pbvx;
}
}
tr_apbvxTriangleVertices.Unlock();
}
// build array of element indices
void CTriangularizer::MakeElements(void)
{
// make elements array
INDEX ctElements = tr_apbvxTriangleVertices.Count();
tr_aiElements.Clear();
tr_aiElements.New(ctElements);
// for each triangle vertex
tr_apbvxTriangleVertices.Lock();
for(INDEX i=0; i<ctElements; i++) {
CBrushVertex *pbvx = tr_apbvxTriangleVertices[i];
// find its element index
BOOL bFound=FALSE;
for(INDEX ipbvx=0; ipbvx<tr_apbvxVertices.Count(); ipbvx++) {
// if it is the same one, stop searching
if (tr_apbvxVertices[ipbvx]==pbvx) {
tr_aiElements[i] = ipbvx;
bFound = TRUE;
break;
}
}
ASSERT(bFound);
}
tr_apbvxTriangleVertices.Unlock();
}
/*
* Constructor - do triangularization for a polygon.
*/
CTriangularizer::CTriangularizer(CBrushPolygon &bpoOriginalPolygon)
: tr_bpoOriginalPolygon(bpoOriginalPolygon)
, tr_abpeOriginalEdges(bpoOriginalPolygon.bpo_abpePolygonEdges) // remember original edges
{
// find polygon normal and major axes
#ifdef OPERATEIN2D
INDEX iMaxNormal = bpoOriginalPolygon.bpo_pbplPlane->bpl_pldPreciseRelative.GetMaxNormal();
INDEX iMaxSign = Sgn(bpoOriginalPolygon.bpo_pbplPlane->bpl_pldPreciseRelative(iMaxNormal));
ASSERT(iMaxSign!=0);
switch(iMaxNormal) {
case 1:
if (iMaxSign==-1) {
tr_iAxis0 = 3; tr_iAxis1 = 2; tr_vPolygonNormal = DOUBLE3D(-1,0,0);
} else {
tr_iAxis0 = 2; tr_iAxis1 = 3; tr_vPolygonNormal = DOUBLE3D(1,0,0);
}
break;
case 2:
if (iMaxSign==-1) {
tr_iAxis0 = 1; tr_iAxis1 = 3; tr_vPolygonNormal = DOUBLE3D(0,-1,0);
} else {
tr_iAxis0 = 3; tr_iAxis1 = 1; tr_vPolygonNormal = DOUBLE3D(0,1,0);
}
break;
case 3:
if (iMaxSign==-1) {
tr_iAxis0 = 2; tr_iAxis1 = 1; tr_vPolygonNormal = DOUBLE3D(0,0,-1);
} else {
tr_iAxis0 = 1; tr_iAxis1 = 2; tr_vPolygonNormal = DOUBLE3D(0,0,1);
}
break;
default:
ASSERT(FALSE);
tr_iAxis0 = 2; tr_iAxis1 = 3; tr_vPolygonNormal = DOUBLE3D(1,0,0);
}
tr_vPolygonNormal = DOUBLE3D(0,0,1);
#else
tr_iAxis0 = -1; tr_iAxis1 = -1; tr_vPolygonNormal = bpoOriginalPolygon.bpo_pbplPlane->bpl_pldPreciseRelative;
#endif
// create a dynamic array of edges
MakeEdgesForTriangularization();
tr_iError = -1;
// estimate max number of triangles
INDEX ctOrgEdges = tr_abpeOriginalEdges.Count();
INDEX ctMaxHoles = ctOrgEdges;
INDEX ctMaxTriangles = ctOrgEdges-2+2*ctMaxHoles;
iBottomEdgeOffset = 0;
iTopEdgeOffset = 0;
#ifdef DUMP_ALLSTEPS
DPrintF("PolygonBegin\n");
#endif
// ASSERT(tr_abedEdges.Count()!=8);
// while the array of edges is not empty
//*
INDEX iPasses = 0;
while (tr_abedEdges.Count()>0) {
// if total number of triangles is too large, or searching too long
INDEX ctTriangles = tr_apbvxTriangleVertices.Count()/3;
if (ctTriangles>ctMaxTriangles*2 || iPasses>ctMaxTriangles*2) {
// error, quit triangulation
tr_iError = 2;
return;
}
#ifdef DUMP_ALLSTEPS
// dump remaining edges
DumpEdges();
#endif
// find best triangle
FindBestTriangle();
#ifdef DUMP_ALLSTEPS
DPrintF("BestQuality=%f\n", tr_fQualityBest);
#endif
// if no triangle is found
if (tr_fQualityBest<0.0) {
// quit searching
tr_iError = 1;
return;
}
if (tr_bIntersectedBest) {
// quit searching
tr_iError = 3;
return;
}
// if best triangle has positive quality
if (tr_fQualityBest>0.0) {
// add it to triangles
AddBestTriangleToTriangles();
}
// remove best triangle from edges
RemoveBestTriangleFromPolygon();
#ifndef NDEBUG
// check that there are no invalid edges after creating
CheckForInvalidEdges();
#endif
iPasses++;
}
tr_iError = 0;
//*/
}
/*
* Make triangular representation of the polygon.
*/
void CBrushPolygon::Triangulate(void)
{
// if already triangulated
if (bpo_apbvxTriangleVertices.Count()>0) {
// do nothing
return;
}
// triangularize the polygon
CTriangularizer tr(*this);
// find vertices used without duplication
tr.FindVerticesUsed();
// build array of element indices
tr.MakeElements();
// if there was an error
if (tr.tr_iError!=0) {
// report it
// CPrintF( TRANS("Cannot properly triangulate a polygon: error %d!\n"), tr.tr_iError);
// mark the polygon
bpo_ulFlags|=BPOF_INVALIDTRIANGLES;
// if there no errors
} else {
// mark the polygon as triangulated well
bpo_ulFlags&=~BPOF_INVALIDTRIANGLES;
}
// copy dynamic array of triangles to the triangular representation of the polygon
INDEX ctVertices = tr.tr_apbvxVertices.Count();
bpo_apbvxTriangleVertices.Clear();
bpo_apbvxTriangleVertices.New(ctVertices);
for (INDEX iVertex=0; iVertex<ctVertices; iVertex++) {
bpo_apbvxTriangleVertices[iVertex] = tr.tr_apbvxVertices[iVertex];
}
bpo_aiTriangleElements = tr.tr_aiElements;
if (_bDebugOutputOpen) {
_strmDebugOutput.Close();
_bDebugOutputOpen = FALSE;
}
}