sunrize 1.7.44 → 1.7.45

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sunrize",
   "productName": "Sunrize X3D Editor",
-  "version": "1.7.44",
+  "version": "1.7.45",
   "description": "A Multi-Platform X3D Editor",
   "main": "src/main.js",
   "bin": {
@@ -90,7 +90,7 @@
   "dependencies": {
     "capitalize": "^2.0.4",
     "console": "^0.7.2",
-    "electron": "^33.3.1",
+    "electron": "^34.0.0",
     "electron-prompt": "^1.7.0",
     "electron-squirrel-startup": "^1.0.1",
     "electron-tabs": "^1.0.4",
@@ -109,7 +109,7 @@
     "string-similarity": "^4.0.4",
     "tweakpane": "^3.1.10",
     "update-electron-app": "^3.1.0",
-    "x_ite": "^11.0.4",
+    "x_ite": "^11.0.5",
     "x3d-traverse": "^1.0.9"
   }
 }

package/src/Application/Document.js

@@ -177,15 +177,7 @@ module .exports = class Document extends Interface
 
       this .browser .updateConcreteNode (require ("../Components/Grouping/StaticGroup"));
 
-      X3D .NurbsSweptSurface .prototype .traverse = function (type, renderObject)
-      {
-         this .getTrajectoryCurve () ?.traverse (type, renderObject);
-      };
-
-      X3D .NurbsSwungSurface .prototype .traverse = function (type, renderObject)
-      {
-         this .getTrajectoryCurve () ?.traverse (type, renderObject);
-      };
+      require ("../Components");
 
       // Restore
 

package/src/Components/Geometry2D/Arc2D.js

@@ -0,0 +1,16 @@
+const X3D = require ("../../X3D");
+
+Object .assign (X3D .Arc2D .prototype,
+{
+   toPrimitive (executionContext = this .getExecutionContext ())
+   {
+      const geometry = this .toIndexedLineSet (executionContext,
+      {
+         polyline: true,
+      });
+
+      geometry ._metadata = this ._metadata;
+
+      return geometry;
+   },
+});

package/src/Components/Geometry2D/ArcClose2D.js

@@ -0,0 +1,14 @@
+const X3D = require ("../../X3D");
+
+Object .assign (X3D .ArcClose2D .prototype,
+{
+   toPrimitive (executionContext = this .getExecutionContext ())
+   {
+      const geometry = this .toIndexedFaceSet (executionContext, { texCoord: true });
+
+      geometry ._metadata = this ._metadata;
+      geometry ._solid    = this ._solid;
+
+      return geometry;
+   },
+});

package/src/Components/Geometry2D/Circle2D.js

@@ -0,0 +1,23 @@
+const X3D = require ("../../X3D");
+
+Object .assign (X3D .Circle2D .prototype,
+{
+   toPrimitive (executionContext = this .getExecutionContext ())
+   {
+      const
+         browser  = this .getBrowser (),
+         geometry = browser .getCircle2DOptions () .getGeometry () .copy (executionContext),
+         radius   = this ._radius .getValue ();
+
+      geometry ._metadata = this ._metadata;
+      geometry ._coord    = geometry ._coord .getValue () .copy (executionContext);
+
+      for (const [i, point] of geometry ._coord .point .entries ())
+         geometry ._coord .point [i] = point .multiply (radius);
+
+      geometry ._coord .getValue () .setup ();
+      geometry .setup ();
+
+      return geometry;
+   },
+});

package/src/Components/Geometry2D/Disk2D.js

@@ -0,0 +1,53 @@
+const X3D = require ("../../X3D");
+
+Object .assign (X3D .Disk2D .prototype,
+{
+   toPrimitive (executionContext = this .getExecutionContext ())
+   {
+      const
+         innerRadius = Math .min (Math .abs (this ._innerRadius .getValue ()), Math .abs (this ._outerRadius .getValue ())),
+         outerRadius = Math .max (Math .abs (this ._innerRadius .getValue ()), Math .abs (this ._outerRadius .getValue ()));
+
+      if (innerRadius === outerRadius)
+      {
+         // Point
+
+         if (outerRadius === 0)
+         {
+            const geometry = executionContext .createNode ("PointSet", false);
+
+            geometry ._coord = executionContext .createNode ("Coordinate", false);
+
+            geometry ._coord .point .push (new X3D .SFVec3f ());
+
+            geometry ._coord .getValue () .setup ();
+            geometry .setup ();
+
+            return geometry;
+         }
+
+         // Circle
+
+         const
+            browser  = this .getBrowser (),
+            geometry = browser .getCircle2DOptions () .getGeometry () .copy (executionContext);
+
+         geometry ._coord = geometry ._coord .getValue () .copy (executionContext);
+
+         for (const [i, point] of geometry ._coord .point .entries ())
+            geometry ._coord .point [i] = point .multiply (outerRadius);
+
+         geometry ._coord .getValue () .setup ();
+         geometry .setup ();
+
+         return geometry;
+      }
+
+      const geometry = this .toIndexedFaceSet (executionContext, { texCoord: true });
+
+      geometry ._metadata = this ._metadata;
+      geometry ._solid    = this ._solid;
+
+      return geometry;
+   },
+});

