sunrize 1.7.44 → 1.7.46

package/src/Components/Geometry3D/IndexedFaceSet.js

@@ -0,0 +1,158 @@
+const X3D = require ("../../X3D");
+
+Object .assign (X3D .IndexedFaceSet .prototype,
+{
+   toIndexedTriangleSet (executionContext = this .getExecutionContext ())
+   {
+      const geometry = executionContext .createNode ("IndexedTriangleSet", false);
+
+      geometry ._metadata        = this ._metadata;
+      geometry ._solid           = this ._solid;
+      geometry ._ccw             = this ._ccw;
+      geometry ._colorPerVertex  = this ._colorPerVertex;
+      geometry ._normalPerVertex = this ._normalPerVertex;
+      geometry ._attrib          = this ._attrib;
+      geometry ._fogCoord        = this ._fogCoord;
+      geometry ._coord           = this ._coord;
+
+      if (!this ._colorIndex .length || this ._colorIndex .equals (this ._coordIndex))
+      {
+         geometry ._color = this ._color;
+      }
+
+      if (!this ._texCoordIndex .length || this ._texCoordIndex .equals (this ._coordIndex))
+      {
+         geometry ._texCoord = this ._texCoord;
+      }
+
+      if (!this ._normalIndex .length || this ._normalIndex .equals (this ._coordIndex))
+      {
+         geometry ._tangent = this ._tangent;
+         geometry ._normal  = this ._normal;
+      }
+
+      const polygons = this .triangulate ();
+
+      for (const { triangles } of polygons)
+      {
+         for (const i of triangles)
+         {
+            geometry ._index .push (this ._coordIndex [i]);
+         }
+      }
+
+      geometry .setup ();
+
+      return geometry;
+   },
+   toPrimitive (executionContext = this .getExecutionContext ())
+   {
+      const geometry = executionContext .createNode ("IndexedLineSet", false);
+
+      geometry ._metadata       = this ._metadata;
+      geometry ._colorPerVertex = this ._colorPerVertex;
+      geometry ._attrib         = this ._attrib;
+      geometry ._fogCoord       = this ._fogCoord;
+      geometry ._color          = this ._color;
+      geometry ._coord          = this ._coord;
+
+      if (this ._normalPerVertex .getValue ())
+      {
+         if (!this ._normalIndex .length || this ._normalIndex .equals (this ._coordIndex))
+         {
+            geometry ._tangent = this ._tangent;
+            geometry ._normal  = this ._normal;
+         }
+      }
+
+      // The coord index must end with -1!
+
+      const
+         lineIndex  = new Set (),
+         colorIndex = geometry ._colorIndex,
+         coordIndex = geometry ._coordIndex,
+         length     = this ._coordIndex .length;
+
+      let
+         line  = false,
+         last  = -1,
+         first = 0,
+         face  = 0;
+
+      for (let i = 1; i < length; ++ i)
+      {
+         const
+            p        = i - 1,
+            previous = this ._coordIndex [p];
+
+         let
+            index = this ._coordIndex [i],
+            c     = i;
+
+         if (index === -1)
+         {
+            index = this ._coordIndex [first];
+            c     = first;
+         }
+
+         const
+            minMax = `${Math .min (previous, index)} ${Math .max (previous, index)}`,
+            exists = lineIndex .has (minMax);
+
+         if (!exists)
+            lineIndex .add (minMax);
+
+         if ((previous === -1 || exists) && line)
+         {
+            if (this ._color .getValue ())
+            {
+               if (this ._colorPerVertex .getValue ())
+                  colorIndex .push (-1);
+               else
+                  colorIndex .push (this .getColorPerFaceIndex (face));
+            }
+
+            coordIndex .push (-1);
+
+            line = false;
+         }
+
+         if (previous === -1)
+         {
+            first = i;
+            face += 1;
+            last  = -1;
+            continue;
+         }
+
+         if (exists)
+            continue;
+
+         if (last !== previous)
+         {
+            if (this ._color .getValue ())
+            {
+               if (this ._colorPerVertex .getValue ())
+                  colorIndex .push (this .getColorPerVertexIndex (p));
+            }
+
+            coordIndex .push (previous);
+         }
+
+         if (this ._color .getValue ())
+         {
+            if (this ._colorPerVertex .getValue ())
+               colorIndex .push (this .getColorPerVertexIndex (c));
+         }
+
+         coordIndex .push (index);
+
+         last = index;
+         line = true;
+      }
+
+      geometry .setup ();
+
+      return geometry;
+   },
+});

