sunrize 1.7.44 → 1.7.45

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");

package/src/Editors/OutlineView.js

@@ -2926,7 +2926,7 @@ module .exports = class OutlineView extends Interface
          }
       });
 
-      element .find (".node:not([node-id=NULL])") .each ((i, e) =>
+      element .find (".node:not([node-id=NULL]), .imported-node, .exported-node") .each ((i, e) =>
       {
          const
             child = $(e),
@@ -2975,7 +2975,7 @@ module .exports = class OutlineView extends Interface
       {
          const
             child = $(e),
-            node = this .getNode (child);
+            node  = this .getNode (child);
 
          node .typeName_changed .removeFieldCallback (this .#exportedNodeSymbol);
          node .name_changed     .removeFieldCallback (this .#exportedNodeSymbol);
@@ -2985,7 +2985,7 @@ module .exports = class OutlineView extends Interface
       {
          const
             child = $(e),
-            field   = this .getField (child);
+            field = this .getField (child);
 
          field .removeReferencesCallback (this .#fieldSymbol);
          field .removeRouteCallback (this .#fieldSymbol);

package/src/Tools/Geometry2D/Disk2DTool.js

@@ -19,58 +19,56 @@ class Disk2DTool extends X3DGeometryNodeTool
 
       const toolChildren = new X3D .MFNode ();
 
-      // Transform Tool innerRadius
+      // Transform Tool outerRadius
       {
          const
             groupNode     = this .getToolScene () .createNode ("Group"),
             transformNode = this .getToolScene () .createNode ("Transform"),
             transformTool = await transformNode .getValue () .addTool () .getToolInstance ();
 
-         this .#innerRadiusTransformNode = transformNode;
+         this .#outerRadiusTransformNode = transformNode;
 
-         transformNode .scale .addInterest ("set_innerRadiusScale", this);
+         transformNode .scale .addInterest ("set_outerRadiusScale", this);
          transformTool .getField ("isActive") .addInterest ("handleUndo", this);
-         transformTool .getField ("isActive") .addInterest ("set_innerRadiusActive", this);
+         transformTool .getField ("isActive") .addInterest ("set_outerRadiusActive", this);
 
          groupNode     .bboxSize      = new X3D .Vector3 (2, 2, 0);
          transformNode .children      = [groupNode];
-         transformTool .group         = `${this .getTypeName ()}.innerRadius`;
+         transformTool .group         = `${this .getTypeName ()}.outerRadius`;
          transformTool .undo          = false;
          transformTool .tools         = ["SCALE"];
          transformTool .keys          = [ ];
          transformTool .connectedAxes = ["XY", "YX", "ZX"];
          transformTool .centerDisplay = false;
          transformTool .centerTool    = false;
-         transformTool .xAxisDisplay  = false;
-         transformTool .yAxisDisplay  = false;
          transformTool .zAxisDisplay  = false;
          transformTool .bboxColor     = ToolColors .BLUE;
 
          toolChildren .push (transformNode);
 
-         // Connections innerRadius
+         // Connections outerRadius
 
-         this .node ._innerRadius .addInterest ("set_innerRadius", this);
+         this .node ._outerRadius .addInterest ("set_outerRadius", this);
 
-         this .set_innerRadius (this .node ._innerRadius);
+         this .set_outerRadius (this .node ._outerRadius);
       }
 
-      // Transform Tool outerRadius
+      // Transform Tool innerRadius
       {
          const
             groupNode     = this .getToolScene () .createNode ("Group"),
             transformNode = this .getToolScene () .createNode ("Transform"),
             transformTool = await transformNode .getValue () .addTool () .getToolInstance ();
 
-         this .#outerRadiusTransformNode = transformNode;
+         this .#innerRadiusTransformNode = transformNode;
 
-         transformNode .scale .addInterest ("set_outerRadiusScale", this);
+         transformNode .scale .addInterest ("set_innerRadiusScale", this);
          transformTool .getField ("isActive") .addInterest ("handleUndo", this);
-         transformTool .getField ("isActive") .addInterest ("set_outerRadiusActive", this);
+         transformTool .getField ("isActive") .addInterest ("set_innerRadiusActive", this);
 
          groupNode     .bboxSize      = new X3D .Vector3 (2, 2, 0);
          transformNode .children      = [groupNode];
-         transformTool .group         = `${this .getTypeName ()}.outerRadius`;
+         transformTool .group         = `${this .getTypeName ()}.innerRadius`;
          transformTool .undo          = false;
          transformTool .tools         = ["SCALE"];
          transformTool .keys          = [ ];
@@ -82,11 +80,11 @@ class Disk2DTool extends X3DGeometryNodeTool
 
          toolChildren .push (transformNode);
 
-         // Connections outerRadius
+         // Connections innerRadius
 
-         this .node ._outerRadius .addInterest ("set_outerRadius", this);
+         this .node ._innerRadius .addInterest ("set_innerRadius", this);
 
-         this .set_outerRadius (this .node ._outerRadius);
+         this .set_innerRadius (this .node ._innerRadius);
       }
 
       this .tool .undo        = true;

package/src/Undo/Editor.js

@@ -607,150 +607,6 @@ ${scene .toXMLString ({ html: true, indent: " " .repeat (6) }) .trimEnd () }
       return executionContext === parentContext
    }
 
-   static nodesToRemove = new Map ()
-
-   /**
-    *
-    * @param {X3DExecutionContext} executionContext
-    * @param {Array<X3DNode|SFNode>|MFNode} nodes
-    * @param {UndoManager} undoManager
-    */
-   static removeNodesFromExecutionContextIfNecessary (executionContext, nodes, undoManager = UndoManager .shared)
-   {
-      if (!nodes .length)
-         return;
-
-      if (!this .nodesToRemove .has (executionContext))
-         this .nodesToRemove .set (executionContext, [ ]);
-
-      const nodesToRemove = this .nodesToRemove .get (executionContext);
-
-      for (const node of nodes)
-         nodesToRemove .push (node);
-
-      if (undoManager .defer ("removeNodesFromExecutionContextIfNecessary"))
-         return;
-
-      undoManager .defer ("removeNodesFromExecutionContextIfNecessary", () =>
-      {
-         for (const [executionContext, nodesToRemove] of this .nodesToRemove)
-         {
-            // Add nodes and child nodes.
-
-            const children = new Set ();
-
-            Array .from (Traverse .traverse (nodesToRemove, Traverse .ROOT_NODES | Traverse .PROTO_DECLARATIONS | Traverse .PROTO_DECLARATION_BODY))
-            .filter (object => object instanceof X3D .SFNode)
-            .forEach (node => children .add (node .getValue () .valueOf ()));
-
-            // Remove nodes still in scene graph.
-
-            Array .from (Traverse .traverse (executionContext, Traverse .ROOT_NODES | Traverse .PROTO_DECLARATIONS | Traverse .PROTO_DECLARATION_BODY))
-            .filter (object => object instanceof X3D .SFNode)
-            .forEach (node => children .delete (node .getValue () .valueOf ()));
-
-            if (children .size === 0)
-               continue;
-
-            undoManager .beginUndo (_("Remove %s Nodes from Execution Context"), children .size);
-
-            for (const node of children)
-            {
-               // Rebind X3DBindableNode nodes.
-
-               if (node .getType () .includes (X3D .X3DConstants .X3DBindableNode))
-               {
-                  if (node ._isBound .getValue ())
-                  {
-                     undoManager .registerUndo (() =>
-                     {
-                        this .setFieldValue (executionContext, node, node ._set_bind, true, undoManager);
-                     });
-                  }
-               }
-
-               // Remove named nodes.
-
-               if (node .getName ())
-                  this .removeNamedNode (executionContext, node, undoManager);
-
-               // Remove routes.
-
-               this .deleteRoutes (executionContext, node, undoManager);
-
-               // Remove imported nodes if node is an Inline node.
-
-               for (const importedNode of Array .from (executionContext .getImportedNodes ()))
-               {
-                  if (importedNode .getInlineNode () .valueOf () === node)
-                     this .removeImportedNode (executionContext, importedNode .getImportedName (), undoManager);
-               }
-
-               // Remove exported nodes.
-
-               if (executionContext instanceof X3D .X3DScene)
-               {
-                  for (const exportedNode of Array .from (executionContext .getExportedNodes ()))
-                  {
-                     if (exportedNode .getLocalNode () .valueOf () === node)
-                        this .removeExportedNode (executionContext, exportedNode .getExportedName (), undoManager);
-                  }
-               }
-
-               // Clear fields, to get right clone count.
-
-               for (const field of node .getFields ())
-               {
-                  switch (field .getType ())
-                  {
-                     case X3D .X3DConstants .SFNode:
-                     {
-                        this .setFieldValue (executionContext, node, field, null, undoManager);
-                        break;
-                     }
-                     case X3D .X3DConstants .MFNode:
-                     {
-                        this .setFieldValue (executionContext, node, field, new X3D .MFNode (), undoManager);
-                        break;
-                     }
-                  }
-               }
-
-               this .#setLive (node, false, undoManager);
-            }
-
-            this .requestUpdateInstances (executionContext, undoManager);
-
-            undoManager .endUndo ();
-         }
-
-         this .nodesToRemove .clear ();
-      });
-   }
-
-   /**
-    *
-    * @param {X3DBaseNode} node
-    * @param {boolean} value
-    */
-   static #setLive (node, value, undoManager = UndoManager .shared)
-   {
-      node = node .valueOf ();
-
-      const oldValue = node .isLive ();
-
-      undoManager .beginUndo (_("Set live state to »%s«"), value);
-
-      node .setLive (value);
-
-      undoManager .registerUndo (() =>
-      {
-         this .#setLive (node, oldValue, undoManager);
-      });
-
-      undoManager .endUndo ();
-   }
-
    /**
     *
     * @param {X3DScene} scene
@@ -3542,6 +3398,204 @@ ${scene .toXMLString ({ html: true, indent: " " .repeat (6) }) .trimEnd () }
       });
    }
 
+   static #nodesToRemove = new Map ();
+
+   /**
+    *
+    * @param {X3DExecutionContext} executionContext
+    * @param {Array<X3DNode|SFNode>|MFNode} nodes
+    * @param {UndoManager} undoManager
+    */
+   static removeNodesFromExecutionContextIfNecessary (executionContext, nodes, undoManager = UndoManager .shared)
+   {
+      if (!nodes .length)
+         return;
+
+      if (!this .#nodesToRemove .has (executionContext))
+         this .#nodesToRemove .set (executionContext, [ ]);
+
+      const nodesToRemove = this .#nodesToRemove .get (executionContext);
+
+      for (const node of nodes)
+         nodesToRemove .push (node .valueOf ());
+
+      if (undoManager .defer ("removeNodesFromExecutionContextIfNecessary"))
+         return;
+
+      undoManager .defer ("removeNodesFromExecutionContextIfNecessary", () =>
+      {
+         for (const [executionContext, nodesToRemove] of this .#nodesToRemove)
+         {
+            // Add nodes and child nodes.
+
+            const children = new Set ();
+
+            Array .from (Traverse .traverse (nodesToRemove, Traverse .ROOT_NODES | Traverse .PROTO_DECLARATIONS | Traverse .PROTO_DECLARATION_BODY))
+            .filter (object => object instanceof X3D .SFNode)
+            .forEach (node => children .add (node .getValue () .valueOf ()));
+
+            // Remove nodes still in scene graph.
+
+            Array .from (Traverse .traverse (executionContext, Traverse .ROOT_NODES | Traverse .PROTO_DECLARATIONS | Traverse .PROTO_DECLARATION_BODY))
+            .filter (object => object instanceof X3D .SFNode)
+            .forEach (node => children .delete (node .getValue () .valueOf ()));
+
+            if (children .size === 0)
+               continue;
+
+            undoManager .beginUndo (_("Remove %s Nodes from Execution Context"), children .size);
+
+            for (const node of children)
+            {
+               // Rebind X3DBindableNode nodes.
+
+               if (node .getType () .includes (X3D .X3DConstants .X3DBindableNode))
+               {
+                  if (node ._isBound .getValue ())
+                  {
+                     undoManager .registerUndo (() =>
+                     {
+                        this .setFieldValue (executionContext, node, node ._set_bind, true, undoManager);
+                     });
+                  }
+               }
+
+               // Remove named nodes.
+
+               if (node .getName ())
+                  this .removeNamedNode (executionContext, node, undoManager);
+
+               // Remove routes.
+
+               this .deleteRoutes (executionContext, node, undoManager);
+
+               // Remove imported nodes if node is an Inline node.
+
+               for (const importedNode of Array .from (executionContext .getImportedNodes ()))
+               {
+                  if (importedNode .getInlineNode () .valueOf () === node)
+                     this .removeImportedNode (executionContext, importedNode .getImportedName (), undoManager);
+               }
+
+               // Remove exported nodes.
+
+               if (executionContext instanceof X3D .X3DScene)
+               {
+                  for (const exportedNode of Array .from (executionContext .getExportedNodes ()))
+                  {
+                     if (exportedNode .getLocalNode () .valueOf () === node)
+                        this .removeExportedNode (executionContext, exportedNode .getExportedName (), undoManager);
+                  }
+               }
+
+               // Clear fields, to get right clone count.
+
+               for (const field of node .getFields ())
+               {
+                  switch (field .getType ())
+                  {
+                     case X3D .X3DConstants .SFNode:
+                     {
+                        this .setFieldValue (executionContext, node, field, null, undoManager);
+                        break;
+                     }
+                     case X3D .X3DConstants .MFNode:
+                     {
+                        this .setFieldValue (executionContext, node, field, new X3D .MFNode (), undoManager);
+                        break;
+                     }
+                  }
+               }
+
+               this .#setLive (node, false, undoManager);
+               this .#removeSelection (node, undoManager);
+            }
+
+            this .requestUpdateInstances (executionContext, undoManager);
+
+            undoManager .endUndo ();
+         }
+
+         this .#nodesToRemove .clear ();
+      });
+   }
+
+   /**
+    *
+    * @param {X3DBaseNode} node
+    * @param {boolean} value
+    * @param {UndoManager} undoManager
+    */
+   static #setLive (node, value, undoManager = UndoManager .shared)
+   {
+      node = node .valueOf ();
+
+      const oldValue = node .isLive ();
+
+      undoManager .beginUndo (_("Set live state to »%s«"), value);
+
+      node .setLive (value);
+
+      undoManager .registerUndo (() =>
+      {
+         this .#setLive (node, oldValue, undoManager);
+      });
+
+      undoManager .endUndo ();
+   }
+
+   /**
+    *
+    * @param {X3DBaseNode} node
+    * @param {UndoManager} undoManager
+    */
+   static #addSelection (node, undoManager = UndoManager .shared)
+   {
+      node = node .valueOf ();
+
+      const selection = require ("../Application/Selection");
+
+      if (selection .has (node))
+         return;
+
+      undoManager .beginUndo (_("Select node"));
+
+      selection .add (node);
+
+      undoManager .registerUndo (() =>
+      {
+         this .#removeSelection (node, undoManager);
+      });
+
+      undoManager .endUndo ();
+   }
+
+   /**
+    *
+    * @param {X3DBaseNode} node
+    * @param {UndoManager} undoManager
+    */
+   static #removeSelection (node, undoManager = UndoManager .shared)
+   {
+      node = node .valueOf ();
+
+      const selection = require ("../Application/Selection");
+
+      if (!selection .has (node))
+         return;
+
+      undoManager .beginUndo (_("Deselect node"));
+
+      selection .remove (node);
+
+      undoManager .registerUndo (() =>
+      {
+         this .#addSelection (node, undoManager);
+      });
+
+      undoManager .endUndo ();
+   }
+
    /**
     *
     * @param {function} callback