package/src/Components/Geometry2D/Polyline2D.js

@@ -0,0 +1,16 @@
+const X3D = require ("../../X3D");
+
+Object .assign (X3D .Polyline2D .prototype,
+{
+   toPrimitive (executionContext = this .getExecutionContext ())
+   {
+      const geometry = this .toIndexedLineSet (executionContext,
+      {
+         polyline: true,
+      });
+
+      geometry ._metadata = this ._metadata;
+
+      return geometry;
+   },
+});

package/src/Components/Geometry2D/Polypoint2D.js

@@ -0,0 +1,20 @@
+const X3D = require ("../../X3D");
+
+Object .assign (X3D .Polypoint2D .prototype,
+{
+   toPrimitive (executionContext = this .getExecutionContext ())
+   {
+      const geometry = executionContext .createNode ("PointSet", false);
+
+      geometry ._metadata = this ._metadata;
+      geometry ._coord    = executionContext .createNode ("Coordinate", false);
+
+      for (const point of this ._point)
+         geometry ._coord .point .push (new X3D .SFVec3f (... point, 0));
+
+      geometry ._coord .getValue () .setup ();
+      geometry .setup ();
+
+      return geometry;
+   },
+});

package/src/Components/Geometry2D/Rectangle2D.js

@@ -0,0 +1,27 @@
+const X3D = require ("../../X3D");
+
+Object .assign (X3D .Rectangle2D .prototype,
+{
+   toPrimitive (executionContext = this .getExecutionContext ())
+   {
+      const
+         browser  = this .getBrowser (),
+         geometry = browser .getRectangle2DOptions () .getGeometry () .copy (executionContext),
+         size1_2  = new X3D .SFVec3f (... this ._size .divide (2), 1);
+
+      geometry ._metadata = this ._metadata;
+      geometry ._solid    = this ._solid;
+
+      geometry ._texCoord = geometry ._texCoord .getValue () .copy (executionContext);
+      geometry ._coord    = geometry ._coord    .getValue () .copy (executionContext);
+
+      for (const [i, point] of geometry ._coord .point .entries ())
+         geometry ._coord .point [i] = point .multVec (size1_2);
+
+      geometry ._texCoord .getValue () .setup ();
+      geometry ._coord    .getValue () .setup ();
+      geometry .setup ();
+
+      return geometry;
+   },
+});

package/src/Components/Geometry2D/TriangleSet2D.js

@@ -0,0 +1,33 @@
+const X3D = require ("../../X3D");
+
+Object .assign (X3D .TriangleSet2D .prototype,
+{
+   toPrimitive (executionContext = this .getExecutionContext ())
+   {
+      const
+         texCoords = this .getTexCoords (),
+         vertices  = this .getVertices (),
+         geometry  = executionContext .createNode ("IndexedFaceSet", false);
+
+      geometry ._metadata = this ._metadata;
+      geometry ._solid    = this ._solid;
+
+      geometry ._texCoord = executionContext .createNode ("TextureCoordinate", false);
+      geometry ._coord    = executionContext .createNode ("Coordinate",        false);
+
+      for (let i = 0, length = vertices .length / 12; i < length; ++ i)
+         geometry ._coordIndex .push (i * 3, i * 3 + 1, i * 3 + 2, -1);
+
+      for (let i = 0, length = vertices .length; i < length; i += 4)
+      {
+         geometry ._texCoord .point .push (new X3D .SFVec2f (texCoords [i], texCoords [i + 1]));
+         geometry ._coord    .point .push (new X3D .SFVec3f (vertices  [i], vertices  [i + 1], 0));
+      }
+
+      geometry ._texCoord .getValue () .setup ();
+      geometry ._coord    .getValue () .setup ();
+      geometry .setup ();
+
+      return geometry;
+   },
+});

