Get rid of if(!this).
According to the C++ standard, "this" is never NULL, so checks of the form "if(!this)" can be legally optimized out. This breaks SolveSpace on GCC 6, and probably on other compilers and configurations.
This commit is contained in:
EvilSpirit
whitequark
parent
11565e081d
commit
09f59ddbc0
91
src/bsp.cpp
91
src/bsp.cpp
|
|
@ -29,7 +29,7 @@ SBsp3 *SBsp3::FromMesh(SMesh *m) {
|
|||
}
|
||||
|
||||
for(i = 0; i < mc.l.n; i++) {
|
||||
bsp3 = bsp3->Insert(&(mc.l.elem[i]), NULL);
|
||||
bsp3 = InsertOrCreate(bsp3, &(mc.l.elem[i]), NULL);
|
||||
}
|
||||
|
||||
mc.Clear();
|
||||
|
|
@ -86,12 +86,12 @@ void SBsp3::InsertHow(int how, STriangle *tr, SMesh *instead) {
|
|||
switch(how) {
|
||||
case POS:
|
||||
if(instead && !pos) goto alt;
|
||||
pos = pos->Insert(tr, instead);
|
||||
pos = InsertOrCreate(pos, tr, instead);
|
||||
break;
|
||||
|
||||
case NEG:
|
||||
if(instead && !neg) goto alt;
|
||||
neg = neg->Insert(tr, instead);
|
||||
neg = InsertOrCreate(neg, tr, instead);
|
||||
break;
|
||||
|
||||
case COPLANAR: {
|
||||
|
|
@ -192,7 +192,7 @@ SBsp3 *SBsp3::InsertConvex(STriMeta meta, Vector *vertex, int cnt,
|
|||
if(onc == 2) {
|
||||
if(!instead) {
|
||||
SEdge se = SEdge::From(on[0], on[1]);
|
||||
edges = edges->InsertEdge(&se, n, out);
|
||||
edges = SBsp2::InsertOrCreateEdge(edges, &se, n, out);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -239,10 +239,10 @@ SBsp3 *SBsp3::InsertConvex(STriMeta meta, Vector *vertex, int cnt,
|
|||
if(!instead) {
|
||||
if(inters == 2) {
|
||||
SEdge se = SEdge::From(inter[0], inter[1]);
|
||||
edges = edges->InsertEdge(&se, n, out);
|
||||
edges = SBsp2::InsertOrCreateEdge(edges, &se, n, out);
|
||||
} else if(inters == 1 && onc == 1) {
|
||||
SEdge se = SEdge::From(inter[0], on[0]);
|
||||
edges = edges->InsertEdge(&se, n, out);
|
||||
edges = SBsp2::InsertOrCreateEdge(edges, &se, n, out);
|
||||
} else if(inters == 0 && onc == 2) {
|
||||
// We already handled this on-plane existing edge
|
||||
} else {
|
||||
|
|
@ -261,13 +261,13 @@ triangulate:
|
|||
for(i = 0; i < cnt - 2; i++) {
|
||||
STriangle tr = STriangle::From(meta,
|
||||
vertex[0], vertex[i+1], vertex[i+2]);
|
||||
r = r->Insert(&tr, instead);
|
||||
r = InsertOrCreate(r, &tr, instead);
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
SBsp3 *SBsp3::Insert(STriangle *tr, SMesh *instead) {
|
||||
if(!this) {
|
||||
SBsp3 *SBsp3::InsertOrCreate(SBsp3 *where, STriangle *tr, SMesh *instead) {
|
||||
if(where == NULL) {
|
||||
if(instead) {
|
||||
if(instead->flipNormal) {
|
||||
instead->atLeastOneDiscarded = true;
|
||||
|
|
@ -284,7 +284,11 @@ SBsp3 *SBsp3::Insert(STriangle *tr, SMesh *instead) {
|
|||
r->tri = *tr;
|
||||
return r;
|
||||
}
|
||||
where->Insert(tr, instead);
|
||||
return where;
|
||||
}
|
||||
|
||||
void SBsp3::Insert(STriangle *tr, SMesh *instead) {
|
||||
double dt[3] = { (tr->a).Dot(n), (tr->b).Dot(n), (tr->c).Dot(n) };
|
||||
|
||||
int inc = 0, posc = 0, negc = 0;
|
||||
|
|
@ -306,7 +310,7 @@ SBsp3 *SBsp3::Insert(STriangle *tr, SMesh *instead) {
|
|||
// All vertices in-plane
|
||||
if(inc == 3) {
|
||||
InsertHow(COPLANAR, tr, instead);
|
||||
return this;
|
||||
return;
|
||||
}
|
||||
|
||||
// No split required
|
||||
|
|
@ -319,7 +323,7 @@ SBsp3 *SBsp3::Insert(STriangle *tr, SMesh *instead) {
|
|||
else oops();
|
||||
if(!instead) {
|
||||
SEdge se = SEdge::From(a, b);
|
||||
edges = edges->InsertEdge(&se, n, tr->Normal());
|
||||
edges = SBsp2::InsertOrCreateEdge(edges, &se, n, tr->Normal());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -328,7 +332,7 @@ SBsp3 *SBsp3::Insert(STriangle *tr, SMesh *instead) {
|
|||
} else {
|
||||
InsertHow(NEG, tr, instead);
|
||||
}
|
||||
return this;
|
||||
return;
|
||||
}
|
||||
|
||||
// The polygon must be split into two pieces, one above, one below.
|
||||
|
|
@ -356,10 +360,10 @@ SBsp3 *SBsp3::Insert(STriangle *tr, SMesh *instead) {
|
|||
|
||||
if(!instead) {
|
||||
SEdge se = SEdge::From(a, bPc);
|
||||
edges = edges->InsertEdge(&se, n, tr->Normal());
|
||||
edges = SBsp2::InsertOrCreateEdge(edges, &se, n, tr->Normal());
|
||||
}
|
||||
|
||||
return this;
|
||||
return;
|
||||
}
|
||||
|
||||
if(posc == 2 && negc == 1) {
|
||||
|
|
@ -391,21 +395,20 @@ SBsp3 *SBsp3::Insert(STriangle *tr, SMesh *instead) {
|
|||
}
|
||||
if(!instead) {
|
||||
SEdge se = SEdge::From(aPb, cPa);
|
||||
edges = edges->InsertEdge(&se, n, alone.Normal());
|
||||
edges = SBsp2::InsertOrCreateEdge(edges, &se, n, alone.Normal());
|
||||
}
|
||||
|
||||
return this;
|
||||
return;
|
||||
}
|
||||
|
||||
void SBsp3::GenerateInPaintOrder(SMesh *m) {
|
||||
if(!this) return;
|
||||
|
||||
// Doesn't matter which branch we take if the normal has zero z
|
||||
// component, so don't need a separate case for that.
|
||||
if(n.z < 0) {
|
||||
pos->GenerateInPaintOrder(m);
|
||||
if(pos) pos->GenerateInPaintOrder(m);
|
||||
} else {
|
||||
neg->GenerateInPaintOrder(m);
|
||||
if(neg) neg->GenerateInPaintOrder(m);
|
||||
}
|
||||
|
||||
SBsp3 *flip = this;
|
||||
|
|
@ -415,16 +418,15 @@ void SBsp3::GenerateInPaintOrder(SMesh *m) {
|
|||
}
|
||||
|
||||
if(n.z < 0) {
|
||||
neg->GenerateInPaintOrder(m);
|
||||
if(neg) neg->GenerateInPaintOrder(m);
|
||||
} else {
|
||||
pos->GenerateInPaintOrder(m);
|
||||
if(pos) pos->GenerateInPaintOrder(m);
|
||||
}
|
||||
}
|
||||
|
||||
void SBsp3::DebugDraw(void) {
|
||||
if(!this) return;
|
||||
|
||||
pos->DebugDraw();
|
||||
if(pos) pos->DebugDraw();
|
||||
Vector norm = tri.Normal();
|
||||
glNormal3d(norm.x, norm.y, norm.z);
|
||||
|
||||
|
|
@ -458,10 +460,10 @@ void SBsp3::DebugDraw(void) {
|
|||
ssglDepthRangeOffset(0);
|
||||
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
|
||||
|
||||
more->DebugDraw();
|
||||
neg->DebugDraw();
|
||||
if(more) more->DebugDraw();
|
||||
if(neg) neg->DebugDraw();
|
||||
|
||||
edges->DebugDraw(n, d);
|
||||
if(edges) edges->DebugDraw(n, d);
|
||||
}
|
||||
|
||||
/////////////////////////////////
|
||||
|
|
@ -475,8 +477,8 @@ Vector SBsp2::IntersectionWith(Vector a, Vector b) {
|
|||
return (a.ScaledBy(db/dab)).Plus(b.ScaledBy(-da/dab));
|
||||
}
|
||||
|
||||
SBsp2 *SBsp2::InsertEdge(SEdge *nedge, Vector nnp, Vector out) {
|
||||
if(!this) {
|
||||
SBsp2 *SBsp2::InsertOrCreateEdge(SBsp2 *where, SEdge *nedge, Vector nnp, Vector out) {
|
||||
if(where == NULL) {
|
||||
// Brand new node; so allocate for it, and fill us in.
|
||||
SBsp2 *r = Alloc();
|
||||
r->np = nnp;
|
||||
|
|
@ -488,6 +490,11 @@ SBsp2 *SBsp2::InsertEdge(SEdge *nedge, Vector nnp, Vector out) {
|
|||
r->edge = *nedge;
|
||||
return r;
|
||||
}
|
||||
where->InsertEdge(nedge, nnp, out);
|
||||
return where;
|
||||
}
|
||||
|
||||
void SBsp2::InsertEdge(SEdge *nedge, Vector nnp, Vector out) {
|
||||
|
||||
double dt[2] = { (nedge->a).Dot(no), (nedge->b).Dot(no) };
|
||||
|
||||
|
|
@ -503,12 +510,12 @@ SBsp2 *SBsp2::InsertEdge(SEdge *nedge, Vector nnp, Vector out) {
|
|||
}
|
||||
|
||||
if((isPos[0] && isPos[1])||(isPos[0] && isOn[1])||(isOn[0] && isPos[1])) {
|
||||
pos = pos->InsertEdge(nedge, nnp, out);
|
||||
return this;
|
||||
pos = InsertOrCreateEdge(pos, nedge, nnp, out);
|
||||
return;
|
||||
}
|
||||
if((isNeg[0] && isNeg[1])||(isNeg[0] && isOn[1])||(isOn[0] && isNeg[1])) {
|
||||
neg = neg->InsertEdge(nedge, nnp, out);
|
||||
return this;
|
||||
neg = InsertOrCreateEdge(neg, nedge, nnp, out);
|
||||
return;
|
||||
}
|
||||
if(isOn[0] && isOn[1]) {
|
||||
SBsp2 *m = Alloc();
|
||||
|
|
@ -523,7 +530,7 @@ SBsp2 *SBsp2::InsertEdge(SEdge *nedge, Vector nnp, Vector out) {
|
|||
|
||||
m->more = more;
|
||||
more = m;
|
||||
return this;
|
||||
return;
|
||||
}
|
||||
if((isPos[0] && isNeg[1]) || (isNeg[0] && isPos[1])) {
|
||||
Vector aPb = IntersectionWith(nedge->a, nedge->b);
|
||||
|
|
@ -532,13 +539,13 @@ SBsp2 *SBsp2::InsertEdge(SEdge *nedge, Vector nnp, Vector out) {
|
|||
SEdge eb = SEdge::From(aPb, nedge->b);
|
||||
|
||||
if(isPos[0]) {
|
||||
pos = pos->InsertEdge(&ea, nnp, out);
|
||||
neg = neg->InsertEdge(&eb, nnp, out);
|
||||
pos = InsertOrCreateEdge(pos, &ea, nnp, out);
|
||||
neg = InsertOrCreateEdge(neg, &eb, nnp, out);
|
||||
} else {
|
||||
neg = neg->InsertEdge(&ea, nnp, out);
|
||||
pos = pos->InsertEdge(&eb, nnp, out);
|
||||
neg = InsertOrCreateEdge(neg, &ea, nnp, out);
|
||||
pos = InsertOrCreateEdge(pos, &eb, nnp, out);
|
||||
}
|
||||
return this;
|
||||
return;
|
||||
}
|
||||
oops();
|
||||
}
|
||||
|
|
@ -659,8 +666,6 @@ void SBsp2::InsertTriangle(STriangle *tr, SMesh *m, SBsp3 *bsp3) {
|
|||
}
|
||||
|
||||
void SBsp2::DebugDraw(Vector n, double d) {
|
||||
if(!this) return;
|
||||
|
||||
if(fabs((edge.a).Dot(n) - d) > LENGTH_EPS) oops();
|
||||
if(fabs((edge.b).Dot(n) - d) > LENGTH_EPS) oops();
|
||||
|
||||
|
|
@ -669,9 +674,9 @@ void SBsp2::DebugDraw(Vector n, double d) {
|
|||
ssglVertex3v(edge.a);
|
||||
ssglVertex3v(edge.b);
|
||||
glEnd();
|
||||
pos->DebugDraw(n, d);
|
||||
neg->DebugDraw(n, d);
|
||||
more->DebugDraw(n, d);
|
||||
if(pos) pos->DebugDraw(n, d);
|
||||
if(neg) neg->DebugDraw(n, d);
|
||||
if(more) more->DebugDraw(n, d);
|
||||
ssglLineWidth(1);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -308,7 +308,7 @@ void SolveSpaceUI::ExportLinesAndMesh(SEdgeList *sel, SBezierList *sbl, SMesh *s
|
|||
// Use the BSP routines to generate the split triangles in paint order.
|
||||
SBsp3 *bsp = SBsp3::FromMesh(&smp);
|
||||
SMesh sms = {};
|
||||
bsp->GenerateInPaintOrder(&sms);
|
||||
if(bsp) bsp->GenerateInPaintOrder(&sms);
|
||||
// And cull the back-facing triangles
|
||||
STriangle *tr;
|
||||
sms.l.ClearTags();
|
||||
|
|
|
|||
|
|
@ -547,7 +547,6 @@ hParam Expr::ReferencedParams(ParamList *pl) {
|
|||
//-----------------------------------------------------------------------------
|
||||
|
||||
std::string Expr::Print(void) {
|
||||
if(!this) return "0";
|
||||
|
||||
char c;
|
||||
switch(op) {
|
||||
|
|
|
|||
|
|
@ -247,7 +247,7 @@ void SMesh::AddAgainstBsp(SMesh *srcm, SBsp3 *bsp3) {
|
|||
STriangle *st = &(srcm->l.elem[i]);
|
||||
int pn = l.n;
|
||||
atLeastOneDiscarded = false;
|
||||
bsp3->Insert(st, this);
|
||||
SBsp3::InsertOrCreate(NULL, st, this);
|
||||
if(!atLeastOneDiscarded && (l.n != (pn+1))) {
|
||||
l.n = pn;
|
||||
if(flipNormal) {
|
||||
|
|
|
|||
|
|
@ -180,7 +180,8 @@ public:
|
|||
void InsertTriangleHow(int how, STriangle *tr, SMesh *m, SBsp3 *bsp3);
|
||||
void InsertTriangle(STriangle *tr, SMesh *m, SBsp3 *bsp3);
|
||||
Vector IntersectionWith(Vector a, Vector b);
|
||||
SBsp2 *InsertEdge(SEdge *nedge, Vector nnp, Vector out);
|
||||
void InsertEdge(SEdge *nedge, Vector nnp, Vector out);
|
||||
static SBsp2 *InsertOrCreateEdge(SBsp2 *where, SEdge *nedge, Vector nnp, Vector out);
|
||||
static SBsp2 *Alloc(void);
|
||||
|
||||
void DebugDraw(Vector n, double d);
|
||||
|
|
@ -206,7 +207,8 @@ public:
|
|||
|
||||
enum { POS = 100, NEG = 101, COPLANAR = 200 };
|
||||
void InsertHow(int how, STriangle *str, SMesh *instead);
|
||||
SBsp3 *Insert(STriangle *str, SMesh *instead);
|
||||
void Insert(STriangle *str, SMesh *instead);
|
||||
static SBsp3 *InsertOrCreate(SBsp3 *where, STriangle *str, SMesh *instead);
|
||||
|
||||
void InsertConvexHow(int how, STriMeta meta, Vector *vertex, int n,
|
||||
SMesh *instead);
|
||||
|
|
|
|||
|
|
@ -83,10 +83,10 @@ SCurve SCurve::MakeCopySplitAgainst(SShell *agnstA, SShell *agnstB,
|
|||
// some slop if points are close to edge and pwl is too coarse,
|
||||
// and it doesn't hurt to split unnecessarily.
|
||||
Point2d dummy = { 0, 0 };
|
||||
int c = pi->srf->bsp->ClassifyPoint(puv, dummy, pi->srf);
|
||||
int c = (pi->srf->bsp) ? pi->srf->bsp->ClassifyPoint(puv, dummy, pi->srf) : SBspUv::OUTSIDE;
|
||||
if(c == SBspUv::OUTSIDE) {
|
||||
double d;
|
||||
d = pi->srf->bsp->MinimumDistanceToEdge(puv, pi->srf);
|
||||
double d = VERY_POSITIVE;
|
||||
if(pi->srf->bsp) d = pi->srf->bsp->MinimumDistanceToEdge(puv, pi->srf);
|
||||
if(d > SS.ChordTolMm()) {
|
||||
pi->tag = 1;
|
||||
continue;
|
||||
|
|
@ -467,7 +467,7 @@ SSurface SSurface::MakeCopyTrimAgainst(SShell *parent,
|
|||
ss->ClosestPointTo(a, &(auv.x), &(auv.y));
|
||||
ss->ClosestPointTo(b, &(buv.x), &(buv.y));
|
||||
|
||||
int c = ss->bsp->ClassifyEdge(auv, buv, ss);
|
||||
int c = (ss->bsp) ? ss->bsp->ClassifyEdge(auv, buv, ss) : SBspUv::OUTSIDE;
|
||||
if(c != SBspUv::OUTSIDE) {
|
||||
Vector ta = Vector::From(0, 0, 0);
|
||||
Vector tb = Vector::From(0, 0, 0);
|
||||
|
|
@ -571,7 +571,7 @@ SSurface SSurface::MakeCopyTrimAgainst(SShell *parent,
|
|||
|
||||
int indir_shell, outdir_shell, indir_orig, outdir_orig;
|
||||
|
||||
int c_this = origBsp->ClassifyEdge(auv, buv, &ret);
|
||||
int c_this = (origBsp) ? origBsp->ClassifyEdge(auv, buv, &ret) : SBspUv::OUTSIDE;
|
||||
TagByClassifiedEdge(c_this, &indir_orig, &outdir_orig);
|
||||
|
||||
agnst->ClassifyEdge(&indir_shell, &outdir_shell,
|
||||
|
|
@ -807,7 +807,7 @@ SBspUv *SBspUv::From(SEdgeList *el, SSurface *srf) {
|
|||
|
||||
SBspUv *bsp = NULL;
|
||||
for(se = work.l.First(); se; se = work.l.NextAfter(se)) {
|
||||
bsp = bsp->InsertEdge((se->a).ProjectXy(), (se->b).ProjectXy(), srf);
|
||||
bsp = InsertOrCreateEdge(bsp, (se->a).ProjectXy(), (se->b).ProjectXy(), srf);
|
||||
}
|
||||
|
||||
work.Clear();
|
||||
|
|
@ -850,14 +850,18 @@ double SBspUv::ScaledDistanceToLine(Point2d pt, Point2d a, Point2d b, bool seg,
|
|||
return pt.DistanceToLine(a, b, seg);
|
||||
}
|
||||
|
||||
SBspUv *SBspUv::InsertEdge(Point2d ea, Point2d eb, SSurface *srf) {
|
||||
if(!this) {
|
||||
SBspUv *SBspUv::InsertOrCreateEdge(SBspUv *where, const Point2d &ea, const Point2d &eb, SSurface *srf) {
|
||||
if(where == NULL) {
|
||||
SBspUv *ret = Alloc();
|
||||
ret->a = ea;
|
||||
ret->b = eb;
|
||||
return ret;
|
||||
}
|
||||
where->InsertEdge(ea, eb, srf);
|
||||
return where;
|
||||
}
|
||||
|
||||
void SBspUv::InsertEdge(Point2d ea, Point2d eb, SSurface *srf) {
|
||||
double dea = ScaledSignedDistanceToLine(ea, a, b, srf),
|
||||
deb = ScaledSignedDistanceToLine(eb, a, b, srf);
|
||||
|
||||
|
|
@ -871,21 +875,21 @@ SBspUv *SBspUv::InsertEdge(Point2d ea, Point2d eb, SSurface *srf) {
|
|||
} else if(fabs(dea) < LENGTH_EPS) {
|
||||
// Point A lies on this lie, but point B does not
|
||||
if(deb > 0) {
|
||||
pos = pos->InsertEdge(ea, eb, srf);
|
||||
pos = InsertOrCreateEdge(pos, ea, eb, srf);
|
||||
} else {
|
||||
neg = neg->InsertEdge(ea, eb, srf);
|
||||
neg = InsertOrCreateEdge(neg, ea, eb, srf);
|
||||
}
|
||||
} else if(fabs(deb) < LENGTH_EPS) {
|
||||
// Point B lies on this lie, but point A does not
|
||||
if(dea > 0) {
|
||||
pos = pos->InsertEdge(ea, eb, srf);
|
||||
pos = InsertOrCreateEdge(pos, ea, eb, srf);
|
||||
} else {
|
||||
neg = neg->InsertEdge(ea, eb, srf);
|
||||
neg = InsertOrCreateEdge(neg, ea, eb, srf);
|
||||
}
|
||||
} else if(dea > 0 && deb > 0) {
|
||||
pos = pos->InsertEdge(ea, eb, srf);
|
||||
pos = InsertOrCreateEdge(pos, ea, eb, srf);
|
||||
} else if(dea < 0 && deb < 0) {
|
||||
neg = neg->InsertEdge(ea, eb, srf);
|
||||
neg = InsertOrCreateEdge(neg, ea, eb, srf);
|
||||
} else {
|
||||
// New edge crosses this one; we need to split.
|
||||
Point2d n = ((b.Minus(a)).Normal()).WithMagnitude(1);
|
||||
|
|
@ -893,18 +897,17 @@ SBspUv *SBspUv::InsertEdge(Point2d ea, Point2d eb, SSurface *srf) {
|
|||
double t = (d - n.Dot(ea)) / (n.Dot(eb.Minus(ea)));
|
||||
Point2d pi = ea.Plus((eb.Minus(ea)).ScaledBy(t));
|
||||
if(dea > 0) {
|
||||
pos = pos->InsertEdge(ea, pi, srf);
|
||||
neg = neg->InsertEdge(pi, eb, srf);
|
||||
pos = InsertOrCreateEdge(pos, ea, pi, srf);
|
||||
neg = InsertOrCreateEdge(neg, pi, eb, srf);
|
||||
} else {
|
||||
neg = neg->InsertEdge(ea, pi, srf);
|
||||
pos = pos->InsertEdge(pi, eb, srf);
|
||||
neg = InsertOrCreateEdge(neg, ea, pi, srf);
|
||||
pos = InsertOrCreateEdge(pos, pi, eb, srf);
|
||||
}
|
||||
}
|
||||
return this;
|
||||
return;
|
||||
}
|
||||
|
||||
int SBspUv::ClassifyPoint(Point2d p, Point2d eb, SSurface *srf) {
|
||||
if(!this) return OUTSIDE;
|
||||
|
||||
double dp = ScaledSignedDistanceToLine(p, a, b, srf);
|
||||
|
||||
|
|
@ -951,10 +954,9 @@ int SBspUv::ClassifyEdge(Point2d ea, Point2d eb, SSurface *srf) {
|
|||
}
|
||||
|
||||
double SBspUv::MinimumDistanceToEdge(Point2d p, SSurface *srf) {
|
||||
if(!this) return VERY_POSITIVE;
|
||||
|
||||
double dn = neg->MinimumDistanceToEdge(p, srf),
|
||||
dp = pos->MinimumDistanceToEdge(p, srf);
|
||||
double dn = (neg) ? neg->MinimumDistanceToEdge(p, srf) : VERY_POSITIVE;
|
||||
double dp = (pos) ? pos->MinimumDistanceToEdge(p, srf) : VERY_POSITIVE;
|
||||
|
||||
Point2d as = a, bs = b;
|
||||
ScalePoints(&p, &as, &bs, srf);
|
||||
|
|
|
|||
|
|
@ -361,7 +361,7 @@ void SSurface::AllPointsIntersecting(Vector a, Vector b,
|
|||
|
||||
// And that it lies inside our trim region
|
||||
Point2d dummy = { 0, 0 };
|
||||
int c = bsp->ClassifyPoint(puv, dummy, this);
|
||||
int c = (bsp) ? bsp->ClassifyPoint(puv, dummy, this) : SBspUv::OUTSIDE;
|
||||
if(trimmed && c == SBspUv::OUTSIDE) {
|
||||
continue;
|
||||
}
|
||||
|
|
@ -527,7 +527,7 @@ bool SShell::ClassifyEdge(int *indir, int *outdir,
|
|||
|
||||
if((pp.Minus(p)).Magnitude() > LENGTH_EPS) continue;
|
||||
Point2d dummy = { 0, 0 };
|
||||
int c = srf->bsp->ClassifyPoint(puv, dummy, srf);
|
||||
int c = (srf->bsp) ? srf->bsp->ClassifyPoint(puv, dummy, srf) : SBspUv::OUTSIDE;
|
||||
if(c == SBspUv::OUTSIDE) continue;
|
||||
|
||||
// Edge-on-face (unless edge-on-edge above superceded)
|
||||
|
|
|
|||
|
|
@ -45,7 +45,8 @@ public:
|
|||
double ScaledDistanceToLine(Point2d pt, Point2d a, Point2d b, bool seg,
|
||||
SSurface *srf);
|
||||
|
||||
SBspUv *InsertEdge(Point2d a, Point2d b, SSurface *srf);
|
||||
void InsertEdge(Point2d a, Point2d b, SSurface *srf);
|
||||
static SBspUv *InsertOrCreateEdge(SBspUv *where, const Point2d &ea, const Point2d &eb, SSurface *srf);
|
||||
int ClassifyPoint(Point2d p, Point2d eb, SSurface *srf);
|
||||
int ClassifyEdge(Point2d ea, Point2d eb, SSurface *srf);
|
||||
double MinimumDistanceToEdge(Point2d p, SSurface *srf);
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user