NFC: Raplace all aggregate initializations {0, 0, 0} with {}

ruevs · ruevs · commit 5a471b538b7a · 2026-03-31T15:27:31.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, {} /*{0, 0, 0}*/);
             pt = pt.Plus(p);
             pt = pt.RotatedAbout(n, theta);
             pt = pt.Plus(trans);
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({} /*{0, 0, 0}*/);
         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({} /*{0, 0, 0}*/, 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({} /*{0.0, 0.0, 0.0}*/) && 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({} /*{0.0, 0.0, 0.0}*/) && 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 = {} /*{0, 0, 0}*/; 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 = {}; /*{0.0, 0.0, 0.0}*/
         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,7 +339,7 @@ bool LinkIDF(const Platform::Path &filename, EntityList *el, SMesh *m, SShell *s
     
     hEntity hprev;
     hEntity hprevTop;
-    Vector pprev{};    // {0, 0, 0}
+    Vector pprev{};     // {0, 0, 0}
     Vector pprevTop{};  // {0, 0, 0}
     
     double board_thickness = 10.0;
@@ -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, 0.0}*/,
                                    {0.0, 0.0, board_thickness},
                                    RgbaColor::From(0, 180, 0) );
     SS.chordTolCalculated = ctc;
diff --git a/src/importmesh.cpp b/src/importmesh.cpp
@@ -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, {} /*{0.0, 0.0, 0.0}*/);
     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 = {} /*{0, 0, 0}*/;
     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 = {} /*{0, 0, 0}*/;
 
     // 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 = {} /*{0, 0, 0}*/;
+    Vector last  = {} /*{0, 0, 0}*/;
     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 = {} /*{0, 0, 0}*/;
     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 = {} /*{0, 0, 0}*/;
 
     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 {} /*{0, 0, 0}*/;
     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({} /*{0, 0, 0}*/)) {
             // 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 = {} /*{0, 0, 0}*/;
+                Vector tb = {} /*{0, 0, 0}*/;
                 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 = {} /*{0, 0, 0}*/;
     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 = {} /*{0, 0, 0}*/;
     }
     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 = {} /*{0, 0, 0}*/;
     }
 
     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 = {} /*{0, 0, 0}*/;
     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 = {} /*{0, 0, 0}*/, pt_p = {} /*{0, 0, 0}*/;
     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 = {} /*{0, 0, 0}*/;
     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   = {} /*{0, 0, 0}*/,
+           num_u = {} /*{0, 0, 0}*/,
+           num_v = {} /*{0, 0, 0}*/;
     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({} /*{0, 0, 0}*/) && retry)
         TangentsAt(u+(0.5-u)*0.00001, v, tu, tv, false);
-    if(tu->Equals({0, 0, 0}) && retry)
+    if(tu->Equals({} /*{0, 0, 0}*/) && 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 = {} /*{0, 0, 0}*/;
     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, {} /*{0, 0, 0}*/, 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 = {} /*{0, 0, 0}*/;
     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 = {} /*{0, 0, 0}*/;
             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
@@ -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({} /*{0.0, 0.0, 0.0}*/)) {
        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 {} /*{0, 0, 0}*/;
     }
 
     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 {} /*{0, 0, 0}*/;
     }
     *parallel = false;
 

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({} /{0.0, 0.0, 0.0}/) && 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({} /{0.0, 0.0, 0.0}/) && src->type == Group::Type::DRAWING_WORKPLANE) {`
`1043`	`1043`	`n = SK.GetEntity(src->h.entity(0))->Normal()->NormalN();`
`1044`	`1044`	`}`
`1045`	`1045`