package/src/Components/Geometry3D/Box.js

@@ -0,0 +1,27 @@
+const X3D = require ("../../X3D");
+
+Object .assign (X3D .Box .prototype,
+{
+   toPrimitive (executionContext = this .getExecutionContext ())
+   {
+      const
+         browser  = this .getBrowser (),
+         geometry = browser .getBoxOptions () .getGeometry () .copy (executionContext),
+         size1_2  = this ._size .divide (2);
+
+      geometry ._metadata = this ._metadata;
+      geometry ._solid    = this ._solid;
+
+      geometry ._texCoord = geometry ._texCoord .getValue () .copy (executionContext);
+      geometry ._coord    = geometry ._coord    .getValue () .copy (executionContext);
+
+      for (const [i, point] of geometry ._coord .point .entries ())
+         geometry ._coord .point [i] = point .multVec (size1_2);
+
+      geometry ._texCoord .getValue () .setup ();
+      geometry ._coord    .getValue () .setup ();
+      geometry .setup ();
+
+      return geometry;
+   },
+});

package/src/Components/Geometry3D/Cone.js

@@ -0,0 +1,79 @@
+const X3D = require ("../../X3D");
+
+Object .assign (X3D .Cone .prototype,
+{
+   toPrimitive (executionContext = this .getExecutionContext ())
+   {
+      const
+         browser   = this .getBrowser (),
+         geometry  = browser .getConeOptions () .getSideGeometry () .copy (executionContext),
+         radius    = this ._bottomRadius .getValue (),
+         height1_2 = this ._height .getValue () / 2;
+
+      geometry ._metadata    = this ._metadata;
+      geometry ._coordIndex  = [ ];
+      geometry ._normalIndex = [ ];
+      geometry ._solid       = this ._solid;
+      geometry ._creaseAngle = Math .PI;
+
+      geometry ._texCoord = geometry ._texCoord .getValue () .copy (executionContext);
+      geometry ._normal   = null;
+      geometry ._coord    = geometry ._coord    .getValue () .copy (executionContext);
+
+      for (const point of geometry ._coord .point)
+      {
+         point .x *= radius;
+         point .y *= height1_2;
+         point .z *= radius;
+      }
+
+      if (this ._side .getValue ())
+      {
+         const last = geometry ._coord .point .length - 1;
+
+         for (const index of browser .getConeOptions () .getSideGeometry () ._coordIndex)
+         {
+            if (index < 0 || index !== last)
+            {
+               geometry ._coordIndex .push (index);
+            }
+            else
+            {
+               geometry ._coordIndex .push (geometry ._coord .point .length);
+               geometry ._coord .point .push (geometry ._coord .point [index]);
+            }
+         }
+      }
+      else
+      {
+         geometry ._texCoordIndex .length = 0;
+      }
+
+      if (this ._bottom .getValue ())
+      {
+         for (const index of browser .getConeOptions () .getBottomGeometry () ._texCoordIndex)
+            geometry ._texCoordIndex .push (index);
+
+         for (const index of browser .getConeOptions () .getBottomGeometry () ._coordIndex)
+         {
+            if (index < 0)
+            {
+               geometry ._coordIndex .push (-1);
+            }
+            else
+            {
+               geometry ._coordIndex .push (geometry ._coord .point .length);
+               geometry ._coord .point .push (geometry ._coord .point [index]);
+            }
+         }
+      }
+
+      // geometry .optimize ();
+
+      geometry ._texCoord .getValue () .setup ();
+      geometry ._coord    .getValue () .setup ();
+      geometry .setup ();
+
+      return geometry;
+   },
+});

package/src/Components/Geometry3D/Cylinder.js