package/src/Components/Geometry3D/Sphere.js

@@ -0,0 +1,27 @@
+const X3D = require ("../../X3D");
+
+Object .assign (X3D .Sphere .prototype,
+{
+   toPrimitive (executionContext = this .getExecutionContext ())
+   {
+      const
+         browser  = this .getBrowser (),
+         geometry = browser .getSphereOptions () .getGeometry () .copy (executionContext),
+         radius   = this ._radius .getValue ();
+
+      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 .multiply (radius);
+
+      geometry ._texCoord .getValue () .setup ();
+      geometry ._coord    .getValue () .setup ();
+      geometry .setup ();
+
+      return geometry;
+   },
+});

package/src/Components/NURBS/NurbsCurve.js

@@ -0,0 +1,17 @@
+const X3D = require ("../../X3D");
+
+Object .assign (X3D .NurbsCurve .prototype,
+{
+   toPrimitive (executionContext = this .getExecutionContext ())
+   {
+      const geometry = this .toIndexedLineSet (executionContext,
+      {
+         double: !!X3D .X3DCast (X3D .X3DConstants .CoordinateDouble, this ._controlPoint),
+         polyline: true,
+      });
+
+      geometry ._metadata = this ._metadata;
+
+      return geometry;
+   },
+});

package/src/Components/NURBS/NurbsSweptSurface.js

@@ -0,0 +1,24 @@
+const X3D = require ("../../X3D");
+
+Object .assign (X3D .NurbsSweptSurface .prototype,
+{
+   traverse (type, renderObject)
+   {
+      this .getTrajectoryCurve () ?.traverse (type, renderObject);
+   },
+   toPrimitive (executionContext = this .getExecutionContext ())
+   {
+      const geometry = this .toIndexedFaceSet (executionContext,
+      {
+         double: true,
+         texCoord: true,
+      });
+
+      geometry ._metadata    = this ._metadata;
+      geometry ._solid       = this ._solid;
+      geometry ._ccw         = this ._ccw;
+      geometry ._creaseAngle = Math .PI;
+
+      return geometry;
+   },
+});

package/src/Components/NURBS/NurbsSwungSurface.js

@@ -0,0 +1,24 @@
+const X3D = require ("../../X3D");
+
+Object .assign (X3D .NurbsSwungSurface .prototype,
+{
+   traverse (type, renderObject)
+   {
+      this .getTrajectoryCurve () ?.traverse (type, renderObject);
+   },
+   toPrimitive (executionContext = this .getExecutionContext ())
+   {
+      const geometry = this .toIndexedFaceSet (executionContext,
+      {
+         double: true,
+         texCoord: true,
+      });
+
+      geometry ._metadata    = this ._metadata;
+      geometry ._solid       = this ._solid;
+      geometry ._ccw         = this ._ccw;
+      geometry ._creaseAngle = Math .PI;
+
+      return geometry;
+   },
+});

package/src/Components/NURBS/X3DNurbsSurfaceGeometryNode.js

@@ -0,0 +1,19 @@
+const X3D = require ("../../X3D");
+
+Object .assign (X3D .X3DNurbsSurfaceGeometryNode .prototype,
+{
+   toPrimitive (executionContext = this .getExecutionContext ())
+   {
+      const geometry = this .toIndexedFaceSet (executionContext,
+      {
+         double: !!X3D .X3DCast (X3D .X3DConstants .CoordinateDouble, this ._controlPoint),
+         texCoord: true,
+      });
+
+      geometry ._metadata    = this ._metadata;
+      geometry ._solid       = this ._solid;
+      geometry ._creaseAngle = Math .PI;
+
+      return geometry;
+   },
+});

