x_ite 8.8.2 → 8.8.4

package/src/x_ite/Browser/X3DBrowser.js

@@ -64,18 +64,22 @@ import XMLParser           from "../Parser/XMLParser.js";
 import JSONParser          from "../Parser/JSONParser.js";
 import X3DCast             from "../Base/X3DCast.js";
 import X3DConstants        from "../Base/X3DConstants.js";
-import Features            from "./Networking/Features.js";
+import Features            from "../Features.js";
 import Algorithm           from "../../standard/Math/Algorithm.js";
 import MapUtilities        from "../../standard/Utility/MapUtilities.js";
 import _                   from "../../locale/gettext.js";
 
 const
-   _DOMIntegration   = Symbol (),
-   _reject           = Symbol (),
-   _fileLoader       = Symbol (),
-   _browserCallbacks = Symbol (),
-   _console          = Symbol (),
-   _processEvents    = Symbol .for ("X_ITE.X3DRoutingContext.processEvents");
+   _DOMIntegration      = Symbol (),
+   _supportedProfiles   = Symbol (),
+   _supportedComponents = Symbol (),
+   _concreteNodes       = Symbol (),
+   _abstractNodes       = Symbol (),
+   _reject              = Symbol (),
+   _fileLoader          = Symbol (),
+   _browserCallbacks    = Symbol (),
+   _console             = Symbol (),
+   _processEvents       = Symbol .for ("X_ITE.X3DRoutingContext.processEvents");
 
 function X3DBrowser (element)
 {
@@ -88,8 +92,12 @@ function X3DBrowser (element)
 
    this .addType (X3DConstants .X3DBrowser);
 
-   this [_browserCallbacks] = new Map ();
-   this [_console]          = document .getElementsByClassName ("x_ite-console");
+   this [_supportedProfiles]   = SupportedProfiles .copy ();
+   this [_supportedComponents] = SupportedComponents .copy ();
+   this [_concreteNodes]       = ConcreteNodes .copy ();
+   this [_abstractNodes]       = AbstractNodes .copy ();
+   this [_browserCallbacks]    = new Map ();
+   this [_console]             = document .getElementsByClassName ("x_ite-console");
 
    this .setup ();
 };