@@ -0,0 +1,81 @@
+const X3D = require ("../../X3D");
+
+Object .assign (X3D .Cylinder .prototype,
+{
+   toPrimitive (executionContext = this .getExecutionContext ())
+   {
+      const
+         browser   = this .getBrowser (),
+         geometry  = browser .getCylinderOptions () .getSideGeometry () .copy (executionContext),
+         radius    = this ._radius .getValue (),
+         height1_2 = this ._height .getValue () / 2;
+
+      geometry ._metadata    = this ._metadata;
+      geometry ._normalIndex = [ ];
+      geometry ._solid       = this ._solid;
+      geometry ._creaseAngle = Math .PI;
+
+      geometry ._texCoord = geometry ._texCoord .getValue () .copy (executionContext);
+      geometry ._normal   = null;
+      geometry ._coord    = geometry ._coord .getValue () .copy (executionContext);
+
+      for (const point of geometry ._coord .point)
+      {
+         point .x *= radius;
+         point .y *= height1_2;
+         point .z *= radius;
+      }
+
+      if (!this ._side .getValue ())
+      {
+         geometry ._texCoordIndex .length = 0;
+         geometry ._coordIndex    .length = 0;
+      }
+
+      if (this ._top .getValue ())
+      {
+         for (const index of browser .getCylinderOptions () .getTopGeometry () ._texCoordIndex)
+            geometry ._texCoordIndex .push (index);
+
+         for (const index of browser .getCylinderOptions () .getTopGeometry () ._coordIndex)
+         {
+            if (index < 0)
+            {
+               geometry ._coordIndex .push (-1);
+            }
+            else
+            {
+               geometry ._coordIndex .push (geometry ._coord .point .length);
+               geometry ._coord .point .push (geometry ._coord .point [index]);
+            }
+         }
+      }
+
+      if (this ._bottom .getValue ())
+      {
+         for (const index of browser .getCylinderOptions () .getBottomGeometry () ._texCoordIndex)
+            geometry ._texCoordIndex .push (index);
+
+         for (const index of browser .getCylinderOptions () .getBottomGeometry () ._coordIndex)
+         {
+            if (index < 0)
+            {
+               geometry ._coordIndex .push (-1);
+            }
+            else
+            {
+               geometry ._coordIndex .push (geometry ._coord .point .length);
+               geometry ._coord .point .push (geometry ._coord .point [index]);
+            }
+         }
+      }
+
+      // geometry .optimize ();
+
+      geometry ._texCoord .getValue () .setup ();
+      geometry ._coord    .getValue () .setup ();
+      geometry .setup ();
+
+      return geometry;
+   },
+});

package/src/Components/Geometry3D/ElevationGrid.js

@@ -0,0 +1,23 @@
+const X3D = require ("../../X3D");
+
+Object .assign (X3D .ElevationGrid .prototype,
+{
+   toPrimitive (executionContext = this .getExecutionContext ())
+   {
+      const geometry = this .toIndexedFaceSet (executionContext,
+      {
+         fogCoord: !!this ._fogCoord .getValue (),
+         color: !!this ._color .getValue (),
+         texCoord: true,
+         tangent: !!this ._tangent .getValue (),
+         normal: !!this ._normal .getValue (),
+      });
+
+      geometry ._metadata    = this ._metadata;
+      geometry ._solid       = this ._solid;
+      geometry ._ccw         = this ._ccw;
+      geometry ._creaseAngle = this ._creaseAngle;
+
+      return geometry;
+   },
+});

package/src/Components/Geometry3D/Extrusion.js