package/src/Components/Rendering/IndexedLineSet.js

@@ -0,0 +1,24 @@
+const X3D = require ("../../X3D");
+
+Object .assign (X3D .IndexedLineSet .prototype,
+{
+   toPrimitive (executionContext = this .getExecutionContext)
+   {
+      const geometry = executionContext .createNode ("PointSet", false);
+
+      geometry ._metadata = this ._metadata;
+      geometry ._attrib   = this ._attrib;
+      geometry ._fogCoord = this ._fogCoord;
+
+      if (this ._colorPerVertex .getValue ())
+         geometry ._color = this ._color;
+
+      geometry ._tangent = this ._tangent;
+      geometry ._normal  = this ._normal;
+      geometry ._coord   = this ._coord;
+
+      geometry .setup ();
+
+      return geometry;
+   },
+});

package/src/Components/Rendering/LineSet.js

@@ -0,0 +1,34 @@
+const X3D = require ("../../X3D");
+
+Object .assign (X3D .LineSet .prototype,
+{
+   toPrimitive (executionContext = this .getExecutionContext)
+   {
+      const geometry = executionContext .createNode ("IndexedLineSet", false);
+
+      geometry ._metadata = this ._metadata;
+      geometry ._attrib   = this ._attrib;
+      geometry ._fogCoord = this ._fogCoord;
+      geometry ._color    = this ._color;
+      geometry ._tangent  = this ._tangent;
+      geometry ._normal   = this ._normal;
+      geometry ._coord    = this ._coord;
+
+      let index = 0;
+
+      for (const length of this ._vertexCount)
+      {
+         if (length < 2)
+            continue;
+
+         for (let i = 0; i < length; ++ i, ++ index)
+            geometry ._coordIndex .push (index);
+
+         geometry ._coordIndex .push (-1);
+      }
+
+      geometry .setup ();
+
+      return geometry;
+   },
+});

package/src/Components/Rendering/X3DComposedGeometryNode.js

@@ -0,0 +1,44 @@
+const X3D = require ("../../X3D");
+
+Object .assign (X3D .X3DComposedGeometryNode .prototype,
+{
+   toPrimitive (executionContext = this .getExecutionContext)
+   {
+      const geometry = executionContext .createNode ("IndexedFaceSet", false);
+
+      geometry ._metadata        = this ._metadata;
+      geometry ._solid           = this ._solid;
+      geometry ._ccw             = this ._ccw;
+      geometry ._creaseAngle     = Math .PI;
+      geometry ._colorPerVertex  = this ._colorPerVertex;
+      geometry ._normalPerVertex = this ._normalPerVertex;
+
+      geometry ._attrib   = this ._attrib;
+      geometry ._fogCoord = this ._fogCoord;
+      geometry ._color    = this ._color;
+      geometry ._tangent  = this ._tangent;
+      geometry ._normal   = this ._normal;
+      geometry ._coord    = this ._coord;
+
+      let
+         verticesPerPolygon = this .getVerticesPerPolygon (),
+         numVertices        = this .getNumVertices ();
+
+      // Set size to a multiple of vertexCount.
+      numVertices -= numVertices % verticesPerPolygon;
+
+      for (let i = 0; i < numVertices; ++ i)
+      {
+         const index = this .getPolygonIndex (i);
+
+         geometry ._coordIndex .push (index);
+
+         if (i % verticesPerPolygon === verticesPerPolygon - 1)
+            geometry ._coordIndex .push (-1);
+      }
+
+      geometry .setup ();
+
+      return geometry;
+   },
+});

package/src/Components/Rendering/X3DGeometryNode.js

