sunrize 1.5.13 → 1.6.0

package/src/Tools/Core/X3DNodeTool.js

@@ -17,9 +17,17 @@ class X3DNodeTool extends X3DBaseTool
 {
    static createOnSelection = true;
    static createOnDemand    = true;
+   static tools             = new Set (); // Set of all X3DNodeTool tools.
+
+   static #gridNode = null;
+   static get gridNode () { return X3DNodeTool .#gridNode; }
+   static set gridNode (value) { X3DNodeTool .#gridNode = value; }
+
+   static #snapTarget = false;
+   static get snapTarget () { return X3DNodeTool .#snapTarget; }
+   static set snapTarget (value) { X3DNodeTool .#snapTarget = value; }
 
    static #scenes  = new Map (); // Loaded tool proto scenes.
-   static tools    = new Set (); // Set of all this tools.
    static #sensors = [ ];        // Always empty
 
    tool           = null;
@@ -140,6 +148,7 @@ class X3DNodeTool extends X3DBaseTool
             {
                const scene = await this .getBrowser () .createX3DFromURL (new X3D .MFString (protoURL));
 
+               scene .setExecutionContext (scene);
                scene .setLive (true);
 
                for (const externproto of scene .externprotos)
@@ -239,13 +248,15 @@ class X3DNodeTool extends X3DBaseTool
 
    handleUndo (active)
    {
+      // This function is also called in OutlineEditor beginUndoSetFieldValue and endUndoSetFieldValue.
+
       if (!this .tool .undo)
          return;
 
       if (active .getValue ())
          this .prepareUndo ();
       else
-         requestAnimationFrame (() => this .finishUndo ());
+         this .finishUndo ();
    }
 
    prepareUndo ()
@@ -360,18 +371,64 @@ class X3DNodeTool extends X3DBaseTool
    undoSaveInitialValues (fields)
    {
       for (const name of fields)
-         this .#initialValues .set (name, this .getField (name) .copy ());
+      {
+         try
+         {
+            this .#initialValues .set (name, this .getField (name) .copy ());
+         }
+         catch
+         {
+            this .#initialValues .set (name, this .tool .getField (name) .copy ());
+         }
+      }
    }
 
    undoSetValues ()
    {
       for (const [name, initialValue] of this .#initialValues)
       {
-         const value = this .getField (name) .copy ();
+         try
+         {
+            const value = this .getField (name) .copy ();
 
-         this .getField (name) .assign (initialValue);
+            switch (value .getType ())
+            {
+               case X3D .X3DConstants .SFRotation:
+               case X3D .X3DConstants .SFVec2d:
+               case X3D .X3DConstants .SFVec2f:
+               case X3D .X3DConstants .SFVec3d:
+               case X3D .X3DConstants .SFVec3f:
+               case X3D .X3DConstants .SFVec4d:
+               case X3D .X3DConstants .SFVec4f:
+                  Editor .roundToIntegerIfAlmostEqual (value);
+                  break;
+            }
 
-         Editor .setFieldValue (this .getExecutionContext (), this .node, this .getField (name), value);
+            this .getField (name) .assign (initialValue);
+
+            Editor .setFieldValue (this .getExecutionContext (), this .node, this .getField (name), value);
+         }
+         catch
+         {
+            const value = this .tool .getField (name) .copy ();
+
+            switch (value .getType ())
+            {
+               case X3D .X3DConstants .SFRotation:
+               case X3D .X3DConstants .SFVec2d:
+               case X3D .X3DConstants .SFVec2f:
+               case X3D .X3DConstants .SFVec3d:
+               case X3D .X3DConstants .SFVec3f:
+               case X3D .X3DConstants .SFVec4d:
+               case X3D .X3DConstants .SFVec4f:
+                  Editor .roundToIntegerIfAlmostEqual (value);
+                  break;
+            }
+
+            this .setMetaData (`${this .getTypeName ()}/${name}`, initialValue);
+
+            Editor .setNodeMetaData (this .node, `${this .getTypeName ()}/${name}`, value);
+         }
       }
 
       this .#initialValues .clear ();
@@ -389,13 +446,10 @@ class X3DNodeTool extends X3DBaseTool
       {
          case X3D .TraverseType .POINTER:
          {
-            if ($("#secondary-toolbar .hand") .hasClass ("active"))
-               return;
+            if (this .toolPointingEnabled)
+               break;
 
-            if (!this .toolPointingEnabled)
-               return;
-
-            break;
+            return;
          }
       }
 

package/src/Tools/Grids/AngleGridTool.js

@@ -6,11 +6,6 @@ const
 
 class AngleGridTool extends X3DGridNodeTool
 {
-   constructor (executionContext)
-   {
-      super (executionContext);
-   }
-
    async initializeTool ()
    {
       await super .initializeTool (__dirname, "AngleGridTool.x3d");

package/src/Tools/Grids/AngleGridTool.x3d

@@ -63,6 +63,7 @@
     </ProtoDeclare>
     <ProtoDeclare name='AngleGridTool'>
       <ProtoInterface>
+        <field accessType='inputOutput' type='SFBool' name='visible'/>
         <field accessType='inputOutput' type='SFVec3f' name='translation'/>
         <field accessType='inputOutput' type='SFRotation' name='rotation'/>
         <field accessType='inputOutput' type='SFVec3f' name='scale' value='1 1 1'/>

package/src/Tools/Grids/AxonometricGrid.x3d

@@ -222,14 +222,14 @@ function generateGridAxis (axis, hexagon, major, grid, coordIndex, p)
          p2  = c .lerp (d, t)
          add = major / (4 * p1 .distance (p2));
 
-		point [p]     = p1 .lerp (p2, 0 - add);
-		point [p + 1] = p1 .lerp (p2, 1 + add);
+      point [p]     = p1 .lerp (p2, 0 - add);
+      point [p + 1] = p1 .lerp (p2, 1 + add);
 
       coordIndex [coordIndex .length] = p;
-		coordIndex [coordIndex .length] = p + 1;
-		coordIndex [coordIndex .length] = -1;
+      coordIndex [coordIndex .length] = p + 1;
+      coordIndex [coordIndex .length] = -1;
 
-		p += 2;
+      p += 2;
    }
 
    return p;

package/src/Tools/Grids/AxonometricGridTool.js

@@ -7,11 +7,6 @@ const
 
 class AxonometricGridTool extends X3DGridNodeTool
 {
-   constructor (executionContext)
-   {
-      super (executionContext);
-   }
-
    async initializeTool ()
    {
       await super .initializeTool (__dirname, "AxonometricGridTool.x3d");

package/src/Tools/Grids/AxonometricGridTool.x3d

@@ -65,6 +65,7 @@
     </ProtoDeclare>
     <ProtoDeclare name='AxonometricGridTool'>
       <ProtoInterface>
+        <field accessType='inputOutput' type='SFBool' name='visible'/>
         <field accessType='inputOutput' type='SFVec3f' name='translation'/>
         <field accessType='inputOutput' type='SFRotation' name='rotation'/>
         <field accessType='inputOutput' type='SFVec3f' name='scale' value='1 1 1'/>

package/src/Tools/Grids/GridTool.js

@@ -6,11 +6,6 @@ const
 
 class GridTool extends X3DGridNodeTool
 {
-   constructor (executionContext)
-   {
-      super (executionContext);
-   }
-
    async initializeTool ()
    {
       await super .initializeTool (__dirname, "GridTool.x3d");

package/src/Tools/Grids/GridTool.x3d

@@ -53,6 +53,7 @@
     </ProtoDeclare>
     <ProtoDeclare name='GridTool'>
       <ProtoInterface>
+        <field accessType='inputOutput' type='SFBool' name='visible'/>
         <field accessType='inputOutput' type='SFVec3f' name='translation'/>
         <field accessType='inputOutput' type='SFRotation' name='rotation'/>
         <field accessType='inputOutput' type='SFVec3f' name='scale' value='1 1 1'/>

package/src/Tools/Grids/X3DGridNodeTool.js

@@ -3,30 +3,44 @@
 const
    X3DActiveLayerNodeTool = require ("../Layering/X3DActiveLayerNodeTool"),
    X3D                    = require ("../../X3D"),
-   ActionKeys             = require ("../../Application/ActionKeys");
+   ActionKeys             = require ("../../Application/ActionKeys"),
+   Editor                 = require ("../../Undo/Editor.js"),
+   $                      = require ("jquery");
 
 class X3DGridNodeTool extends X3DActiveLayerNodeTool
 {
    #transformTools = [ ];
-   #events         = Symbol ();
    #changing       = Symbol ();
 
-   constructor (executionContext)
-   {
-      super (executionContext);
-   }
-
    async initializeTool (... args)
    {
       await super .initializeTool (... args);
 
+      this .tool .getField ("visible") .addReference (this ._visible);
       this .tool .getField ("translation") .setUnit ("length");
+
+      for (const field of this .tool .getValue () .getFields ())
+      {
+         if (!field .isInitializable ())
+            continue;
+
+         switch (field .getType ())
+         {
+            case X3D .X3DConstants .SFNode:
+            case X3D .X3DConstants .MFNode:
+               continue;
+         }
+
+         field .addInterest ("saveGrid", this);
+      }
    }
 
    connectTool ()
    {
       super .connectTool ();
 
+      X3DGridNodeTool .gridNode = this;
+
       X3DGridNodeTool .addToolInterest (this, () => this .set_transform_tools ());
 
       this .set_transform_tools ();
@@ -39,13 +53,61 @@ class X3DGridNodeTool extends X3DActiveLayerNodeTool
       super .disconnectTool ();
    }
 
-   set_transform_tools ()
+   configureTool ()
    {
-      for (const transformTool of this .#transformTools)
+      this .restoreGrid ();
+   }
+
+   restoreGrid ()
+   {
+      if (!this .toolLayerNode)
+         return;
+
+      const configNode = Editor .getConfigNode (this .getBrowser ());
+
+      for (const field of this .tool .getValue () .getFields ())
+      {
+         if (!field .isInitializable ())
+            continue;
+
+         switch (field .getType ())
+         {
+            case X3D .X3DConstants .SFNode:
+            case X3D .X3DConstants .MFNode:
+               continue;
+         }
+
+         field .assign (this .tool .getFieldDefinition (field .getName ()) .value);
+
+         configNode ?.getMetaData (`Sunrize/${this .tool .getNodeTypeName ()}/${field .getName ()}`, field);
+      }
+   }
+
+   saveGrid (field)
+   {
+      if (!this .toolLayerNode)
+         return;
+
+      const path = `Sunrize/${this .tool .getNodeTypeName ()}/${field .getName ()}`;
+
+      if (field .equals (this .tool .getFieldDefinition (field .getName ()) .value))
+      {
+         const configNode = Editor .getConfigNode (this .getBrowser ());
+
+         configNode ?.removeMetaData (path);
+      }
+      else
       {
-         transformTool .tool .getField ("isActive") .removeInterest ("set_active",    this);
-         transformTool                              .removeInterest ("set_transform", this);
+         const configNode = Editor .getConfigNode (this .getBrowser (), true);
+
+         configNode .setMetaData (path, field);
       }
+   }
+
+   set_transform_tools ()
+   {
+      for (const transformTool of this .#transformTools)
+         transformTool .removeInterest ("set_transform", this);
 
       this .#transformTools .length = 0;
 
@@ -58,21 +120,10 @@ class X3DGridNodeTool extends X3DActiveLayerNodeTool
       }
 
       for (const transformTool of this .#transformTools)
-      {
-         transformTool .tool .getField ("isActive") .addInterest ("set_active",    this, transformTool);
-         transformTool                              .addInterest ("set_transform", this, transformTool, false);
-      }
+         transformTool .addInterest ("set_transform", this, transformTool);
    }
 
-   set_active (transformTool, active)
-   {
-      if (active .getValue ())
-         transformTool .setUserData (this .#events, false);
-      else
-         this .set_transform (transformTool, transformTool .getUserData (this .#events));
-   }
-
-   set_transform (transformTool, active)
+   set_transform (transformTool)
    {
       if (!this ._visible .getValue ())
          return;
@@ -80,10 +131,13 @@ class X3DGridNodeTool extends X3DActiveLayerNodeTool
       if (ActionKeys .value === (ActionKeys .Shift | ActionKeys .Control))
          return;
 
+      if (X3DGridNodeTool .snapTarget)
+         return;
+
       if (!this .tool .snapping)
          return;
 
-      if (!(active || transformTool .tool .isActive))
+      if (!transformTool .tool .isActive)
          return;
 
       switch (transformTool .tool .activeTool)
@@ -102,46 +156,44 @@ class X3DGridNodeTool extends X3DActiveLayerNodeTool
 
    set_translation (transformTool)
    {
-      transformTool .setUserData (this .#events, true);
-
       if (transformTool .getUserData (this .#changing))
       {
          transformTool .setUserData (this .#changing, false);
          return;
       }
 
-		// The position is transformed to an absolute position and then transformed into the coordinate system of the grid
-		// for easier snapping position calculation.
+      // The position is transformed to an absolute position and then transformed into the coordinate system of the grid
+      // for easier snapping position calculation.
 
-		// Get absolute position.
+      // Get absolute position.
 
-		const absoluteMatrix = transformTool .getCurrentMatrix () .multRight (transformTool .getModelMatrix ());
+      const absoluteMatrix = transformTool .getCurrentMatrix () .multRight (transformTool .getModelMatrix ());
 
-		if (transformTool .tool .keepCenter || !this .tool .snapToCenter)
-		{
-			// snapping to bbox center.
-			var position = transformTool .getSubBBox (new X3D .Box3 ()) .multRight (absoluteMatrix) .center;
-		}
-		else
-		{
-			var position = absoluteMatrix .multVecMatrix (transformTool ._center .getValue () .copy ());
-		}
+      if (transformTool .tool .keepCenter || !this .tool .snapToCenter)
+      {
+         // snapping to bbox center.
+         var position = transformTool .getSubBBox (new X3D .Box3 ()) .multRight (absoluteMatrix) .center;
+      }
+      else
+      {
+         var position = absoluteMatrix .multVecMatrix (transformTool ._center .getValue () .copy ());
+      }
 
-		// Calculate snapping position and apply absolute translation.
+      // Calculate snapping position and apply absolute translation.
 
       const
          gridMatrix    = this .getGridMatrix (),
          invGridMatrix = gridMatrix .copy () .inverse ();
 
-		const
+      const
          snapMatrix    = new X3D .Matrix4 () .set (gridMatrix .multVecMatrix (this .getSnapPosition (invGridMatrix .multVecMatrix (position .copy ()), true)) .subtract (position)),
-		   currentMatrix = absoluteMatrix .multRight (snapMatrix) .multRight (transformTool .getModelMatrix () .copy () .inverse ());
+         currentMatrix = absoluteMatrix .multRight (snapMatrix) .multRight (transformTool .getModelMatrix () .copy () .inverse ());
 
       transformTool .setUserData (this .#changing, true);
 
-		if (transformTool .tool .keepCenter)
+      if (transformTool .tool .keepCenter)
          transformTool .setMatrixKeepCenter (currentMatrix);
-		else
+      else
          transformTool .setMatrixWithCenter (currentMatrix);
    }
 
@@ -153,8 +205,6 @@ class X3DGridNodeTool extends X3DActiveLayerNodeTool
 
    set_rotation (transformTool)
    {
-      transformTool .setUserData (this .#events, true);
-
       if (transformTool .getUserData (this .#changing))
       {
          transformTool .setUserData (this .#changing, false);
@@ -163,17 +213,17 @@ class X3DGridNodeTool extends X3DActiveLayerNodeTool
 
       // Snap rotation to axes.
 
-		const absoluteMatrix = transformTool .getCurrentMatrix () .copy () .multRight (transformTool .getModelMatrix ()); // Matrix after transformation
+      const absoluteMatrix = transformTool .getCurrentMatrix () .copy () .multRight (transformTool .getModelMatrix ()); // Matrix after transformation
 
       const
          index0 = X3DGridNodeTool .#rotationAxes [transformTool .tool .activeHandle], // Index of rotation axis
          index1 = (index0 + 1) % 3,
          index2 = (index0 + 2) % 3;
 
-		const y = [
+      const y = [
          absoluteMatrix .xAxis .copy (),
          absoluteMatrix .yAxis .copy (),
-         absoluteMatrix .zAxis .copy ()
+         absoluteMatrix .zAxis .copy (),
       ]; // Rotation axis, equates to grid normal
 
       const z = [
@@ -182,27 +232,27 @@ class X3DGridNodeTool extends X3DActiveLayerNodeTool
          absoluteMatrix .yAxis .copy (),
       ]; // Axis which snaps, later transformed to grid space
 
-		const gridMatrix = this .getGridMatrix ();
+      const gridMatrix = this .getGridMatrix ();
 
       const
-		   Y         = y [index1] .copy () .cross (y [index2]) .normalize (), // Normal of rotation plane
-		   X         = gridMatrix .yAxis .copy () .cross (Y), // Intersection between both planes
-		   Z         = X .copy () .cross (Y), // Front vector
-		   gridPlane = gridMatrix .submatrix .copy ();
+         Y         = y [index1] .copy () .cross (y [index2]) .normalize (), // Normal of rotation plane
+         X         = gridMatrix .yAxis .copy () .cross (Y), // Intersection between both planes
+         Z         = X .copy () .cross (Y), // Front vector
+         gridPlane = gridMatrix .submatrix .copy ();
 
       let
-		   rotationPlane = new X3D .Matrix3 (X [0], X [1], X [2], Y [0], Y [1], Y [2], Z [0], Z [1], Z [2]),
-		   gridRotation  = this .tool .rotation .getValue () .getMatrix ();
+         rotationPlane = new X3D .Matrix3 (X [0], X [1], X [2], Y [0], Y [1], Y [2], Z [0], Z [1], Z [2]),
+         gridRotation  = this .tool .rotation .getValue () .getMatrix ();
 
-		// If X or Z are near 0 then Y is collinear to the y-axis.
+      // If X or Z are near 0 then Y is collinear to the y-axis.
 
-		if (1 - Math .abs (gridMatrix .yAxis .normalize () .dot (Y)) < 1e-6)
-		{
-			rotationPlane = new X3D .Matrix3 ();
-			gridRotation  = new X3D .Matrix3 ();
-		}
+      if (1 - Math .abs (gridMatrix .yAxis .normalize () .dot (Y)) < 1e-6)
+      {
+         rotationPlane = new X3D .Matrix3 ();
+         gridRotation  = new X3D .Matrix3 ();
+      }
 
-		const
+      const
          vectorToSnap   = z [index0],
          vectorOnGrid   = rotationPlane .copy () .inverse () .multRight (gridRotation) .multRight (gridPlane .copy () .inverse ()) .multVecMatrix (vectorToSnap .copy ()) .normalize (), // Vector inside grid space.
          snapVector     = rotationPlane .multVecMatrix (gridRotation .copy () .inverse () .multVecMatrix (gridPlane .multVecMatrix (this .getSnapPosition (vectorOnGrid .copy (), false)))),
@@ -212,19 +262,19 @@ class X3DGridNodeTool extends X3DActiveLayerNodeTool
             invModelMatrix .multDirMatrix (snapVector .copy ())
          );
 
-		const currentMatrix = new X3D .Matrix4 ()
+      const currentMatrix = new X3D .Matrix4 ()
          .set (transformTool ._translation      .getValue (),
-		         transformTool ._rotation         .getValue () .copy () .multRight (snapRotation),
-		         transformTool ._scale            .getValue (),
-		         transformTool ._scaleOrientation .getValue (),
-		         transformTool ._center           .getValue ());
+               transformTool ._rotation         .getValue () .copy () .multRight (snapRotation),
+               transformTool ._scale            .getValue (),
+               transformTool ._scaleOrientation .getValue (),
+               transformTool ._center           .getValue ());
 
       transformTool .setUserData (this .#changing, true);
 
-		if (transformTool .tool .keepCenter)
-			transformTool .setMatrixKeepCenter (currentMatrix);
-		else
-			transformTool .setMatrixWithCenter (currentMatrix);
+      if (transformTool .tool .keepCenter)
+         transformTool .setMatrixKeepCenter (currentMatrix);
+      else
+         transformTool .setMatrixWithCenter (currentMatrix);
    }
 
    static #scaleHandles = {
@@ -246,28 +296,26 @@ class X3DGridNodeTool extends X3DActiveLayerNodeTool
 
    set_scale (transformTool)
    {
-      transformTool .setUserData (this .#events, true);
-
       if (transformTool .getUserData (this .#changing))
       {
          transformTool .setUserData (this .#changing, false);
          return;
       }
 
-		const handle = X3DGridNodeTool .#scaleHandles [transformTool .tool .activeHandle];
+      const handle = X3DGridNodeTool .#scaleHandles [transformTool .tool .activeHandle];
 
-		// All points are first transformed to grid space, then a snapping position is calculated, and then transformed back to absolute space.
+      // All points are first transformed to grid space, then a snapping position is calculated, and then transformed back to absolute space.
 
-		const currentMatrix = handle < 6
+      const currentMatrix = handle < 6
          ? this .getScaleMatrix (transformTool, handle)
          : this .getUniformScaleMatrix (transformTool, handle - 6);
 
       transformTool .setUserData (this .#changing, true);
 
-		if (transformTool .tool .keepCenter)
-			transformTool .setMatrixKeepCenter (currentMatrix);
-		else
-			transformTool .setMatrixWithCenter (currentMatrix);
+      if (transformTool .tool .keepCenter)
+         transformTool .setMatrixKeepCenter (currentMatrix);
+      else
+         transformTool .setMatrixWithCenter (currentMatrix);
    }
 
    static #axes = [
@@ -482,8 +530,7 @@ class X3DGridNodeTool extends X3DActiveLayerNodeTool
       const tool = this .tool;
 
       return new X3D .Matrix4 ()
-         .set (tool .translation .getValue (), tool .rotation .getValue (), tool .scale .getValue ())
-         .multRight (this .getModelMatrix ());
+         .set (tool .translation .getValue (), tool .rotation .getValue (), tool .scale .getValue ());
    }
 }
 

package/src/Tools/Grouping/X3DTransformNodeTool.js

@@ -79,11 +79,6 @@ class X3DTransformNodeTool extends X3DChildNodeTool
    #initialScaleOrientation;
    #initialCenter;
 
-   prepareUndo ()
-   {
-      super .prepareUndo ();
-   }
-
    beginUndo ()
    {
       if (this .isHidden ())
@@ -92,6 +87,9 @@ class X3DTransformNodeTool extends X3DChildNodeTool
       if (!this ._visible .getValue ())
          return false;
 
+      if (!this .tool .undo)
+         return false;
+
       this .#initialMatrix .assign (this .getCurrentMatrix ());
 
       this .#initialTranslation      = this ._translation      .copy ();
@@ -137,19 +135,19 @@ class X3DTransformNodeTool extends X3DChildNodeTool
 
    transformGroups ()
    {
-      if (!this .tool .isActive)
+      if (this .isHidden ())
          return;
 
-      if (!this .tool .activeTool .match (/^(?:TRANSLATE|ROTATE|SCALE)$/))
+      if (!this ._visible .getValue ())
          return;
 
-      if (this .isHidden ())
+      if (this .tool .group === "NONE")
          return;
 
-      if (!this ._visible .getValue ())
+      if (!this .tool .activeTool .match (/^(?:TRANSLATE|ROTATE|SCALE)$/))
          return;
 
-      if (this .tool .group === "NONE")
+      if (!(this .tool .isActive || this .tool .active))
          return;
 
       const differenceMatrix = this .#initialMatrix .copy ()
@@ -191,21 +189,21 @@ class X3DTransformNodeTool extends X3DChildNodeTool
          scale            = new X3D .Vector3 (1, 1, 1),
          scaleOrientation = new X3D .Rotation4 ();
 
-		matrix .get (translation, rotation, scale, scaleOrientation);
+      matrix .get (translation, rotation, scale, scaleOrientation);
 
-		if (!this .tool .tools .includes ("TRANSLATE"))
-			translation .set (0, 0, 0);
+      if (!this .tool .tools .includes ("TRANSLATE"))
+         translation .set (0, 0, 0);
 
-		if (!this .tool .tools .includes ("ROTATE"))
-			rotation .set (0, 0, 1, 0);
+      if (!this .tool .tools .includes ("ROTATE"))
+         rotation .set (0, 0, 1, 0);
 
-		if (!this .tool .tools .includes ("SCALE"))
+      if (!this .tool .tools .includes ("SCALE"))
       {
-			scale .set (1, 1, 1);
-			scaleOrientation .set (0, 0, 1, 0);
+         scale .set (1, 1, 1);
+         scaleOrientation .set (0, 0, 1, 0);
       }
 
-		matrix .set (translation, rotation, scale, scaleOrientation);
+      matrix .set (translation, rotation, scale, scaleOrientation);
 
       if (keepCenter)
          this .setMatrixKeepCenter (matrix);
@@ -219,9 +217,9 @@ class X3DTransformNodeTool extends X3DChildNodeTool
          .add (this ._translation .getValue ())
          .subtract (matrix .origin);
 
-		matrix .copy () .inverse () .multDirMatrix (center);
+      matrix .copy () .inverse () .multDirMatrix (center);
 
-		this .setMatrixWithCenter (matrix, center);
+      this .setMatrixWithCenter (matrix, center);
    }
 
    setMatrixWithCenter (matrix, center = this ._center .getValue ())