zcy
/
solvespace
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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.
pull/4/head
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);