sunrize 1.7.43 → 1.7.45

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;
+   },
+});

package/src/Components/Geometry3D/IndexedFaceSet.js

@@ -0,0 +1,112 @@
+const X3D = require ("../../X3D");
+
+Object .assign (X3D .IndexedFaceSet .prototype,
+{
+   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 ._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;
+   },
+});