sunrize 1.7.43 → 1.7.45

package/src/Components/Rendering/X3DGeometryNode.js

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

package/src/Editors/Library.js

@@ -97,7 +97,9 @@ module .exports = new class Library extends Dialog
 
       this .button ($(button ?? this .buttons .children () [0]));
 
+      this .input .val ("");
       this .input .trigger ("focus");
+      this .filter ();
    }
 
    button (button)

package/src/Editors/LibraryPane.js

@@ -1,6 +1,6 @@
 "use strict";
 
-module .exports = class LibraryPanel
+module .exports = class LibraryPane
 {
    #library;
 
@@ -9,6 +9,11 @@ module .exports = class LibraryPanel
       this .#library = library;
    }
 
+   get config ()
+   {
+      return this .#library .config;
+   }
+
    get browser ()
    {
       return this .#library .browser;

package/src/Editors/NodesLibrary.js

@@ -17,6 +17,14 @@ module .exports = class NodesLibrary extends LibraryPane
 
    open ()
    {
+      // Set default config values.
+
+      this .config .global .setDefaultValues ({
+         recentNodes: [ ],
+      });
+
+      // Clear output.
+
       this .#list ?.remove ();
       this .#list = undefined;
    }
@@ -48,7 +56,32 @@ module .exports = class NodesLibrary extends LibraryPane
          .sort ((a, b) => a .typeName .localeCompare (b .typeName))
          .sort ((a, b) => a .componentInfo .name .localeCompare (b .componentInfo .name));
 
-      // Create list for proto elements
+      // Get recently used elements.
+
+      const recentNodes = this .config .global .recentNodes .map (typeName => this .browser .getConcreteNode (typeName));
+
+      // Create list for recently used elements.
+
+      if (recentNodes .length)
+      {
+         $("<li></li>")
+            .addClass ("component")
+            .attr ("name", "recent")
+            .text ("Recently Used Nodes")
+            .appendTo (this .#list);
+
+         for (const node of recentNodes)
+         {
+            $("<li></li>")
+               .addClass ("node")
+               .text (node .typeName)
+               .attr ("componentName", node .componentInfo .name)
+               .appendTo (this .#list)
+               .on ("dblclick", () => this .createNode (node .typeName, node .componentInfo .name));
+         }
+      }
+
+      // Create list for proto elements.
 
       if (protos .length)
       {
@@ -129,6 +162,13 @@ module .exports = class NodesLibrary extends LibraryPane
 
    async createNode (typeName, componentName)
    {
+      const recentNodes = this .config .global .recentNodes .filter (name => name !== typeName);
+
+      recentNodes .unshift (typeName);
+      recentNodes .splice (10);
+
+      this .config .global .recentNodes = recentNodes;
+
       UndoManager .shared .beginUndo (_("Create Node %s"), typeName);
 
       await Editor .addComponent (this .executionContext, componentName);

package/src/Editors/OutlineEditor.js

@@ -248,7 +248,11 @@ module .exports = class OutlineEditor extends OutlineRouteGraph
                   args: ["addUserDefinedField", element .attr ("id"), executionContext .getId (), node .getId ()],
                },
                { type: "separator" },
-               {
+            ];
+
+            if (node .getType () .includes (X3D .X3DConstants .X3DChildNode))
+            {
+               menu .push ({
                   label: _("Add Parent Group"),
                   submenu: [
                      {
@@ -358,8 +362,8 @@ module .exports = class OutlineEditor extends OutlineRouteGraph
                   enabled: parentNodeElement .hasClass ("node"),
                   args: ["removeParent", element .attr ("id"), executionContext .getId (), node .getId ()],
                },
-               { type: "separator" },
-            ];
+               { type: "separator" });
+            }
 
             for (const type of node .getType () .toReversed ())
             {
@@ -386,6 +390,19 @@ module .exports = class OutlineEditor extends OutlineRouteGraph
 
                      continue;
                   }
+                  case X3D .X3DConstants .X3DGeometryNode:
+                  {
+                     if (!node .toPrimitive)
+                        continue;
+
+                     menu .push (
+                     {
+                        label: _("Convert Node to Next Lower Geometry Type"),
+                        args: ["toPrimitive", element .attr ("id"), executionContext .getId (), node .getId ()],
+                     });
+
+                     continue;
+                  }
                   case X3D .X3DConstants .ImageTexture:
                   {
                      if (node .checkLoadState () === X3D .X3DConstants .COMPLETE_STATE)
@@ -432,6 +449,11 @@ module .exports = class OutlineEditor extends OutlineRouteGraph
                   }
                   case X3D .X3DConstants .X3DPrototypeInstance:
                   {
+                     menu .push ({
+                        label: _("Unwrap Inner Node"),
+                        args: ["unwrapInnerNode", element .attr ("id"), executionContext .getId (), node .getId ()],
+                     });
+
                      if (!$.try (() => node .getInnerNode () .getType () .includes (X3D .X3DConstants .X3DChildNode)))
                         continue;
 
@@ -1051,6 +1073,9 @@ module .exports = class OutlineEditor extends OutlineRouteGraph
       }
 
       UndoManager .shared .endUndo ();
+
+      if (element .hasClass ("selected"))
+         require ("../Application/Selection") .add (primitive);
    }
 
    async addParentGroup (id, executionContextId, nodeId, component, typeName, fieldName)
@@ -1682,39 +1707,29 @@ module .exports = class OutlineEditor extends OutlineRouteGraph
             case X3D .X3DConstants .IndexedFaceSet:
             {
                const
-                  polygons        = node .triangulate (),
                   coordIndex      = node ._coordIndex,
                   normalPerVertex = node ._normalPerVertex .getValue (),
+                  polygons        = node .triangulate (),
                   normals         = node .createNormals (polygons),
-                  normalIndex     = new X3D .MFInt32 (),
                   normalNode      = executionContext .createNode ("Normal") .getValue (),
                   vector          = normalNode ._vector;
 
                if (normalPerVertex)
                {
-                  for (let i = 0, length = coordIndex .length; i < length; ++ i)
+                  for (const [i, index] of coordIndex .entries ())
                   {
-                     const index = coordIndex [i];
-
                      if (index < 0)
-                     {
-                        normalIndex .push (-1);
-                     }
-                     else
-                     {
-                        normalIndex .push (vector .length);
-                        vector .push (normals [i]);
-                     }
+                        continue;
+
+                     vector [index] = normals [i];
                   }
                }
                else
                {
                   let face = 0;
 
-                  for (let i = 0, length = coordIndex .length; i < length; ++ i)
+                  for (const [i, index] of coordIndex .entries ())
                   {
-                     const index = coordIndex [i];
-
                      if (index < 0)
                      {
                         vector .length = ++ face;
@@ -1726,8 +1741,7 @@ module .exports = class OutlineEditor extends OutlineRouteGraph
                   }
                }
 
-               Editor .setFieldValue (executionContext, node, node ._normalIndex, normalIndex);
-               Editor .setFieldValue (executionContext, node, node ._normal,      normalNode);
+               Editor .setFieldValue (executionContext, node, node ._normal, normalNode);
                break;
             }
             case X3D .X3DConstants .X3DComposedGeometryNode:
@@ -1809,6 +1823,85 @@ module .exports = class OutlineEditor extends OutlineRouteGraph
       UndoManager .shared .endUndo ();
    }
 
+   toPrimitive (id, executionContextId, nodeId)
+   {
+      const
+         element            = $(`#${id}`),
+         executionContext   = this .objects .get (executionContextId),
+         parentFieldElement = element .closest (".field, .scene", this .sceneGraph),
+         parentNodeElement  = parentFieldElement .closest (".node, .proto, .scene", this .sceneGraph),
+         parentNode         = this .getNode (parentNodeElement),
+         parentField        = parentFieldElement .hasClass ("scene") ? parentNode .rootNodes : this .getField (parentFieldElement),
+         node               = this .objects .get (nodeId),
+         primitive          = node .toPrimitive (executionContext),
+         index              = parseInt (element .attr ("index"));
+
+      UndoManager .shared .beginUndo (_("Convert Node to Next Lower Primitive"));
+
+      if (node .getName ())
+         Editor .updateNamedNode (executionContext, executionContext .getUniqueName (node .getName ()), primitive);
+
+      switch (parentField .getType ())
+      {
+         case X3D .X3DConstants .SFNode:
+         {
+            Editor .setFieldValue (executionContext, parentNode, parentField, primitive);
+            break;
+         }
+         case X3D .X3DConstants .MFNode:
+         {
+            Editor .removeValueFromArray (executionContext, parentNode, parentField, index);
+            Editor .insertValueIntoArray (executionContext, parentNode, parentField, index, primitive);
+            break;
+         }
+      }
+
+      UndoManager .shared .endUndo ();
+
+      if (element .hasClass ("selected"))
+         require ("../Application/Selection") .add (primitive);
+   }
+
+   async unwrapInnerNode (id, executionContextId, nodeId)
+   {
+      const
+         element            = $(`#${id}`),
+         executionContext   = this .objects .get (executionContextId),
+         parentFieldElement = element .closest (".field, .scene", this .sceneGraph),
+         parentNodeElement  = parentFieldElement .closest (".node, .proto, .scene", this .sceneGraph),
+         parentNode         = this .getNode (parentNodeElement),
+         parentField        = parentFieldElement .hasClass ("scene") ? parentNode .rootNodes : this .getField (parentFieldElement),
+         node               = this .objects .get (nodeId),
+         x3dSyntax          = await Editor .exportX3D (this .executionContext, [node]),
+         importedNodes      = await Editor .importX3D (this .executionContext, x3dSyntax),
+         innerNode          = importedNodes [0],
+         index              = parseInt (element .attr ("index"));
+
+      this .executionContext .rootNodes .length -= importedNodes .length;
+
+      UndoManager .shared .beginUndo (_("Convert Node to Next Lower Primitive"));
+
+      switch (parentField .getType ())
+      {
+         case X3D .X3DConstants .SFNode:
+         {
+            Editor .setFieldValue (executionContext, parentNode, parentField, innerNode);
+            break;
+         }
+         case X3D .X3DConstants .MFNode:
+         {
+            Editor .removeValueFromArray (executionContext, parentNode, parentField, index);
+            Editor .insertValueIntoArray (executionContext, parentNode, parentField, index, innerNode);
+            break;
+         }
+      }
+
+      UndoManager .shared .endUndo ();
+
+      if (element .hasClass ("selected"))
+         require ("../Application/Selection") .add (innerNode);
+   }
+
    addPrototype (id, executionContextId)
    {
       require ("../Controls/AddPrototypePopover");
@@ -1909,7 +2002,7 @@ module .exports = class OutlineEditor extends OutlineRouteGraph
 
       const
          target    = $(event .target),
-         element   = target .closest (".node, .exported-node", this .sceneGraph),
+         element   = target .closest (".node, .imported-node, .exported-node", this .sceneGraph),
          layerNode = this .getNode (element),
          layerSet  = this .browser .getWorld () .getLayerSet (),
          index     = layerSet ._layers .findIndex (node => node ?.getValue () .valueOf () === layerNode);
@@ -1927,7 +2020,7 @@ module .exports = class OutlineEditor extends OutlineRouteGraph
    {
       const
          target  = $(event .target),
-         element = target .closest (".node, .exported-node", this .sceneGraph),
+         element = target .closest (".node, .imported-node, .exported-node", this .sceneGraph),
          node    = this .getNode (element);
 
       event .preventDefault ();
@@ -1952,7 +2045,7 @@ module .exports = class OutlineEditor extends OutlineRouteGraph
    {
       const
          target  = $(event .target),
-         element = target .closest (".node, .exported-node", this .sceneGraph),
+         element = target .closest (".node, .imported-node, .exported-node", this .sceneGraph),
          node    = this .getNode (element);
 
       event .preventDefault ();
@@ -1965,7 +2058,7 @@ module .exports = class OutlineEditor extends OutlineRouteGraph
    {
       const
          target  = $(event .target),
-         element = target .closest (".node, .exported-node", this .sceneGraph),
+         element = target .closest (".node, .imported-node, .exported-node", this .sceneGraph),
          node    = this .getNode (element);
 
       event .preventDefault ();