sunrize 1.7.44 → 1.7.46

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,28 @@ module .exports = class OutlineEditor extends OutlineRouteGraph
 
                      continue;
                   }
+                  case X3D .X3DConstants .X3DGeometryNode:
+                  {
+                     if (node .toIndexedTriangleSet)
+                     {
+                        menu .push (
+                        {
+                           label: _("Convert Node to IndexedTriangleSet"),
+                           args: ["toIndexedTriangleSet", element .attr ("id"), executionContext .getId (), node .getId ()],
+                        });
+                     }
+
+                     if (node .toPrimitive)
+                     {
+                        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 +458,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 +1082,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 +1716,53 @@ 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)
-                  {
-                     const index = coordIndex [i];
+                  const creaseAngle = X3D .Algorithm .clamp (node ._creaseAngle .getValue (), 0, Math .PI);
 
-                     if (index < 0)
+                  if (Math .abs (creaseAngle - Math .PI) < 0.1)
+                  {
+                     for (const [i, index] of coordIndex .entries ())
                      {
-                        normalIndex .push (-1);
+                        if (index < 0)
+                           continue;
+
+                        vector [index] = normals [i];
                      }
-                     else
+                  }
+                  else
+                  {
+                     const normalIndex = new X3D .MFInt32 ();
+
+                     for (const [i, index] of coordIndex .entries ())
                      {
-                        normalIndex .push (vector .length);
-                        vector .push (normals [i]);
+                        if (index < 0)
+                        {
+                           normalIndex .push (-1);
+                        }
+                        else
+                        {
+                           normalIndex .push (vector .length);
+                           vector .push (normals [i]);
+                        }
                      }
+
+                     Editor .setFieldValue (executionContext, node, node ._normalIndex, normalIndex);
                   }
                }
                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 +1774,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 +1856,124 @@ module .exports = class OutlineEditor extends OutlineRouteGraph
       UndoManager .shared .endUndo ();
    }
 
+   toIndexedTriangleSet (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 .toIndexedTriangleSet (executionContext),
+         index              = parseInt (element .attr ("index"));
+
+      UndoManager .shared .beginUndo (_("Convert Node to IndexedTriangleSet"));
+
+      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);
+   }
+
+   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/Editors/ScriptEditor.js

@@ -174,8 +174,8 @@ module .exports = class ScriptEditor extends Interface
             }
          }
 
-         if (this .monaco)
-            this .monaco .viewState = this .monaco .saveViewState ();
+         if (this .editor)
+            this .editor .viewState = this .editor .saveViewState ();
       }
 
       this .node = node;
@@ -186,12 +186,12 @@ module .exports = class ScriptEditor extends Interface
 
          this .nodeName .renameNodeInput (this .node);
          this .applyButton .show ();
-         this .editor ?.detach ();
+         this .monaco ?.detach ();
 
-         this .editor = editor .element .appendTo (this .verticalSplitterRight);
-         this .monaco = editor .editor;
+         this .monaco = editor .element .appendTo (this .verticalSplitterRight);
+         this .editor = editor .editor;
 
-         this .monaco .restoreViewState (this .monaco .viewState);
+         this .editor .restoreViewState (this .editor .viewState);
 
          this .node ._url       .addFieldCallback (this, this .set_url       .bind (this));
          this .node ._loadState .addFieldCallback (this, this .set_loadState .bind (this, editor .monaco));
@@ -228,10 +228,10 @@ module .exports = class ScriptEditor extends Interface
       {
          this .nodeName .renameNodeInput (null, null);
          this .applyButton .hide ();
-         this .editor ?.detach ();
+         this .monaco ?.detach ();
 
-         this .editor = null;
          this .monaco = null;
+         this .editor = null;
       }
    }
 
@@ -406,6 +406,17 @@ module .exports = class ScriptEditor extends Interface
                editor .onDidFocusEditorWidget (() => this .setDeclarations (monaco));
                editor .onDidBlurEditorWidget (() => this .apply ());
 
+               editor .onKeyDown ((event) =>
+               {
+                  const { keyCode, ctrlKey, metaKey } = event;
+
+                  if (keyCode === 52 && (metaKey || ctrlKey))
+                  {
+                     event .preventDefault ();
+                     this .paste ();
+                  }
+               });
+
                editor .viewState = editor .saveViewState ();
 
                element .on ("mouseenter", () => this .setDeclarations (monaco))
@@ -467,15 +478,15 @@ module .exports = class ScriptEditor extends Interface
          { type: "separator" },
          {
             label: _("Cut"),
-            args: ["execCommand", "cut"],
+            args: ["cutOrCopy", true],
          },
          {
             label: _("Copy"),
-            args: ["execCommand", "copy"],
+            args: ["cutOrCopy", false],
          },
          {
             label: _("Paste"),
-            args: ["execCommand", "paste"],
+            args: ["paste"],
          },
          { type: "separator" },
          {
@@ -489,7 +500,7 @@ module .exports = class ScriptEditor extends Interface
 
    runAction (id)
    {
-      this .monaco .getAction (id) .run ();
+      this .editor .getAction (id) .run ();
    }
 
    debugFindActions (editor = this .editor)
@@ -541,9 +552,60 @@ module .exports = class ScriptEditor extends Interface
       }
    }
 
-   execCommand (command)
+   // execCommand (command)
+   // {
+   //    document .execCommand (command);
+   // }
+
+   cutOrCopy (cut)
+   {
+      this .editor .focus ();
+
+      // Get the current selection in the editor.
+      const selection = this .editor .getSelection ();
+
+      if (!selection || selection .isEmpty ())
+      {
+        navigator .clipboard .writeText ("");
+        return;
+      }
+
+      // Get the text from that selection.
+      const data = this .editor .getModel () ?.getValueInRange (selection);
+
+      // Set the clipboard contents.
+      navigator .clipboard .writeText (data || "");
+
+      if (!cut)
+         return;
+
+      // This is a cut operation, so replace the selection with an empty string.
+      this .editor .executeEdits ("clipboard", [{
+         range: selection,
+         text: "",
+         forceMoveMarkers: true,
+      }]);
+   }
+
+   async paste ()
    {
-      document .execCommand (command);
+      this .editor .focus ();
+
+      // Get the current clipboard contents
+      const text = await navigator .clipboard .readText ();
+
+      // Get the current selection in the editor.
+      const selection = this .editor .getSelection ();
+
+      if (!selection)
+        return;
+
+      // Replace the current contents with the text from the clipboard.
+      this .editor .executeEdits ("clipboard", [{
+        range: selection,
+        text: text,
+        forceMoveMarkers: true,
+      }]);
    }
 
    create ()
@@ -649,11 +711,11 @@ main ()
       if (!this .node)
          return;
 
-      if (!this .monaco)
+      if (!this .editor)
          return;
 
       const
-         string = this .monaco .getModel () .getValue (),
+         string = this .editor .getModel () .getValue (),
          value  = this .node ._url .toSpliced (0, 1, Editor .encodeURI (string));
 
       if (this .node ._url .equals (value))
@@ -666,7 +728,7 @@ main ()
 
    set_url ()
    {
-      this .monaco .getModel () .setValue (Editor .decodeURI (this .node ._url [0]));
+      this .editor .getModel () .setValue (Editor .decodeURI (this .node ._url [0]));
    }
 
    set_loadState (monaco)

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;