@@ -118,30 +126,30 @@ Object .assign (Object .setPrototypeOf (X3DBrowser .prototype, X3DBrowserContext
       if (!this .getBrowserOption ("Debug"))
          return;
 
-      this .printWelcomeMessage ();
-   },
-   printWelcomeMessage ()
-   {
-      this .print (`Welcome to ${this .name} X3D Browser v${this .version}:\n` +
-                   `   Current Graphics Renderer\n` +
-                   `      Name: ${this .getVendor ()} ${this .getRenderer ()}\n` +
-                   `      WebGL version: ${this .getWebGLVersion ()}\n` +
-                   `      Shading language: ${this .getShadingLanguageVersion ()}\n` +
-                   `   Rendering Properties\n` +
-                   `      Antialiased: ${this .getAntialiased ()}\n` +
-                   `      Max samples: ${this .getMaxSamples ()}\n` +
-                   `      Depth size: ${this .getDepthSize ()} bits\n` +
-                   `      Color depth: ${this .getColorDepth ()} bits\n` +
-                   `      Max clip planes per shape: ${this .getMaxClipPlanes ()}\n` +
-                   `      Max lights per shape: ${this .getMaxLights ()}\n` +
-                   `      Max multi textures per shape: ${this .getMaxTextures ()}\n` +
-                   `      Texture units: ${this .getMaxCombinedTextureUnits ()}\n` +
-                   `      Max texture size: ${this .getMaxTextureSize ()} × ${this .getMaxTextureSize ()} pixels\n` +
-                   `      Texture memory: ${this .getTextureMemory ()}\n` +
-                   `      Max vertex uniform vectors: ${this .getMaxVertexUniformVectors ()}\n` +
-                   `      Max fragment uniform vectors: ${this .getMaxFragmentUniformVectors ()}\n` +
-                   `      Max vertex attribs: ${this .getMaxVertexAttribs ()}\n` +
-                   `      Max varying vectors: ${this .getMaxVaryingVectors ()}\n`);
+      this .print (this .getWelcomeMessage ());
+   },
+   getWelcomeMessage ()
+   {
+      return `Welcome to ${this .name} X3D Browser v${this .version}:\n` +
+             `   Current Graphics Renderer\n` +
+             `      Name: ${this .getVendor ()} ${this .getRenderer ()}\n` +
+             `      WebGL version: ${this .getWebGLVersion ()}\n` +
+             `      Shading language: ${this .getShadingLanguageVersion ()}\n` +
+             `   Rendering Properties\n` +
+             `      Antialiased: ${this .getAntialiased ()}\n` +
+             `      Max samples: ${this .getMaxSamples ()}\n` +
+             `      Depth size: ${this .getDepthSize ()} bits\n` +
+             `      Color depth: ${this .getColorDepth ()} bits\n` +
+             `      Max clip planes per shape: ${this .getMaxClipPlanes ()}\n` +
+             `      Max lights per shape: ${this .getMaxLights ()}\n` +
+             `      Max multi textures per shape: ${this .getMaxTextures ()}\n` +
+             `      Texture units: ${this .getMaxCombinedTextureUnits ()}\n` +
+             `      Max texture size: ${this .getMaxTextureSize ()} × ${this .getMaxTextureSize ()} pixels\n` +
+             `      Texture memory: ${this .getTextureMemory ()}\n` +
+             `      Max vertex uniform vectors: ${this .getMaxVertexUniformVectors ()}\n` +
+             `      Max fragment uniform vectors: ${this .getMaxFragmentUniformVectors ()}\n` +
+             `      Max vertex attribs: ${this .getMaxVertexAttribs ()}\n` +
+             `      Max varying vectors: ${this .getMaxVaryingVectors ()}\n`;
    },
    getName ()
    {
@@ -167,23 +175,44 @@ Object .assign (Object .setPrototypeOf (X3DBrowser .prototype, X3DBrowserContext
    {
       name = String (name);
 
-      const profile = SupportedProfiles .get (name);
+      const profile = this [_supportedProfiles] .get (name);
 
       if (profile)
          return profile;
 
       throw Error (`Profile '${name}' is not supported.`);
    },
+   addSupportedProfile: function (profile)
+   {
+      this [_supportedProfiles] .add (profile .name, profile);
+   },
+   updateSupportedProfile: function (profile)
+   {
+      this [_supportedProfiles] .update (profile .name, profile .name, profile);
+   },
+   removeSupportedProfile (name)
+   {
+      return this [_supportedProfiles] .remove (String (name));
+   },
+   getSupportedProfile (name)
+   {
+      const profile = this [_supportedProfiles] .get (String (name));
+
+      if (profile)
+         return profile;
+
+      throw new Error (`Supported profile '${name}' does not exists.`);
+   },
    getSupportedProfiles ()
    {
-      return SupportedProfiles;
+      return this [_supportedProfiles];
    },
-   getComponent (name, level = 0)
+   getComponent (name, level)
    {
       name   = String (name);
       level |= 0;
 
-      const component = SupportedComponents .get (name);
+      const component = this [_supportedComponents] .get (name);
 
       if (component)
       {
@@ -197,30 +226,60 @@ Object .assign (Object .setPrototypeOf (X3DBrowser .prototype, X3DBrowserContext
 
       throw Error (`Component '${name}' at level '${level}' is not supported.`);
    },
+   addSupportedComponent (component)
+   {
+      this [_supportedComponents] .add (component .name, component);
+   },
+   updateSupportedComponent (component)
+   {
+      this [_supportedComponents] .update (component .name, component .name, component);
+   },
+   removeSupportedComponent (name)
+   {
+      this [_supportedComponents] .remove (String (name));
+   },
+   getSupportedComponent (name)
+   {
+      const component = this [_supportedComponents] .get (String (name));
+
+      if (component)
+         return component;
+
+      throw new Error (`Supported component '${name}' does not exists.`);
+   },
    getSupportedComponents ()
    {
-      return SupportedComponents;
+      return this [_supportedComponents];
    },
-   loadComponents: (function ()
+   loadComponents: (() =>
    {
       function loadComponents (components, seen)
       {
-         return Promise .all (components .map (component => loadComponent (component, seen)))
+         return Promise .all (components .map (component => loadComponent .call (this, component, seen)))
       }
 
       async function loadComponent ({ name, providerUrl, external, dependencies }, seen)
       {
          if (seen .has (name)) return; seen .add (name);
 
-         await loadComponents (dependencies .map (name => SupportedComponents .get (name)), seen);
+         await loadComponents .call (this, dependencies .map (name => this [_supportedComponents] .get (name)), seen);
 
          if (!external)
             return;
 
-         if (Features .NODE_ENV)
-            global .require (global .require ("url") .fileURLToPath (providerUrl))
-         else
-            await import (/* webpackIgnore: true */ providerUrl);
+         switch (Features .ENVIRONMENT)
+         {
+            case "NODE":
+            {
+               global .require (global .require ("url") .fileURLToPath (providerUrl))
+               break;
+            }
+            case "BROWSER":
+            {
+               await import (/* webpackIgnore: true */ providerUrl);
+               break;
+            }
+         }
       }
 
       return function (... args)
@@ -239,52 +298,62 @@ Object .assign (Object .setPrototypeOf (X3DBrowser .prototype, X3DBrowserContext
                component .push (arg);
 
             else if (typeof arg === "string")
-               component .push (SupportedComponents .get (arg))
+               component .push (this [_supportedComponents] .get (arg))
          }
 
          // Load array of component names.
-         return loadComponents (component, new Set ());
+         return loadComponents .call (this, component, new Set ());
       };
    })(),
-   addConcreteNode (typeName, ConcreteNode)
+   addConcreteNode (ConcreteNode)
    {
-      ConcreteNodes .add (String (typeName), ConcreteNode);
+      this [_concreteNodes] .add (ConcreteNode .typeName, ConcreteNode);
    },
-   updateConcreteNode (typeName, ConcreteNode)
+   updateConcreteNode (ConcreteNode)
    {
-      ConcreteNodes .update (String (typeName), String (typeName), ConcreteNode);
+      this [_concreteNodes] .update (ConcreteNode .typeName, ConcreteNode .typeName, ConcreteNode);
    },
    removeConcreteNode (typeName)
    {
-      ConcreteNodes .remove (String (typeName));
+      this [_concreteNodes] .remove (String (typeName));
    },
    getConcreteNode (typeName)
    {
-      return ConcreteNodes .get (String (typeName));
+      const concreteNode = this [_concreteNodes] .get (String (typeName));
+
+      if (concreteNode)
+         return concreteNode;
+
+      throw new Error (`Concrete node '${typeName}' does not exists.`);
    },
    getConcreteNodes ()
    {
-      return ConcreteNodes;
+      return this [_concreteNodes];
    },
-   addAbstractNode (typeName, AbstractNode)
+   addAbstractNode (AbstractNode)
    {
-      AbstractNodes .add (String (typeName), AbstractNode);
+      this [_abstractNodes] .add (AbstractNode .typeName, AbstractNode);
    },
-   updateAbstractNode (typeName, AbstractNode)
+   updateAbstractNode (AbstractNode)
    {
-      AbstractNodes .update (String (typeName), String (typeName), AbstractNode);
+      this [_abstractNodes] .update (AbstractNode .typeName, AbstractNode .typeName, AbstractNode);
    },
    removeAbstractNode (typeName)
    {
-      AbstractNodes .remove (String (typeName));
+      this [_abstractNodes] .remove (String (typeName));
    },
    getAbstractNode (typeName)
    {
-      return AbstractNodes .get (String (typeName));
+      const abstractNode = this [_abstractNodes] .get (String (typeName));
+
+      if (abstractNode)
+         return abstractNode;
+
+      throw new Error (`Abstract node '${typeName}' does not exists.`);
    },
    getAbstractNodes ()
    {
-      return AbstractNodes;
+      return this [_abstractNodes];
    },
    createScene (profile, ... components)
    {
@@ -609,7 +678,7 @@ Object .assign (Object .setPrototypeOf (X3DBrowser .prototype, X3DBrowserContext
    {
       return this [_browserCallbacks];
    },
-   callBrowserCallbacks: (function ()
+   callBrowserCallbacks: (() =>
    {
       const browserCallbacks = [ ];
 
@@ -867,7 +936,7 @@ Object .assign (Object .setPrototypeOf (X3DBrowser .prototype, X3DBrowserContext
    },
 });
 
-for (const key of Reflect .ownKeys (X3DBrowser .prototype))
+for (const key of Object .keys (X3DBrowser .prototype))
    Object .defineProperty (X3DBrowser .prototype, key, { enumerable: false });
 
 Object .defineProperties (X3DBrowser .prototype,
@@ -914,22 +983,34 @@ Object .defineProperties (X3DBrowser .prototype,
    },
    supportedProfiles:
    {
-      value: SupportedProfiles,
+      get ()
+      {
+         return this [_supportedProfiles];
+      },
       enumerable: true,
    },
    supportedComponents:
    {
-      value: SupportedComponents,
+      get ()
+      {
+         return this [_supportedComponents];
+      },
       enumerable: true,
    },
    concreteNodes:
    {
-      value: ConcreteNodes,
+      get ()
+      {
+         return this [_concreteNodes];
+      },
       enumerable: true,
    },
    abstractNodes:
    {
-      value: AbstractNodes,
+      get ()
+      {
+         return this [_abstractNodes];
+      },
       enumerable: true,
    },
 });

package/src/x_ite/Browser/X3DBrowserContext.js

@@ -65,9 +65,12 @@ import X3DSoundContext                from "./Sound/X3DSoundContext.js";
 import X3DTexturingContext            from "./Texturing/X3DTexturingContext.js";
 import X3DTimeContext                 from "./Time/X3DTimeContext.js";
 import X3DRoutingContext              from "../Routing/X3DRoutingContext.js";
+import AbstractNodes                  from "../Configuration/AbstractNodes.js"
+import ConcreteNodes                  from "../Configuration/ConcreteNodes.js"
 import X3DWorld                       from "../Execution/X3DWorld.js";
 import TraverseType                   from "../Rendering/TraverseType.js";
 import StopWatch                      from "../../standard/Time/StopWatch.js";
+import DEVELOPMENT                    from "../DEVELOPMENT.js";
 
 const
    _world           = Symbol (),
@@ -367,37 +370,70 @@ Object .assign (Object .setPrototypeOf (X3DBrowserContext .prototype, X3DBaseNod
    },
 });
 
-for (const key of Reflect .ownKeys (X3DBrowserContext .prototype))
+for (const key of Object .keys (X3DBrowserContext .prototype))
    Object .defineProperty (X3DBrowserContext .prototype, key, { enumerable: false });
 
 Object .assign (X3DBrowserContext,
 {
-   addBrowserContext (browserContext)
+   addComponent ({ name, concreteNodes, abstractNodes, browserContext, external })
    {
-      browserContexts .push (browserContext);
+      if (concreteNodes)
+      {
+         for (const ConcreteNode of concreteNodes)
+            ConcreteNodes .add (ConcreteNode .typeName, ConcreteNode);
+      }
 
-      const keys = Object .keys (browserContext .prototype)
-         .filter (k => !k .match (/^(initialize|dispose)$/))
-         .concat (Object .getOwnPropertySymbols (browserContext .prototype));
+      if (abstractNodes)
+      {
+         for (const AbstractNode of abstractNodes)
+            AbstractNodes .add (AbstractNode .typeName, AbstractNode);
+      }
 
-      for (const key of keys)
+      if (browserContext)
       {
-         Object .defineProperty (X3DBrowserContext .prototype, key,
+         browserContexts .push (browserContext);
+
+         const keys = Object .keys (browserContext .prototype)
+            .filter (k => !k .match (/^(?:initialize|dispose)$/))
+            .concat (Object .getOwnPropertySymbols (browserContext .prototype));
+
+         for (const key of keys)
          {
-            value: browserContext .prototype [key],
-            writable: true,
-         });
+            Object .defineProperty (X3DBrowserContext .prototype, key,
+            {
+               value: browserContext .prototype [key],
+               writable: true,
+            });
+         }
       }
 
       for (const browser of browsers)
       {
-         browserContext .call (browser);
-         browserContext .prototype .initialize ?.call (browser);
+         if (concreteNodes)
+         {
+            for (const ConcreteNode of concreteNodes)
+               browser .addConcreteNode (ConcreteNode);
+         }
+
+         if (abstractNodes)
+         {
+            for (const AbstractNode of abstractNodes)
+               browser .addAbstractNode (AbstractNode);
+         }
 
-         // Process events from context creation. This will setup nodes like
-         // geometry option nodes before any node is created.
-         browser [_processEvents] ();
+         if (browserContext)
+         {
+            browserContext .call (browser);
+            browserContext .prototype .initialize ?.call (browser);
+
+            // Process events from context creation. This will setup nodes like
+            // geometry option nodes before any node is created.
+            browser [_processEvents] ();
+         }
       }
+
+      if (external && DEVELOPMENT)
+         console .info (`Done loading external component '${name}'.`);
    },
 });
 

package/src/x_ite/Components/Core/X3DNode.js

@@ -48,13 +48,16 @@
 import Fields       from "../../Fields.js";
 import X3DBaseNode  from "../../Base/X3DBaseNode.js";
 import X3DConstants from "../../Base/X3DConstants.js";
-import SFNodeCache  from "../../Fields/SFNodeCache.js";
+
+const _private = Symbol ()
 
 function X3DNode (executionContext)
 {
    X3DBaseNode .call (this, executionContext);
 
    this .addType (X3DConstants .X3DNode);
+
+   this [_private] = false;
 }
 
 Object .assign (Object .setPrototypeOf (X3DNode .prototype, X3DBaseNode .prototype),
@@ -219,6 +222,22 @@ Object .assign (Object .setPrototypeOf (X3DNode .prototype, X3DBaseNode .prototy
 
       return false;
    },
+   isPrivate ()
+   {
+      return this [_private];
+   },
+   setPrivate (value)
+   {
+      this [_private] = value;
+   },
+   getCloneCount ()
+   {
+      return X3DBaseNode .prototype .collectCloneCount .call (this);
+   },
+   collectCloneCount ()
+   {
+      return this .isPrivate () ? 0 : 1;
+   },
    getSourceText ()
    {
       return null;
@@ -1354,7 +1373,7 @@ Object .assign (Object .setPrototypeOf (X3DNode .prototype, X3DBaseNode .prototy
    },
 });
 
-for (const key of Reflect .ownKeys (X3DNode .prototype))
+for (const key of Object .keys (X3DNode .prototype))
    Object .defineProperty (X3DNode .prototype, key, { enumerable: false });
 
 Object .defineProperties (X3DNode,

package/src/x_ite/Components/Core/X3DPrototypeInstance.js

@@ -88,22 +88,29 @@ Object .assign (Object .setPrototypeOf (X3DPrototypeInstance .prototype, X3DNode
    {
       this [_body] ?.dispose ();
 
-      const proto = this [_protoNode] .getProtoDeclaration ();
+      const protoNode = this [_protoNode];
 
-      if (!proto)
+      if (protoNode .isExternProto)
       {
-         this [_body] = new X3DExecutionContext (this .getExecutionContext (), this);
-         this [_body] .setup ();
+         if (protoNode .checkLoadState () !== X3DConstants .COMPLETE_STATE)
+         {
+            this [_body] = null;
 
-         if (this .isInitialized ())
-            X3DChildObject .prototype .addEvent .call (this);
+            if (this .isInitialized ())
+               X3DChildObject .prototype .addEvent .call (this);
+
+            protoNode ._updateInstances .addInterest ("construct", this);
+            protoNode .requestImmediateLoad () .catch (Function .prototype);
 
-         return;
+            return;
+         }
       }
 
-      // If there is a proto the externproto is completely loaded.
+      const proto = protoNode .getProtoDeclaration ();
+
+      // If there is a proto, the externproto is completely loaded.
 
-      if (this [_protoNode] .isExternProto)
+      if (protoNode .isExternProto)
       {
          for (const protoField of proto .getUserDefinedFields ())
          {
@@ -162,8 +169,8 @@ Object .assign (Object .setPrototypeOf (X3DPrototypeInstance .prototype, X3DNode
       if (this .isInitialized ())
          X3DChildObject .prototype .addEvent .call (this);
 
-      this [_protoNode] ._updateInstances .removeInterest ("construct", this);
-      this [_protoNode] ._updateInstances .addInterest ("update", this);
+      protoNode ._updateInstances .removeInterest ("construct", this);
+      protoNode ._updateInstances .addInterest ("update", this);
    },
    update ()
    {
@@ -206,9 +213,6 @@ Object .assign (Object .setPrototypeOf (X3DPrototypeInstance .prototype, X3DNode
 
          this .getPredefinedFields () .update (newField .getName (), newField .getName (), oldField);
 
-         if (!this .isPrivate ())
-            oldField .addCloneCount (1);
-
          oldFields .delete (oldFieldName);
          newField .dispose ();
       }
@@ -232,9 +236,11 @@ Object .assign (Object .setPrototypeOf (X3DPrototypeInstance .prototype, X3DNode
    {
       // Disconnect old proto node.
 
-      this [_protoNode] ._name_changed .removeFieldInterest (this ._typeName_changed);
-      this [_protoNode] ._updateInstances .removeInterest ("construct", this);
-      this [_protoNode] ._updateInstances .removeInterest ("update",    this);
+      const oldProtoNode = this [_protoNode];
+
+      oldProtoNode ._name_changed .removeFieldInterest (this ._typeName_changed);
+      oldProtoNode ._updateInstances .removeInterest ("construct", this);
+      oldProtoNode ._updateInstances .removeInterest ("update",    this);
 
       // Get fields from new proto node.
 
@@ -243,22 +249,7 @@ Object .assign (Object .setPrototypeOf (X3DPrototypeInstance .prototype, X3DNode
 
       protoNode ._name_changed .addFieldInterest (this ._typeName_changed);
 
-      if (protoNode .isExternProto)
-      {
-         if (this [_protoNode] .checkLoadState () === X3DConstants .COMPLETE_STATE)
-         {
-            this .construct ();
-         }
-         else
-         {
-            protoNode ._updateInstances .addInterest ("construct", this);
-            protoNode .requestImmediateLoad () .catch (Function .prototype);
-         }
-      }
-      else
-      {
-         this .construct ();
-      }
+      this .construct ();
    },
    getBody ()
    {
@@ -266,14 +257,17 @@ Object .assign (Object .setPrototypeOf (X3DPrototypeInstance .prototype, X3DNode
    },
    getInnerNode ()
    {
-      const rootNodes = this [_body] .getRootNodes ();
-
-      if (rootNodes .length)
+      if (this [_body])
       {
-         const rootNode = rootNodes [0];
+         const rootNodes = this [_body] .getRootNodes ();
 
-         if (rootNode)
-            return rootNode .getValue () .getInnerNode ();
+         if (rootNodes .length)
+         {
+            const rootNode = rootNodes [0];
+
+            if (rootNode)
+               return rootNode .getValue () .getInnerNode ();
+         }
       }
 
       throw new Error ("Root node not available.");
@@ -979,9 +973,11 @@ Object .assign (Object .setPrototypeOf (X3DPrototypeInstance .prototype, X3DNode
    },
    dispose ()
    {
-      this [_protoNode] ._name_changed .removeFieldInterest (this ._typeName_changed);
-      this [_protoNode] ._updateInstances .removeInterest ("construct", this);
-      this [_protoNode] ._updateInstances .removeInterest ("update",    this);
+      const protoNode = this [_protoNode];
+
+      protoNode ._name_changed .removeFieldInterest (this ._typeName_changed);
+      protoNode ._updateInstances .removeInterest ("construct", this);
+      protoNode ._updateInstances .removeInterest ("update",    this);
 
       this [_body] ?.dispose ();
 

package/src/x_ite/Components/CubeMapTexturing/GeneratedCubeMapTexture.js

@@ -137,7 +137,7 @@ Object .assign (Object .setPrototypeOf (GeneratedCubeMapTexture .prototype, X3DE
 
       this .modelMatrix .assign (renderObject .getModelViewMatrix () .get ()) .multRight (renderObject .getCameraSpaceMatrix () .get ());
    },
-   renderTexture: (function ()
+   renderTexture: (() =>
    {
       // Rotations to negated normals of the texture cube.
 
@@ -243,7 +243,7 @@ Object .assign (Object .setPrototypeOf (GeneratedCubeMapTexture .prototype, X3DE
             this ._update = "NONE";
       };
    })(),
-   setShaderUniforms: (function ()
+   setShaderUniforms: (() =>
    {
       const zeros = new Float32Array (16); // Trick: zero model view matrix to hide object.
 

package/src/x_ite/Components/CubeMapTexturing/X3DEnvironmentTextureNode.js

@@ -86,7 +86,7 @@ Object .assign (Object .setPrototypeOf (X3DEnvironmentTextureNode .prototype, X3
    {
       return this .targets;
    },
-   clearTexture: (function ()
+   clearTexture: (() =>
    {
       const defaultData = new Uint8Array ([ 255, 255, 255, 255 ]);