@@ -0,0 +1,195 @@
+const X3D = require ("../../X3D");
+
+Object .assign (X3D .X3DGeometryNode .prototype,
+{
+   /**
+    * Converts any line geometry to IndexedLineSet.
+    * @param {X3D .X3DExecutionContext} executionContext
+    * @param {object} options
+    * @returns
+    */
+   toIndexedLineSet (executionContext = this .getExecutionContext (), options = { })
+   {
+      const geometry = executionContext .createNode ("IndexedLineSet", false);
+
+      // Coordinate
+
+      const
+         vertexArray = this .getVertices (),
+         numVertices = vertexArray .length;
+
+      geometry ._coord = executionContext .createNode (options .double ? "CoordinateDouble" : "Coordinate", false);
+
+      if (numVertices)
+      {
+         if (options .polyline)
+         {
+            const
+               SFVec3 = options .double ? X3D .SFVec3d : X3D .SFVec3f,
+               first  = new SFVec3 (vertexArray .at (0),  vertexArray .at (1),  0),
+               last   = new SFVec3 (vertexArray .at (-4), vertexArray .at (-3), 0);
+
+            for (let i = 0, length = numVertices / 8; i < length; ++ i)
+               geometry ._coordIndex .push (i);
+
+            if (last .equals (first))
+               geometry ._coordIndex .push (0, -1);
+            else
+               geometry ._coordIndex .push (geometry ._coordIndex .at (-1) + 1, -1);
+
+            for (let i = 0; i < numVertices; i += 8)
+               geometry ._coord .point .push (new SFVec3 (vertexArray [i], vertexArray [i + 1], 0));
+
+            if (!last .equals (first))
+               geometry ._coord .point .push (last);
+         }
+         else
+         {
+            const [coordIndex, points] = this .mergePoints (vertexArray);
+
+            geometry ._coordIndex   = coordIndex .flatMap ((index, i) => i % 2 === 1 ? [index, -1] : index);
+            geometry ._coord .point = points .filter ((point, i) => i % 4 < 3);
+         }
+      }
+
+      // Setup
+
+      geometry ._coord .getValue () ?.setup ();
+      geometry .setup ();
+
+      return geometry;
+   },
+   /**
+    * Converts any polygon geometry to IndexedFaceSet.
+    * @param {X3D .X3DExecutionContext} executionContext
+    * @param {object} options
+    * @returns
+    */
+   toIndexedFaceSet (executionContext = this .getExecutionContext (), options = { })
+   {
+      const geometry = executionContext .createNode ("IndexedFaceSet", false);
+
+      // Coordinate
+
+      const [coordIndex, points] = this .mergePoints (this .getVertices ());
+
+      geometry ._coordIndex   = coordIndex .flatMap ((index, i) => i % 3 === 2 ? [index, -1] : index);
+      geometry ._coord        = executionContext .createNode (options .double ? "CoordinateDouble" : "Coordinate", false);
+      geometry ._coord .point = points .filter ((p, i) => i % 4 < 3);
+
+      // Tangent
+
+      if (options .fogCoord)
+      {
+         geometry ._fogCoord        = executionContext .createNode ("FogCoordinate", false);
+         geometry ._fogCoord .depth = this .getFogDepths ();
+      }
+
+      // Color
+
+      if (options .color)
+      {
+         const [colorIndex, colors] = this .mergePoints (this .getColors ());
+
+         geometry ._colorIndex = colorIndex .flatMap ((index, i) => i % 3 === 2 ? [index, -1] : index);
+
+         if (geometry ._colorIndex .equals (geometry ._coordIndex))
+            geometry ._colorIndex = [ ];
+
+         if (colors .some ((p, i)=> i === 3 && p !== 1))
+         {
+            geometry ._color        = executionContext .createNode ("ColorRGBA", false);
+            geometry ._color .color = colors;
+         }
+         else
+         {
+            geometry ._color        = executionContext .createNode ("Color", false);
+            geometry ._color .color = colors .filter ((p, i) => i % 4 < 3);
+         }
+      }
+
+      // TextureCoordinate
+
+      if (options .texCoord)
+      {
+         const [texCoordIndex, texCoords] = this .mergePoints (this .getTexCoords ());
+
+         geometry ._texCoordIndex = texCoordIndex .flatMap ((index, i) => i % 3 === 2 ? [index, -1] : index);
+
+         if (geometry ._texCoordIndex .equals (geometry ._coordIndex))
+            geometry ._texCoordIndex = [ ];
+
+         if (texCoords .some ((p, i)=> (i === 2 && p !== 0) || (i === 3 && p !== 1)))
+         {
+            geometry ._texCoord        = executionContext .createNode ("TextureCoordinate3D", false);
+            geometry ._texCoord .point = texCoords;
+         }
+         else
+         {
+            geometry ._texCoord        = executionContext .createNode ("TextureCoordinate", false);
+            geometry ._texCoord .point = texCoords .filter ((p, i) => i % 4 < 2);
+         }
+      }
+
+      // Tangent
+
+      if (options .tangent)
+      {
+         // TODO: Implement Tangent
+      }
+
+      // Normal
+
+      if (options .normal)
+      {
+         const [normalIndex, normals] = this .mergePoints (this .getNormals ());
+
+         geometry ._normalIndex   = normalIndex .flatMap ((index, i) => i % 3 === 2 ? [index, -1] : index);
+         geometry ._normal        = executionContext .createNode ("Normal", false);
+         geometry ._normal .point = normals;
+
+         if (geometry ._normalIndex .equals (geometry ._coordIndex))
+            geometry ._normalIndex = [ ];
+      }
+
+      // Setup
+
+      geometry ._fogCoord .getValue () ?.setup ();
+      geometry ._color    .getValue () ?.setup ();
+      geometry ._texCoord .getValue () ?.setup ();
+      geometry ._tangent  .getValue () ?.setup ();
+      geometry ._normal   .getValue () ?.setup ();
+      geometry ._coord    .getValue () ?.setup ();
+      geometry .setup ();
+
+      return geometry;
+   },
+   mergePoints (array)
+   {
+      const
+         index  = [ ],
+         points = [ ],
+         map    = new Map (),
+         length = array .length;
+
+      for (let i = 0; i < length; i += 4)
+      {
+         const key = `${array [i]} ${array [i + 1]} ${array [i + 2]} ${array [i + 3]}`;
+
+         if (map .has (key))
+         {
+            index .push (map .get (key));
+         }
+         else
+         {
+            const next = points .length / 4;
+
+            map .set (key, next);
+            index .push (next);
+            points .push (array [i], array [i + 1], array [i + 2], array [i + 3]);
+         }
+      }
+
+      return [index, points];
+   },
+});

