NFC: Ramove all {0, 0, 0} comments. Everyone knows zero initialization.

ruevs · ruevs · commit 97d958865d4f · 2026-03-31T15:20:24.000+03:00
diff --git a/src/clipboard.cpp b/src/clipboard.cpp
@@ -209,7 +209,7 @@ void GraphicsWindow::PasteClipboard(Vector trans, double theta, double scale) {
             // Likewise the scale, which could otherwise take us out of the
             // workplane.
             pt = pt.ScaledBy(fabs(scale));
-            pt = pt.ScaleOutOfCsys(u, v, {} /*{0, 0, 0}*/);
+            pt = pt.ScaleOutOfCsys(u, v, {});
             pt = pt.Plus(p);
             pt = pt.RotatedAbout(n, theta);
             pt = pt.Plus(trans);
@@ -338,7 +338,7 @@ void GraphicsWindow::MenuClipboard(Command id) {
             Entity *wrkpl  = SK.GetEntity(SS.GW.ActiveWorkplane());
             Vector p = SK.GetEntity(wrkpl->point[0])->PointGetNum();
             SS.TW.shown.paste.times  = 1;
-            SS.TW.shown.paste.trans  = {};    // {0, 0, 0}
+            SS.TW.shown.paste.trans  = {};
             SS.TW.shown.paste.theta  = 0;
             SS.TW.shown.paste.origin = p;
             SS.TW.shown.paste.scale  = 1;
diff --git a/src/constraint.cpp b/src/constraint.cpp
@@ -320,7 +320,7 @@ void Constraint::MenuConstrain(Command id) {
                 c.disp.offset = n.Cross(a.Minus(b));
                 c.disp.offset = (c.disp.offset).WithMagnitude(50/SS.GW.scale);
             } else {
-                c.disp.offset = {};    // {0, 0, 0}
+                c.disp.offset = {};
             }
 
             if(id == Command::REF_DISTANCE) {
diff --git a/src/drawconstraint.cpp b/src/drawconstraint.cpp
@@ -886,7 +886,7 @@ void Constraint::DoLayout(DrawAs how, Canvas *canvas,
         }
 
         case Type::PERPENDICULAR: {
-            Vector u{}, v{};    // {0, 0, 0}
+            Vector u{}, v{};
             Vector rn, ru;
             if(workplane == Entity::FREE_IN_3D) {
                 rn = gn;
diff --git a/src/drawentity.cpp b/src/drawentity.cpp
@@ -263,8 +263,8 @@ void Entity::ComputeInterpolatingSpline(SBezierList *sbl, bool periodic) const {
 
     // The starting and finishing control points that define our end tangents
     // (if the spline isn't periodic), and the on-curve points.
-    Vector ctrl_s{}; // {0, 0, 0}
-    Vector ctrl_f{}; // {0, 0, 0}
+    Vector ctrl_s{};
+    Vector ctrl_f{};
     Vector pt[MAX_N+4];
     if(periodic) {
         for(i = 0; i < ep + 3; i++) {
@@ -503,7 +503,7 @@ Vector Entity::ExplodeOffset() const {
         double offset = SS.explodeDistance * (requestIdx + 1);
         return SK.GetEntity(workplane)->Normal()->NormalN().ScaledBy(offset);
     } else {
-        return {}; // {0, 0, 0}
+        return {};
     }
 }
 
diff --git a/src/export.cpp b/src/export.cpp
@@ -249,7 +249,7 @@ void SolveSpaceUI::ExportViewOrWireframeTo(const Platform::Path &filename, bool
         Vector u{1.0, 0.0, 0.0},
                v{0.0, 1.0, 0.0},
                n{0.0, 0.0, 1.0},
-               origin{};    // {0, 0, 0}
+               origin{};
         double cameraTan = 0.0,
                scale = 1.0;
 
diff --git a/src/generate.cpp b/src/generate.cpp
@@ -421,7 +421,7 @@ void SolveSpaceUI::ForceReferences() {
         Entity *wrkpl = SK.GetEntity(hr.entity(0));
         // The origin for our coordinate system, always zero
         Entity *origin = SK.GetEntity(wrkpl->point[0]);
-        origin->PointForceTo({} /*{0, 0, 0}*/);
+        origin->PointForceTo({});
         origin->construction = true;
         SK.GetParam(origin->param[0])->known = true;
         SK.GetParam(origin->param[1])->known = true;
diff --git a/src/graphicswin.cpp b/src/graphicswin.cpp
@@ -1216,7 +1216,7 @@ void GraphicsWindow::MenuEdit(Command id) {
             norm = norm.WithMagnitude(1);
             Quaternion qaa = Quaternion::From(norm, PI/2);
 
-            g->TransformImportedBy({} /*{0, 0, 0}*/, qaa);
+            g->TransformImportedBy({}, qaa);
 
             // and regenerate as necessary.
             SS.MarkGroupDirty(hg);
diff --git a/src/group.cpp b/src/group.cpp
@@ -1002,7 +1002,7 @@ void Group::MakeRevolveEndFaces(EntityList *el, hEntity pt, int ai, int af)
 
     // When there is no loop normal (e.g. if the loop is broken), use normal of workplane
     // as fallback, to avoid breaking constraints depending on the faces.
-    if(n.Equals({} /*{0.0, 0.0, 0.0}*/) && src->type == Group::Type::DRAWING_WORKPLANE) {
+    if(n.Equals({}) && src->type == Group::Type::DRAWING_WORKPLANE) {
         n = SK.GetEntity(src->h.entity(0))->Normal()->NormalN();
     }
 
@@ -1039,7 +1039,7 @@ void Group::MakeExtrusionTopBottomFaces(EntityList *el, hEntity pt)
 
     // When there is no loop normal (e.g. if the loop is broken), use normal of workplane
     // as fallback, to avoid breaking constraints depending on the faces.
-    if(n.Equals({} /*{0.0, 0.0, 0.0}*/) && src->type == Group::Type::DRAWING_WORKPLANE) {
+    if(n.Equals({}) && src->type == Group::Type::DRAWING_WORKPLANE) {
         n = SK.GetEntity(src->h.entity(0))->Normal()->NormalN();
     }
 
diff --git a/src/groupmesh.cpp b/src/groupmesh.cpp
@@ -251,7 +251,7 @@ void Group::GenerateShellAndMesh() {
 
         Vector tbot, ttop;
         if(subtype == Subtype::ONE_SIDED || subtype == Subtype::ONE_SKEWED) {
-            tbot = {} /*{0, 0, 0}*/; ttop = translate.ScaledBy(2);
+            tbot = {}; ttop = translate.ScaledBy(2);
         } else {
             tbot = translate.ScaledBy(-1); ttop = translate.ScaledBy(1);
         }
@@ -779,7 +779,7 @@ void Group::DrawContourAreaLabels(Canvas *canvas) {
 
         Vector min = sbls.l[0].l[0].ctrl[0];
         Vector max = min;
-        Vector zero = {}; /*{0.0, 0.0, 0.0}*/
+        Vector zero = {};
         sbls.GetBoundingProjd({1.0, 0.0, 0.0}, zero, &min.x, &max.x);
         sbls.GetBoundingProjd({0.0, 1.0, 0.0}, zero, &min.y, &max.y);
         sbls.GetBoundingProjd({0.0, 0.0, 1.0}, zero, &min.z, &max.z);
diff --git a/src/importidf.cpp b/src/importidf.cpp
@@ -339,8 +339,8 @@ bool LinkIDF(const Platform::Path &filename, EntityList *el, SMesh *m, SShell *s
     
     hEntity hprev;
     hEntity hprevTop;
-    Vector pprev{};     // {0, 0, 0}
-    Vector pprevTop{};  // {0, 0, 0}
+    Vector pprev{}; 
+    Vector pprevTop{}; 
     
     double board_thickness = 10.0;
     double scale = 1.0; //mm
@@ -510,7 +510,7 @@ bool LinkIDF(const Platform::Path &filename, EntityList *el, SMesh *m, SShell *s
     SPolygon polyLoops = {};
     bool allClosed;
     bool allCoplanar;
-    Vector errorPointAt{}; // {0, 0, 0}
+    Vector errorPointAt{};
     SEdge errorAt = {};
     
     SBezierLoopSetSet sblss = {};
@@ -522,7 +522,7 @@ bool LinkIDF(const Platform::Path &filename, EntityList *el, SMesh *m, SShell *s
     double ctc = SS.chordTolCalculated;
     if(ctc == 0.0) SS.chordTolCalculated = 0.1; //mm
     // there should only by one sbls in the sblss unless a board has disjointed parts...
-    sh->MakeFromExtrusionOf(sblss.l.First(), {} /*{0.0, 0.0, 0.0}*/,
+    sh->MakeFromExtrusionOf(sblss.l.First(), {},
                                    {0.0, 0.0, board_thickness},
                                    RgbaColor::From(0, 180, 0) );
     SS.chordTolCalculated = ctc;
diff --git a/src/importmesh.cpp b/src/importmesh.cpp
@@ -87,7 +87,7 @@ static hEntity newNormal(EntityList *el, int *id, Quaternion normal, hEntity p)
     en.construction = false;
     en.style.v = Style::NORMALS;
     // to be visible we need to add a point.
-//    en.point[0] = newPoint(el, id, {0, 0, 0});
+//    en.point[0] = newPoint(el, id, {});
     en.point[0] = p;
     en.actVisible = true;
     en.forceHidden = false;
@@ -205,7 +205,7 @@ bool LinkStl(const Platform::Path &filename, EntityList *el, SMesh *m, SShell *s
     int id = 1;
 
     //add the STL origin and normals
-    hEntity origin = newPoint(el, &id, {} /*{0.0, 0.0, 0.0}*/);
+    hEntity origin = newPoint(el, &id, {});
     newNormal(el, &id, Quaternion::From({1, 0, 0},{0, 1, 0}), origin);
     newNormal(el, &id, Quaternion::From({0, 1, 0},{0, 0, 1}), origin);
     newNormal(el, &id, Quaternion::From({0, 0, 1},{1, 0, 0}), origin);
diff --git a/src/mesh.cpp b/src/mesh.cpp
@@ -115,7 +115,7 @@ void SMesh::Simplify(int start) {
     STriangle *tout = new STriangle[maxTriangles];
     int toutc = 0;
 
-    Vector n = {} /*{0, 0, 0}*/;
+    Vector n = {};
     Vector *conv = new Vector[maxTriangles * 3];
     int convc = 0;
 
diff --git a/src/modify.cpp b/src/modify.cpp
@@ -644,7 +644,7 @@ void GraphicsWindow::SplitLinesOrCurves() {
 
     Entity *ea = SK.GetEntity(ha),
            *eb = SK.GetEntity(hb);
-    Vector pi = {} /*{0, 0, 0}*/;
+    Vector pi = {};
 
     // First, decide the point where we're going to make the split.
     bool foundInters = false;
diff --git a/src/polygon.cpp b/src/polygon.cpp
@@ -271,8 +271,8 @@ bool SEdgeList::AssemblePolygon(SPolygon *dest, SEdge *errorAt, bool keepDir) co
     dest->Clear();
 
     bool allClosed = true;
-    Vector first = {} /*{0, 0, 0}*/;
-    Vector last  = {} /*{0, 0, 0}*/;
+    Vector first = {};
+    Vector last  = {};
     int i;
     for(i = 0; i < l.n; i++) {
         if(!l[i].tag) {
@@ -380,7 +380,7 @@ SKdNodeEdges *SKdNodeEdges::From(SEdgeLl *sell) {
 
     // Compute the midpoints (just mean, though median would be better) of
     // each component.
-    Vector ptAve = {} /*{0, 0, 0}*/;
+    Vector ptAve = {};
     SEdgeLl *flip;
     int totaln = 0;
     for(flip = sell; flip; flip = flip->next) {
@@ -582,7 +582,7 @@ void SContour::FindPointWithMinX() {
 }
 
 Vector SContour::ComputeNormal() const {
-    Vector n = {} /*{0, 0, 0}*/;
+    Vector n = {};
 
     for(int i = 0; i < l.n - 2; i++) {
         Vector u = (l[i+1].p).Minus(l[i+0].p).WithMagnitude(1);
@@ -678,7 +678,7 @@ void SPolygon::MakeEdgesInto(SEdgeList *el) const {
 
 Vector SPolygon::ComputeNormal() const {
     if(l.IsEmpty())
-        return {} /*{0, 0, 0}*/;
+        return {};
     return (l[0]).ComputeNormal();
 }
 
diff --git a/src/render/rendergl1.cpp b/src/render/rendergl1.cpp
@@ -643,7 +643,7 @@ void OpenGl1Renderer::DrawMesh(const SMesh &m, hFill hcfFront, hFill hcfBack) {
             }
         }
 
-        if(tr.an.EqualsExactly({} /*{0, 0, 0}*/)) {
+        if(tr.an.EqualsExactly({})) {
             // Compute the normal from the vertices
             ssglNormal3v(tr.Normal());
             ssglVertex3v(tr.a);
diff --git a/src/srf/boolean.cpp b/src/srf/boolean.cpp
@@ -548,8 +548,8 @@ SSurface SSurface::MakeCopyTrimAgainst(SShell *parent,
 
             SBspUv::Class c = (ss->bsp) ? ss->bsp->ClassifyEdge(auv, buv, ss) : SBspUv::Class::OUTSIDE;
             if(c != SBspUv::Class::OUTSIDE) {
-                Vector ta = {} /*{0, 0, 0}*/;
-                Vector tb = {} /*{0, 0, 0}*/;
+                Vector ta = {};
+                Vector tb = {};
                 ret.ClosestPointTo(a, &(ta.x), &(ta.y));
                 ret.ClosestPointTo(b, &(tb.x), &(tb.y));
 
@@ -754,7 +754,7 @@ void SShell::RewriteSurfaceHandlesForCurves(SShell *a, SShell *b) {
 void SShell::MakeFromAssemblyOf(SShell *a, SShell *b) {
     booleanFailed = false;
 
-    Vector t = {} /*{0, 0, 0}*/;
+    Vector t = {};
     Quaternion q = Quaternion::IDENTITY;
     int i = 0;
     SShell *ab;
diff --git a/src/srf/curve.cpp b/src/srf/curve.cpp
@@ -316,7 +316,7 @@ bool SBezierList::GetPlaneContainingBeziers(Vector *p, Vector *u, Vector *v,
     if(!l.IsEmpty()) {
         pt = l[0].Start();
     } else {
-        pt = {} /*{0, 0, 0}*/;
+        pt = {};
     }
     ptFar = ptOffLine = pt;
 
@@ -526,7 +526,7 @@ SBezierLoopSet SBezierLoopSet::From(SBezierList *sbl, SPolygon *poly,
     if(poly->l.n > 0) {
         ret.point = poly->AnyPoint();
     } else {
-        ret.point = {} /*{0, 0, 0}*/;
+        ret.point = {};
     }
 
     return ret;
diff --git a/src/srf/ratpoly.cpp b/src/srf/ratpoly.cpp
@@ -39,7 +39,7 @@ static inline double BernsteinDerivative(int k, int deg, double t) {
 }
 
 Vector SBezier::PointAt(double t) const {
-    Vector pt = {} /*{0, 0, 0}*/;
+    Vector pt = {};
     double d = 0;
 
     int i;
@@ -53,7 +53,7 @@ Vector SBezier::PointAt(double t) const {
 }
 
 Vector SBezier::TangentAt(double t) const {
-    Vector pt = {} /*{0, 0, 0}*/, pt_p = {} /*{0, 0, 0}*/;
+    Vector pt = {}, pt_p = {};
     double d = 0, d_p = 0;
 
     int i;
@@ -313,7 +313,7 @@ Vector SSurface::PointAt(Point2d puv) const {
     return PointAt(puv.x, puv.y);
 }
 Vector SSurface::PointAt(double u, double v) const {
-    Vector num = {} /*{0, 0, 0}*/;
+    Vector num = {};
     double den = 0;
 
     int i, j;
@@ -331,9 +331,9 @@ Vector SSurface::PointAt(double u, double v) const {
 }
 
 void SSurface::TangentsAt(double u, double v, Vector *tu, Vector *tv, bool retry) const {
-    Vector num   = {} /*{0, 0, 0}*/,
-           num_u = {} /*{0, 0, 0}*/,
-           num_v = {} /*{0, 0, 0}*/;
+    Vector num   = {},
+           num_u = {},
+           num_v = {};
     double den   = 0,
            den_u = 0,
            den_v = 0;
@@ -364,9 +364,9 @@ void SSurface::TangentsAt(double u, double v, Vector *tu, Vector *tv, bool retry
     *tv = tv->ScaledBy(1.0/(den*den));
     
     // Tangent is zero at sungularities like the north pole. Move away a bit and retry. 
-    if(tv->Equals({} /*{0, 0, 0}*/) && retry)
+    if(tv->Equals({}) && retry)
         TangentsAt(u+(0.5-u)*0.00001, v, tu, tv, false);
-    if(tu->Equals({} /*{0, 0, 0}*/) && retry)
+    if(tu->Equals({}) && retry)
         TangentsAt(u, v+(0.5-v)*0.00001, tu, tv, false);
 }
 
@@ -467,7 +467,7 @@ void SSurface::ClosestPointTo(Vector p, double *u, double *v, bool mustConverge)
 bool SSurface::ClosestPointNewton(Vector p, double *u, double *v, bool mustConverge) const
 {
     // Initial guess is in u, v; refine by Newton iteration.
-    Vector p0 = {} /*{0, 0, 0}*/;
+    Vector p0 = {};
     for(int i = 0; i < (mustConverge ? 25 : 5); i++) {
         p0 = PointAt(*u, *v);
         if(mustConverge) {
diff --git a/src/srf/shell.cpp b/src/srf/shell.cpp
@@ -549,7 +549,7 @@ void SShell::MakeFirstOrderRevolvedSurfaces(Vector pt, Vector axis, int i0) {
 
 void SShell::MakeFromCopyOf(SShell *a) {
     ssassert(this != a, "Can't make from copy of self");
-    MakeFromTransformationOf(a, {} /*{0, 0, 0}*/, Quaternion::IDENTITY, 1.0);
+    MakeFromTransformationOf(a, {}, Quaternion::IDENTITY, 1.0);
 }
 
 void SShell::MakeFromTransformationOf(SShell *a,
diff --git a/src/srf/surface.cpp b/src/srf/surface.cpp
@@ -222,7 +222,7 @@ bool SSurface::LineEntirelyOutsideBbox(Vector a, Vector b, bool asSegment) const
 void SSurface::MakeTrimEdgesInto(SEdgeList *sel, MakeAs flags,
                                  SCurve *sc, STrimBy *stb)
 {
-    Vector prev = {} /*{0, 0, 0}*/;
+    Vector prev = {};
     bool inCurve = false, empty = true;
     double u = 0, v = 0;
 
diff --git a/src/srf/surfinter.cpp b/src/srf/surfinter.cpp
@@ -436,7 +436,7 @@ void SSurface::IntersectAgainst(SSurface *b, SShell *agnstA, SShell *agnstB,
             sc.pts.Add(&padd);
 
             Point2d pa, pb;
-            Vector np, npc = {} /*{0, 0, 0}*/;
+            Vector np, npc = {};
             bool fwd = false;
             // Better to start with a too-small step, so that we don't miss
             // features of the curve entirely.
diff --git a/src/srf/triangulate.cpp b/src/srf/triangulate.cpp
@@ -614,7 +614,7 @@ void SPolygon::UvGridTriangulateInto(SMesh *mesh, SSurface *srf) {
         // generate two triangles in the mesh, and cut it out of our polygon.
         // Quads around the perimeter would be rejected by AnyEdgeCrossings.
         std::vector<bool> bottom(lj.n, false); // did we use this quad?
-        Vector tu{}, tv{};  // {0, 0, 0}
+        Vector tu{}, tv{}; 
         int i, j;
         for(i = 1; i < (li.n-1); i++) {
             bool prev_flag = false;
@@ -712,7 +712,7 @@ void SPolygon::UvGridTriangulateInto(SMesh *mesh, SSurface *srf) {
 
 void SPolygon::TriangulateInto(SMesh *m) const {
     Vector n = normal;
-    if(n.Equals({} /*{0.0, 0.0, 0.0}*/)) {
+    if(n.Equals({})) {
        n = ComputeNormal();
     }
     Vector u = n.Normal(0);
diff --git a/src/util.cpp b/src/util.cpp
@@ -784,7 +784,7 @@ Vector Vector::AtIntersectionOfPlaneAndLine(Vector n, double d,
 
     if(fabs(n.Dot(dp)) < LENGTH_EPS) {
         if(parallel) *parallel = true;
-        return {} /*{0, 0, 0}*/;
+        return {};
     }
 
     if(parallel) *parallel = false;
@@ -819,7 +819,7 @@ Vector Vector::AtIntersectionOfPlanes(Vector na, double da,
                        nc.x, nc.y, nc.z);
     if(fabs(det) < 1e-10) { // arbitrary tolerance, not so good
         *parallel = true;
-        return {} /*{0, 0, 0}*/;
+        return {};
     }
     *parallel = false;
 

Original file line number	Diff line number	Diff line change
`@@ -320,7 +320,7 @@ void Constraint::MenuConstrain(Command id) {`
`320`	`320`	`c.disp.offset = n.Cross(a.Minus(b));`
`321`	`321`	`c.disp.offset = (c.disp.offset).WithMagnitude(50/SS.GW.scale);`
`322`	`322`	`} else {`
`323`		`- c.disp.offset = {}; // {0, 0, 0}`
	`323`	`+ c.disp.offset = {};`
`324`	`324`	`}`
`325`	`325`
`326`	`326`	`if(id == Command::REF_DISTANCE) {`
Original file line number	Diff line number	Diff line change
`@@ -886,7 +886,7 @@ void Constraint::DoLayout(DrawAs how, Canvas *canvas,`
`886`	`886`	`}`
`887`	`887`
`888`	`888`	`case Type::PERPENDICULAR: {`
`889`		`- Vector u{}, v{}; // {0, 0, 0}`
	`889`	`+ Vector u{}, v{};`
`890`	`890`	`Vector rn, ru;`
`891`	`891`	`if(workplane == Entity::FREE_IN_3D) {`
`892`	`892`	`rn = gn;`
Original file line number	Diff line number	Diff line change
`@@ -1002,7 +1002,7 @@ void Group::MakeRevolveEndFaces(EntityList *el, hEntity pt, int ai, int af)`
`1002`	`1002`
`1003`	`1003`	`// When there is no loop normal (e.g. if the loop is broken), use normal of workplane`
`1004`	`1004`	`// as fallback, to avoid breaking constraints depending on the faces.`
`1005`		`- if(n.Equals({} /{0.0, 0.0, 0.0}/) && src->type == Group::Type::DRAWING_WORKPLANE) {`
	`1005`	`+ if(n.Equals({}) && src->type == Group::Type::DRAWING_WORKPLANE) {`
`1006`	`1006`	`n = SK.GetEntity(src->h.entity(0))->Normal()->NormalN();`
`1007`	`1007`	`}`
`1008`	`1008`
`@@ -1039,7 +1039,7 @@ void Group::MakeExtrusionTopBottomFaces(EntityList *el, hEntity pt)`
`1039`	`1039`
`1040`	`1040`	`// When there is no loop normal (e.g. if the loop is broken), use normal of workplane`
`1041`	`1041`	`// as fallback, to avoid breaking constraints depending on the faces.`
`1042`		`- if(n.Equals({} /{0.0, 0.0, 0.0}/) && src->type == Group::Type::DRAWING_WORKPLANE) {`
	`1042`	`+ if(n.Equals({}) && src->type == Group::Type::DRAWING_WORKPLANE) {`
`1043`	`1043`	`n = SK.GetEntity(src->h.entity(0))->Normal()->NormalN();`
`1044`	`1044`	`}`
`1045`	`1045`