@@ -0,0 +1,194 @@
+const X3D = require ("../../X3D");
+
+Object .assign (X3D .Extrusion .prototype,
+{
+   toPrimitive (executionContext = this .getExecutionContext ())
+   {
+      const
+         geometry = executionContext .createNode ("IndexedFaceSet",    false),
+         texCoord = executionContext .createNode ("TextureCoordinate", false),
+         coord    = executionContext .createNode ("Coordinate",        false);
+
+      geometry ._metadata    = this ._metadata;
+      geometry ._solid       = this ._solid;
+      geometry ._ccw         = this ._ccw;
+      geometry ._convex      = this ._convex;
+      geometry ._creaseAngle = this ._creaseAngle;
+
+      geometry ._texCoord = texCoord;
+      geometry ._coord    = coord;
+
+      // Fill the geometry with points.
+
+      const points = this .createPoints ();
+
+      const
+         numSpines          = this ._spine .length,
+         numCrossSections   = this ._crossSection .length,
+         numSpines_1        = numSpines - 1,
+         numCrossSections_1 = numCrossSections - 1;
+
+      if (numSpines < 2 || numCrossSections < 2)
+      {
+         texCoord .setup ();
+         coord    .setup ();
+         geometry .setup ();
+
+         return geometry;
+      }
+
+      const closedSpine = this .getClosed (this ._spine)
+         && this .getClosed (this ._orientation)
+         && this .getClosed (this ._scale);
+
+      const closedCrossSection = this .getClosed (this ._crossSection);
+
+      // Coordinates
+
+      for (let s = 0; s < numSpines_1; ++ s)
+      {
+         for (let c = 0; c < numCrossSections_1; ++ c)
+         {
+            /* 0---3
+             * |\  |
+             * | \ |
+             * |__\|
+             * 1   2
+             */
+
+            const
+               c1 = closedCrossSection ? (c + 1) % numCrossSections_1 : c + 1,
+               s1 = closedSpine        ? (s + 1) % numSpines_1        : s + 1;
+
+            const
+               p0 = s * numCrossSections + c,
+               p1 = s * numCrossSections + c1,
+               p2 = s1 * numCrossSections + c1,
+               p3 = s1 * numCrossSections + c;
+
+            geometry ._coordIndex .push (p0, p1, p2, -1, p0, p2, p3, -1);
+         }
+      }
+
+      coord ._point = points .flatMap (point => [... point]);
+
+      // Texture coordinates
+
+      for (let s = 0; s < numSpines_1; ++ s)
+      {
+         for (let c = 0; c < numCrossSections_1; ++ c)
+         {
+            const
+               c1 = c + 1,
+               s1 = s + 1;
+
+            const
+               p0 = s * numCrossSections + c,
+               p1 = s * numCrossSections + c1,
+               p2 = s1 * numCrossSections + c1,
+               p3 = s1 * numCrossSections + c;
+
+            geometry ._texCoordIndex .push (p0, p1, p2, -1, p0, p2, p3, -1);
+         }
+      }
+
+      const texCoordPoints = [ ];
+
+      for (let s = 0; s < numSpines; ++ s)
+      {
+         for (let c = 0; c < numCrossSections; ++ c)
+         {
+            const
+               tx = c / numCrossSections_1,
+               ty = s / numSpines_1;
+
+            texCoordPoints .push (tx, ty);
+         }
+      }
+
+      texCoord ._point = texCoordPoints;
+
+      // Caps
+
+      let min = max = this ._crossSection [0];
+
+      for (let c = 1; c < numCrossSections; ++ c)
+      {
+         min = min .min (this ._crossSection [c]);
+         max = max .max (this ._crossSection [c]);
+      }
+
+      const
+         capSize      = max .subtract (min),
+         capMax       = Math .max (capSize .x, capSize .y),
+         numCapPoints = closedCrossSection ? numCrossSections_1 : numCrossSections;
+
+      // Begin Cap
+
+      if (this ._beginCap .getValue ())
+      {
+         // Coordinates
+
+         const numCoords = coord ._point .length;
+
+         for (let c = numCapPoints - 1; c >= 0; -- c)
+            coord ._point .push (coord ._point [c]);
+
+         for (let c = 0; c < numCapPoints; ++ c)
+            geometry ._coordIndex .push (numCoords + c);
+
+         geometry ._coordIndex .push (-1);
+
+         // Texture coordinates
+
+         const numTexCoords = texCoord ._point .length;
+
+         for (let c = numCapPoints - 1; c >= 0; -- c)
+            texCoord ._point .push (this ._crossSection [c] .subtract (min) .divide (capMax));
+
+         for (let c = 0; c < numCapPoints; ++ c)
+            geometry ._texCoordIndex .push (numTexCoords + c);
+
+         geometry ._texCoordIndex .push (-1);
+      }
+
+      // End Cap
+
+      if (this ._endCap .getValue ())
+      {
+         // Coordinates
+
+         const first = numSpines * numCrossSections - numCrossSections;
+
+         const numCoords = coord ._point .length;
+
+         for (let c = 0; c < numCapPoints; ++ c)
+            coord ._point .push (coord ._point [first + c]);
+
+         for (let c = 0; c < numCapPoints; ++ c)
+            geometry ._coordIndex .push (numCoords + c);
+
+         geometry ._coordIndex .push (-1);
+
+         // Texture coordinates
+
+         const numTexCoords = texCoord ._point .length;
+
+         for (let c = 0; c < numCapPoints; ++ c)
+            texCoord ._point .push (this ._crossSection [c] .subtract (min) .divide (capMax));
+
+         for (let c = 0; c < numCapPoints; ++ c)
+            geometry ._texCoordIndex .push (numTexCoords + c);
+
+         geometry ._texCoordIndex .push (-1);
+      }
+
+      // geometry ._optimize ();
+
+      texCoord .setup ();
+      coord    .setup ();
+      geometry .setup ();
+
+      return geometry;
+   },
+});