package/src/Components/Text/Text.js

@@ -0,0 +1,17 @@
+const X3D = require ("../../X3D");
+
+Object .assign (X3D .Text .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.js

@@ -0,0 +1,33 @@
+// Geometry2D
+require ("./Components/Geometry2D/Arc2D");
+require ("./Components/Geometry2D/ArcClose2D");
+require ("./Components/Geometry2D/Circle2D");
+require ("./Components/Geometry2D/Disk2D");
+require ("./Components/Geometry2D/Polyline2D");
+require ("./Components/Geometry2D/Polypoint2D");
+require ("./Components/Geometry2D/Rectangle2D");
+require ("./Components/Geometry2D/TriangleSet2D");
+
+// Geometry3D
+require ("./Components/Geometry3D/Box");
+require ("./Components/Geometry3D/Cone");
+require ("./Components/Geometry3D/Cylinder");
+require ("./Components/Geometry3D/ElevationGrid");
+require ("./Components/Geometry3D/Extrusion");
+require ("./Components/Geometry3D/IndexedFaceSet");
+require ("./Components/Geometry3D/Sphere");
+
+// NURBS
+require ("./Components/NURBS/NurbsCurve");
+require ("./Components/NURBS/NurbsSweptSurface");
+require ("./Components/NURBS/NurbsSwungSurface");
+require ("./Components/NURBS/X3DNurbsSurfaceGeometryNode");
+
+// Rendering
+require ("./Components/Rendering/IndexedLineSet");
+require ("./Components/Rendering/LineSet");
+require ("./Components/Rendering/X3DComposedGeometryNode");
+require ("./Components/Rendering/X3DGeometryNode");
+
+// Text
+require ("./Components/Text/Text");