suzanne.soy/solvespace
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Get rid of if(!this).

Browse Source 
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 2016-03-25 20:16:58 +06:00 committed by whitequark
parent 11565e081d
commit 09f59ddbc0
8 changed files with 83 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

91
src/bsp.cpp
View File

@ -29,7 +29,7 @@ SBsp3 *SBsp3::FromMesh(SMesh *m) {
} }
for(i = 0; i < mc.l.n; i++) { 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(); mc.Clear();
@ -86,12 +86,12 @@ void SBsp3::InsertHow(int how, STriangle *tr, SMesh *instead) {
switch(how) { switch(how) {
case POS: case POS:
if(instead && !pos) goto alt; if(instead && !pos) goto alt;
pos = pos->Insert(tr, instead); pos = InsertOrCreate(pos, tr, instead);
break; break;
case NEG: case NEG:
if(instead && !neg) goto alt; if(instead && !neg) goto alt;
neg = neg->Insert(tr, instead); neg = InsertOrCreate(neg, tr, instead);
break; break;
case COPLANAR: { case COPLANAR: {
@ -192,7 +192,7 @@ SBsp3 *SBsp3::InsertConvex(STriMeta meta, Vector *vertex, int cnt,
if(onc == 2) { if(onc == 2) {
if(!instead) { if(!instead) {
SEdge se = SEdge::From(on[0], on[1]); 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(!instead) {
if(inters == 2) { if(inters == 2) {
SEdge se = SEdge::From(inter[0], inter[1]); 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) { } else if(inters == 1 && onc == 1) {
SEdge se = SEdge::From(inter[0], on[0]); 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) { } else if(inters == 0 && onc == 2) {
// We already handled this on-plane existing edge // We already handled this on-plane existing edge
} else { } else {
@ -261,13 +261,13 @@ triangulate:
for(i = 0; i < cnt - 2; i++) { for(i = 0; i < cnt - 2; i++) {
STriangle tr = STriangle::From(meta, STriangle tr = STriangle::From(meta,
vertex[0], vertex[i+1], vertex[i+2]); vertex[0], vertex[i+1], vertex[i+2]);
r = r->Insert(&tr, instead); r = InsertOrCreate(r, &tr, instead);
} }
return r; return r;
} }
SBsp3 *SBsp3::Insert(STriangle *tr, SMesh *instead) { SBsp3 *SBsp3::InsertOrCreate(SBsp3 *where, STriangle *tr, SMesh *instead) {
if(!this) { if(where == NULL) {
if(instead) { if(instead) {
if(instead->flipNormal) { if(instead->flipNormal) {
instead->atLeastOneDiscarded = true; instead->atLeastOneDiscarded = true;
@ -284,7 +284,11 @@ SBsp3 *SBsp3::Insert(STriangle *tr, SMesh *instead) {
r->tri = *tr; r->tri = *tr;
return r; 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) }; double dt[3] = { (tr->a).Dot(n), (tr->b).Dot(n), (tr->c).Dot(n) };
int inc = 0, posc = 0, negc = 0; int inc = 0, posc = 0, negc = 0;
@ -306,7 +310,7 @@ SBsp3 *SBsp3::Insert(STriangle *tr, SMesh *instead) {
// All vertices in-plane // All vertices in-plane
if(inc == 3) { if(inc == 3) {
InsertHow(COPLANAR, tr, instead); InsertHow(COPLANAR, tr, instead);
return this; return;
} }
// No split required // No split required
@ -319,7 +323,7 @@ SBsp3 *SBsp3::Insert(STriangle *tr, SMesh *instead) {
else oops(); else oops();
if(!instead) { if(!instead) {
SEdge se = SEdge::From(a, b); 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 { } else {
InsertHow(NEG, tr, instead); InsertHow(NEG, tr, instead);
} }
return this; return;
} }
// The polygon must be split into two pieces, one above, one below. // 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) { if(!instead) {
SEdge se = SEdge::From(a, bPc); 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) { if(posc == 2 && negc == 1) {
@ -391,21 +395,20 @@ SBsp3 *SBsp3::Insert(STriangle *tr, SMesh *instead) {
} }
if(!instead) { if(!instead) {
SEdge se = SEdge::From(aPb, cPa); 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) { void SBsp3::GenerateInPaintOrder(SMesh *m) {
if(!this) return;
// Doesn't matter which branch we take if the normal has zero z // Doesn't matter which branch we take if the normal has zero z
// component, so don't need a separate case for that. // component, so don't need a separate case for that.
if(n.z < 0) { if(n.z < 0) {
pos->GenerateInPaintOrder(m); if(pos) pos->GenerateInPaintOrder(m);
} else { } else {
neg->GenerateInPaintOrder(m); if(neg) neg->GenerateInPaintOrder(m);
} }
SBsp3 *flip = this; SBsp3 *flip = this;
@ -415,16 +418,15 @@ void SBsp3::GenerateInPaintOrder(SMesh *m) {
} }
if(n.z < 0) { if(n.z < 0) {
neg->GenerateInPaintOrder(m); if(neg) neg->GenerateInPaintOrder(m);
} else { } else {
pos->GenerateInPaintOrder(m); if(pos) pos->GenerateInPaintOrder(m);
} }
} }
void SBsp3::DebugDraw(void) { void SBsp3::DebugDraw(void) {
if(!this) return;
pos->DebugDraw(); if(pos) pos->DebugDraw();
Vector norm = tri.Normal(); Vector norm = tri.Normal();
glNormal3d(norm.x, norm.y, norm.z); glNormal3d(norm.x, norm.y, norm.z);
@ -458,10 +460,10 @@ void SBsp3::DebugDraw(void) {
ssglDepthRangeOffset(0); ssglDepthRangeOffset(0);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
more->DebugDraw(); if(more) more->DebugDraw();
neg->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)); return (a.ScaledBy(db/dab)).Plus(b.ScaledBy(-da/dab));
} }
SBsp2 *SBsp2::InsertEdge(SEdge *nedge, Vector nnp, Vector out) { SBsp2 *SBsp2::InsertOrCreateEdge(SBsp2 *where, SEdge *nedge, Vector nnp, Vector out) {
if(!this) { if(where == NULL) {
// Brand new node; so allocate for it, and fill us in. // Brand new node; so allocate for it, and fill us in.
SBsp2 *r = Alloc(); SBsp2 *r = Alloc();
r->np = nnp; r->np = nnp;
@ -488,6 +490,11 @@ SBsp2 *SBsp2::InsertEdge(SEdge *nedge, Vector nnp, Vector out) {
r->edge = *nedge; r->edge = *nedge;
return r; 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) }; 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])) { if((isPos[0] && isPos[1])||(isPos[0] && isOn[1])||(isOn[0] && isPos[1])) {
pos = pos->InsertEdge(nedge, nnp, out); pos = InsertOrCreateEdge(pos, nedge, nnp, out);
return this; return;
} }
if((isNeg[0] && isNeg[1])||(isNeg[0] && isOn[1])||(isOn[0] && isNeg[1])) { if((isNeg[0] && isNeg[1])||(isNeg[0] && isOn[1])||(isOn[0] && isNeg[1])) {
neg = neg->InsertEdge(nedge, nnp, out); neg = InsertOrCreateEdge(neg, nedge, nnp, out);
return this; return;
} }
if(isOn[0] && isOn[1]) { if(isOn[0] && isOn[1]) {
SBsp2 *m = Alloc(); SBsp2 *m = Alloc();
@ -523,7 +530,7 @@ SBsp2 *SBsp2::InsertEdge(SEdge *nedge, Vector nnp, Vector out) {
m->more = more; m->more = more;
more = m; more = m;
return this; return;
} }
if((isPos[0] && isNeg[1]) || (isNeg[0] && isPos[1])) { if((isPos[0] && isNeg[1]) || (isNeg[0] && isPos[1])) {
Vector aPb = IntersectionWith(nedge->a, nedge->b); 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); SEdge eb = SEdge::From(aPb, nedge->b);
if(isPos[0]) { if(isPos[0]) {
pos = pos->InsertEdge(&ea, nnp, out); pos = InsertOrCreateEdge(pos, &ea, nnp, out);
neg = neg->InsertEdge(&eb, nnp, out); neg = InsertOrCreateEdge(neg, &eb, nnp, out);
} else { } else {
neg = neg->InsertEdge(&ea, nnp, out); neg = InsertOrCreateEdge(neg, &ea, nnp, out);
pos = pos->InsertEdge(&eb, nnp, out); pos = InsertOrCreateEdge(pos, &eb, nnp, out);
} }
return this; return;
} }
oops(); oops();
} }
@ -659,8 +666,6 @@ void SBsp2::InsertTriangle(STriangle *tr, SMesh *m, SBsp3 *bsp3) {
} }
void SBsp2::DebugDraw(Vector n, double d) { void SBsp2::DebugDraw(Vector n, double d) {
if(!this) return;
if(fabs((edge.a).Dot(n) - d) > LENGTH_EPS) oops(); if(fabs((edge.a).Dot(n) - d) > LENGTH_EPS) oops();
if(fabs((edge.b).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.a);
ssglVertex3v(edge.b); ssglVertex3v(edge.b);
glEnd(); glEnd();
pos->DebugDraw(n, d); if(pos) pos->DebugDraw(n, d);
neg->DebugDraw(n, d); if(neg) neg->DebugDraw(n, d);
more->DebugDraw(n, d); if(more) more->DebugDraw(n, d);
ssglLineWidth(1); ssglLineWidth(1);
} }

2
src/export.cpp
View File

@ -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. // Use the BSP routines to generate the split triangles in paint order.
SBsp3 *bsp = SBsp3::FromMesh(&smp); SBsp3 *bsp = SBsp3::FromMesh(&smp);
SMesh sms = {}; SMesh sms = {};
bsp->GenerateInPaintOrder(&sms); if(bsp) bsp->GenerateInPaintOrder(&sms);
// And cull the back-facing triangles // And cull the back-facing triangles
STriangle *tr; STriangle *tr;
sms.l.ClearTags(); sms.l.ClearTags();

1
src/expr.cpp
View File

@ -547,7 +547,6 @@ hParam Expr::ReferencedParams(ParamList *pl) {
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
std::string Expr::Print(void) { std::string Expr::Print(void) {
if(!this) return "0";
char c; char c;
switch(op) { switch(op) {

2
src/mesh.cpp
View File

@ -247,7 +247,7 @@ void SMesh::AddAgainstBsp(SMesh *srcm, SBsp3 *bsp3) {
STriangle *st = &(srcm->l.elem[i]); STriangle *st = &(srcm->l.elem[i]);
int pn = l.n; int pn = l.n;
atLeastOneDiscarded = false; atLeastOneDiscarded = false;
bsp3->Insert(st, this); SBsp3::InsertOrCreate(NULL, st, this);
if(!atLeastOneDiscarded && (l.n != (pn+1))) { if(!atLeastOneDiscarded && (l.n != (pn+1))) {
l.n = pn; l.n = pn;
if(flipNormal) { if(flipNormal) {

6
src/polygon.h
View File

@ -180,7 +180,8 @@ public:
void InsertTriangleHow(int how, STriangle *tr, SMesh *m, SBsp3 *bsp3); void InsertTriangleHow(int how, STriangle *tr, SMesh *m, SBsp3 *bsp3);
void InsertTriangle(STriangle *tr, SMesh *m, SBsp3 *bsp3); void InsertTriangle(STriangle *tr, SMesh *m, SBsp3 *bsp3);
Vector IntersectionWith(Vector a, Vector b); 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); static SBsp2 *Alloc(void);
void DebugDraw(Vector n, double d); void DebugDraw(Vector n, double d);
@ -206,7 +207,8 @@ public:
enum { POS = 100, NEG = 101, COPLANAR = 200 }; enum { POS = 100, NEG = 101, COPLANAR = 200 };
void InsertHow(int how, STriangle *str, SMesh *instead); 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, void InsertConvexHow(int how, STriMeta meta, Vector *vertex, int n,
SMesh *instead); SMesh *instead);

48
src/srf/boolean.cpp
View File

@ -83,10 +83,10 @@ SCurve SCurve::MakeCopySplitAgainst(SShell *agnstA, SShell *agnstB,
// some slop if points are close to edge and pwl is too coarse, // some slop if points are close to edge and pwl is too coarse,
// and it doesn't hurt to split unnecessarily. // and it doesn't hurt to split unnecessarily.
Point2d dummy = { 0, 0 }; 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) { if(c == SBspUv::OUTSIDE) {
double d; double d = VERY_POSITIVE;
d = pi->srf->bsp->MinimumDistanceToEdge(puv, pi->srf); if(pi->srf->bsp) d = pi->srf->bsp->MinimumDistanceToEdge(puv, pi->srf);
if(d > SS.ChordTolMm()) { if(d > SS.ChordTolMm()) {
pi->tag = 1; pi->tag = 1;
continue; continue;
@ -467,7 +467,7 @@ SSurface SSurface::MakeCopyTrimAgainst(SShell *parent,
ss->ClosestPointTo(a, &(auv.x), &(auv.y)); ss->ClosestPointTo(a, &(auv.x), &(auv.y));
ss->ClosestPointTo(b, &(buv.x), &(buv.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) { if(c != SBspUv::OUTSIDE) {
Vector ta = Vector::From(0, 0, 0); Vector ta = Vector::From(0, 0, 0);
Vector tb = 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 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); TagByClassifiedEdge(c_this, &indir_orig, &outdir_orig);
agnst->ClassifyEdge(&indir_shell, &outdir_shell, agnst->ClassifyEdge(&indir_shell, &outdir_shell,
@ -807,7 +807,7 @@ SBspUv *SBspUv::From(SEdgeList *el, SSurface *srf) {
SBspUv *bsp = NULL; SBspUv *bsp = NULL;
for(se = work.l.First(); se; se = work.l.NextAfter(se)) { 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(); work.Clear();
@ -850,14 +850,18 @@ double SBspUv::ScaledDistanceToLine(Point2d pt, Point2d a, Point2d b, bool seg,
return pt.DistanceToLine(a, b, seg); return pt.DistanceToLine(a, b, seg);
} }
SBspUv *SBspUv::InsertEdge(Point2d ea, Point2d eb, SSurface *srf) { SBspUv *SBspUv::InsertOrCreateEdge(SBspUv *where, const Point2d &ea, const Point2d &eb, SSurface *srf) {
if(!this) { if(where == NULL) {
SBspUv *ret = Alloc(); SBspUv *ret = Alloc();
ret->a = ea; ret->a = ea;
ret->b = eb; ret->b = eb;
return ret; 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), double dea = ScaledSignedDistanceToLine(ea, a, b, srf),
deb = ScaledSignedDistanceToLine(eb, 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) { } else if(fabs(dea) < LENGTH_EPS) {
// Point A lies on this lie, but point B does not // Point A lies on this lie, but point B does not
if(deb > 0) { if(deb > 0) {
pos = pos->InsertEdge(ea, eb, srf); pos = InsertOrCreateEdge(pos, ea, eb, srf);
} else { } else {
neg = neg->InsertEdge(ea, eb, srf); neg = InsertOrCreateEdge(neg, ea, eb, srf);
} }
} else if(fabs(deb) < LENGTH_EPS) { } else if(fabs(deb) < LENGTH_EPS) {
// Point B lies on this lie, but point A does not // Point B lies on this lie, but point A does not
if(dea > 0) { if(dea > 0) {
pos = pos->InsertEdge(ea, eb, srf); pos = InsertOrCreateEdge(pos, ea, eb, srf);
} else { } else {
neg = neg->InsertEdge(ea, eb, srf); neg = InsertOrCreateEdge(neg, ea, eb, srf);
} }
} else if(dea > 0 && deb > 0) { } else if(dea > 0 && deb > 0) {
pos = pos->InsertEdge(ea, eb, srf); pos = InsertOrCreateEdge(pos, ea, eb, srf);
} else if(dea < 0 && deb < 0) { } else if(dea < 0 && deb < 0) {
neg = neg->InsertEdge(ea, eb, srf); neg = InsertOrCreateEdge(neg, ea, eb, srf);
} else { } else {
// New edge crosses this one; we need to split. // New edge crosses this one; we need to split.
Point2d n = ((b.Minus(a)).Normal()).WithMagnitude(1); 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))); double t = (d - n.Dot(ea)) / (n.Dot(eb.Minus(ea)));
Point2d pi = ea.Plus((eb.Minus(ea)).ScaledBy(t)); Point2d pi = ea.Plus((eb.Minus(ea)).ScaledBy(t));
if(dea > 0) { if(dea > 0) {
pos = pos->InsertEdge(ea, pi, srf); pos = InsertOrCreateEdge(pos, ea, pi, srf);
neg = neg->InsertEdge(pi, eb, srf); neg = InsertOrCreateEdge(neg, pi, eb, srf);
} else { } else {
neg = neg->InsertEdge(ea, pi, srf); neg = InsertOrCreateEdge(neg, ea, pi, srf);
pos = pos->InsertEdge(pi, eb, srf); pos = InsertOrCreateEdge(pos, pi, eb, srf);
} }
} }
return this; return;
} }
int SBspUv::ClassifyPoint(Point2d p, Point2d eb, SSurface *srf) { int SBspUv::ClassifyPoint(Point2d p, Point2d eb, SSurface *srf) {
if(!this) return OUTSIDE;
double dp = ScaledSignedDistanceToLine(p, a, b, srf); 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) { double SBspUv::MinimumDistanceToEdge(Point2d p, SSurface *srf) {
if(!this) return VERY_POSITIVE;
double dn = neg->MinimumDistanceToEdge(p, srf), double dn = (neg) ? neg->MinimumDistanceToEdge(p, srf) : VERY_POSITIVE;
dp = pos->MinimumDistanceToEdge(p, srf); double dp = (pos) ? pos->MinimumDistanceToEdge(p, srf) : VERY_POSITIVE;
Point2d as = a, bs = b; Point2d as = a, bs = b;
ScalePoints(&p, &as, &bs, srf); ScalePoints(&p, &as, &bs, srf);

4
src/srf/raycast.cpp
View File

@ -361,7 +361,7 @@ void SSurface::AllPointsIntersecting(Vector a, Vector b,
// And that it lies inside our trim region // And that it lies inside our trim region
Point2d dummy = { 0, 0 }; 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) { if(trimmed && c == SBspUv::OUTSIDE) {
continue; continue;
} }
@ -527,7 +527,7 @@ bool SShell::ClassifyEdge(int *indir, int *outdir,
if((pp.Minus(p)).Magnitude() > LENGTH_EPS) continue; if((pp.Minus(p)).Magnitude() > LENGTH_EPS) continue;
Point2d dummy = { 0, 0 }; 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; if(c == SBspUv::OUTSIDE) continue;
// Edge-on-face (unless edge-on-edge above superceded) // Edge-on-face (unless edge-on-edge above superceded)

3
src/srf/surface.h
View File

@ -45,7 +45,8 @@ public:
double ScaledDistanceToLine(Point2d pt, Point2d a, Point2d b, bool seg, double ScaledDistanceToLine(Point2d pt, Point2d a, Point2d b, bool seg,
SSurface *srf); 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 ClassifyPoint(Point2d p, Point2d eb, SSurface *srf);
int ClassifyEdge(Point2d ea, Point2d eb, SSurface *srf); int ClassifyEdge(Point2d ea, Point2d eb, SSurface *srf);
double MinimumDistanceToEdge(Point2d p, SSurface *srf); double MinimumDistanceToEdge(Point2d p, SSurface *srf);