x_ite 5.0.2 → 6.0.0

package/src/x_ite/Components/ParticleSystems/PointEmitter.js

@@ -70,25 +70,38 @@ function (Fields,
 
       this .addType (X3DConstants .PointEmitter);
 
-      this ._position    .setUnit ("length");
-      this ._speed       .setUnit ("speed");
-      this ._mass        .setUnit ("mass");
-      this ._surfaceArea .setUnit ("area");
+      this ._position .setUnit ("length");
 
-      this .direction = new Vector3 (0, 0, 0);
+      this .addUniform ("position",  "uniform vec3 position;");
+      this .addUniform ("direction", "uniform vec3 direction;");
+
+      this .addFunction (/* glsl */ `vec3 getRandomVelocity ()
+      {
+         if (direction == vec3 (0.0))
+            return getRandomSphericalVelocity ();
+
+         else
+            return direction * getRandomSpeed ();
+      }`);
+
+      this .addFunction (/* glsl */ `vec4 getRandomPosition ()
+      {
+         return vec4 (position, 1.0);
+      }`);
    }
 
    PointEmitter .prototype = Object .assign (Object .create (X3DParticleEmitterNode .prototype),
    {
       constructor: PointEmitter,
       [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new FieldDefinitionArray ([
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",    new Fields .SFNode ()),
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "position",    new Fields .SFVec3f ()),
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "direction",   new Fields .SFVec3f (0, 1, 0)),
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "speed",       new Fields .SFFloat ()),
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "variation",   new Fields .SFFloat (0.25)),
-         new X3DFieldDefinition (X3DConstants .initializeOnly, "mass",        new Fields .SFFloat ()),
-         new X3DFieldDefinition (X3DConstants .initializeOnly, "surfaceArea", new Fields .SFFloat ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "metadata",    new Fields .SFNode ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "on",          new Fields .SFBool (true)),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "position",    new Fields .SFVec3f ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "direction",   new Fields .SFVec3f (0, 1, 0)),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "speed",       new Fields .SFFloat ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "variation",   new Fields .SFFloat (0.25)),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "mass",        new Fields .SFFloat ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "surfaceArea", new Fields .SFFloat ()),
       ]),
       getTypeName: function ()
       {
@@ -106,7 +119,10 @@ function (Fields,
       {
          X3DParticleEmitterNode .prototype .initialize .call (this);
 
-         this ._position  .addInterest ("set_position__", this);
+         if (this .getBrowser () .getContext () .getVersion () < 2)
+            return;
+
+         this ._position  .addInterest ("set_position__",  this);
          this ._direction .addInterest ("set_direction__", this);
 
          this .set_position__ ();
@@ -114,33 +130,21 @@ function (Fields,
       },
       set_position__: function ()
       {
-         this .position = this ._position .getValue ()
-      },
-      set_direction__: function ()
-      {
-         this .direction .assign (this ._direction .getValue ()) .normalize ();
+         const position = this ._position .getValue ();
 
-         if (this .direction .equals (Vector3 .Zero))
-            this .getRandomVelocity = this .getSphericalRandomVelocity;
-         else
-            delete this .getRandomVelocity;
-      },
-      getRandomPosition: function (position)
-      {
-         return position .assign (this .position);
+         this .setUniform ("uniform3f", "position", position .x, position .y, position .z);
       },
-      getRandomVelocity: function (velocity)
+      set_direction__: (function ()
       {
-         var
-            direction = this .direction,
-            speed     = this .getRandomSpeed ();
+         const direction = new Vector3 (0, 0, 0);
 
-         velocity .x = direction .x * speed;
-         velocity .y = direction .y * speed;
-         velocity .z = direction .z * speed;
+         return function ()
+         {
+            direction .assign (this ._direction .getValue ()) .normalize ();
 
-         return velocity;
-       },
+            this .setUniform ("uniform3f", "direction", direction .x, direction .y, direction .z);
+         };
+      })(),
    });
 
    return PointEmitter;

package/src/x_ite/Components/ParticleSystems/PolylineEmitter.js

@@ -55,7 +55,6 @@ define ([
    "x_ite/Components/Rendering/IndexedLineSet",
    "x_ite/Base/X3DConstants",
    "standard/Math/Numbers/Vector3",
-   "standard/Math/Algorithm",
 ],
 function (Fields,
           X3DFieldDefinition,
@@ -63,8 +62,7 @@ function (Fields,
           X3DParticleEmitterNode,
           IndexedLineSet,
           X3DConstants,
-          Vector3,
-          Algorithm)
+          Vector3)
 {
 "use strict";
 
@@ -74,28 +72,69 @@ function (Fields,
 
       this .addType (X3DConstants .PolylineEmitter);
 
-      this ._speed       .setUnit ("speed");
-      this ._mass        .setUnit ("mass");
-      this ._surfaceArea .setUnit ("area");
+      this .polylinesNode  = new IndexedLineSet (executionContext);
+      this .polylinesArray = new Float32Array ();
 
-      this .direction        = new Vector3 (0, 0, 0);
-      this .polylineNode     = new IndexedLineSet (executionContext);
-      this .polylines        = [ ];
-      this .lengthSoFarArray = [ 0 ];
+      this .addSampler ("polylines");
+
+      this .addUniform ("direction",     "uniform vec3 direction;");
+      this .addUniform ("verticesIndex", "uniform int verticesIndex;");
+      this .addUniform ("polylines",     "uniform sampler2D polylines;");
+
+      this .addFunction (/* glsl */ `vec3 getRandomVelocity ()
+      {
+         if (direction == vec3 (0.0))
+            return getRandomSphericalVelocity ();
+
+         else
+            return direction * getRandomSpeed ();
+      }`);
+
+      this .addFunction (/* glsl */ `vec4 getRandomPosition ()
+      {
+         if (verticesIndex < 0)
+         {
+            return vec4 (NaN);
+         }
+         else
+         {
+            // Determine index0, index1 and weight.
+
+            float lastLengthSoFar = texelFetch (polylines, verticesIndex - 1, 0) .x;
+            float fraction        = random () * lastLengthSoFar;
+
+            int   index0 = 0;
+            int   index1 = 0;
+            float weight = 0.0;
+
+            interpolate (polylines, verticesIndex, fraction, index0, index1, weight);
+
+            // Interpolate and return position.
+
+            index0 *= 2;
+            index1  = index0 + 1;
+
+            vec4 vertex0 = texelFetch (polylines, verticesIndex + index0, 0);
+            vec4 vertex1 = texelFetch (polylines, verticesIndex + index1, 0);
+
+            return mix (vertex0, vertex1, weight);
+         }
+      }`);
    }
 
    PolylineEmitter .prototype = Object .assign (Object .create (X3DParticleEmitterNode .prototype),
    {
       constructor: PolylineEmitter,
       [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new FieldDefinitionArray ([
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",    new Fields .SFNode ()),
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "direction",   new Fields .SFVec3f (0, 1, 0)),
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "speed",       new Fields .SFFloat ()),
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "variation",   new Fields .SFFloat (0.25)),
-         new X3DFieldDefinition (X3DConstants .initializeOnly, "mass",        new Fields .SFFloat ()),
-         new X3DFieldDefinition (X3DConstants .initializeOnly, "surfaceArea", new Fields .SFFloat ()),
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "coordIndex",  new Fields .MFInt32 (-1)),
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "coord",       new Fields .SFNode ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "metadata",    new Fields .SFNode ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "on",          new Fields .SFBool (true)),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "direction",   new Fields .SFVec3f (0, 1, 0)),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "speed",       new Fields .SFFloat ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "variation",   new Fields .SFFloat (0.25)),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "mass",        new Fields .SFFloat ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "surfaceArea", new Fields .SFFloat ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "coordIndex",  new Fields .MFInt32 (-1)),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "coord",       new Fields .SFNode ()),
       ]),
       getTypeName: function ()
       {
@@ -113,147 +152,92 @@ function (Fields,
       {
          X3DParticleEmitterNode .prototype .initialize .call (this);
 
+         const browser = this .getBrowser ();
+
+         if (browser .getContext () .getVersion () < 2)
+            return;
+
+         // Create GL stuff.
+
+         this .polylinesTexture = this .createTexture ();
+
+         // Initialize fields.
+
          this ._direction .addInterest ("set_direction__", this);
 
-         this ._coordIndex .addFieldInterest (this .polylineNode ._coordIndex);
-         this ._coord      .addFieldInterest (this .polylineNode ._coord);
+         this ._coordIndex .addFieldInterest (this .polylinesNode ._coordIndex);
+         this ._coord      .addFieldInterest (this .polylinesNode ._coord);
 
-         this .polylineNode ._coordIndex = this ._coordIndex;
-         this .polylineNode ._coord      = this ._coord;
+         this .polylinesNode ._coordIndex = this ._coordIndex;
+         this .polylinesNode ._coord      = this ._coord;
 
-         this .polylineNode ._rebuild .addInterest ("set_polyline", this);
-         this .polylineNode .setPrivate (true);
-         this .polylineNode .setup ();
+         this .polylinesNode ._rebuild .addInterest ("set_polyline", this);
+         this .polylinesNode .setPrivate (true);
+         this .polylinesNode .setup ();
 
          this .set_direction__ ();
          this .set_polyline ();
       },
-      set_direction__: function ()
+      set_direction__: (function ()
       {
-         this .direction .assign (this ._direction .getValue ()) .normalize ();
+         const direction = new Vector3 (0, 0, 0);
 
-         if (this .direction .equals (Vector3 .Zero))
-            this .getRandomVelocity = this .getSphericalRandomVelocity;
-         else
-            delete this .getRandomVelocity;
-      },
+         return function ()
+         {
+            direction .assign (this ._direction .getValue ()) .normalize ();
+
+            this .setUniform ("uniform3f", "direction", direction .x, direction .y, direction .z);
+         };
+      })(),
       set_polyline: (function ()
       {
-         var
+         const
             vertex1 = new Vector3 (0, 0, 0),
             vertex2 = new Vector3 (0, 0, 0);
 
          return function ()
          {
-            var vertices = this .vertices = this .polylineNode .getVertices () .getValue ();
+            const
+               gl                = this .getBrowser () .getContext (),
+               vertices          = this .polylinesNode .getVertices () .getValue (),
+               numVertices       = vertices .length / 4,
+               numLengthSoFar    = numVertices / 2 + 1,
+               polylineArraySize = Math .ceil (Math .sqrt (numLengthSoFar + numVertices));
 
-            if (vertices .length)
-            {
-               delete this .getRandomPosition;
+            const verticesIndex = numLengthSoFar;
 
-               var
-                  lengthSoFar      = 0,
-                  lengthSoFarArray = this .lengthSoFarArray;
+            let polylinesArray = this .polylinesArray;
 
-               lengthSoFarArray .length = 1;
+            if (polylinesArray .length < polylineArraySize * polylineArraySize * 4)
+               polylinesArray = this .polylinesArray = new Float32Array (polylineArraySize * polylineArraySize * 4);
 
-               for (var i = 0, length = vertices .length; i < length; i += 8)
-               {
-                  vertex1 .set (vertices [i],     vertices [i + 1], vertices [i + 2]);
-                  vertex2 .set (vertices [i + 4], vertices [i + 5], vertices [i + 6]);
+            let lengthSoFar = 0;
 
-                  lengthSoFar += vertex2 .subtract (vertex1) .abs ();
-                  lengthSoFarArray .push (lengthSoFar);
-               }
-            }
-            else
+            for (let i = 0, length = vertices .length; i < length; i += 8)
             {
-               this .getRandomPosition = getPosition;
-            }
-         };
-      })(),
-      getRandomPosition: function (position)
-      {
-         // Determine index0 and weight.
+               vertex1 .set (vertices [i],     vertices [i + 1], vertices [i + 2]);
+               vertex2 .set (vertices [i + 4], vertices [i + 5], vertices [i + 6]);
 
-         var
-            lengthSoFarArray = this .lengthSoFarArray,
-            length           = lengthSoFarArray .length,
-            fraction         = Math .random () * lengthSoFarArray .at (-1),
-            index0           = 0,
-            index1           = 0,
-            weight           = 0;
-
-         if (length == 1 || fraction <= lengthSoFarArray [0])
-         {
-            index0 = 0;
-            weight = 0;
-         }
-         else if (fraction >= lengthSoFarArray .at (-1))
-         {
-            index0 = length - 2;
-            weight = 1;
-         }
-         else
-         {
-            var index = Algorithm .upperBound (lengthSoFarArray, 0, length, fraction, Algorithm .less);
+               polylinesArray [i / 2 + 4] = lengthSoFar += vertex2 .subtract (vertex1) .abs ();
+            }
 
-            if (index < length)
-            {
-               index1 = index;
-               index0 = index - 1;
+            polylinesArray .set (vertices, verticesIndex * 4);
 
-               var
-                  key0 = lengthSoFarArray [index0],
-                  key1 = lengthSoFarArray [index1];
+            this .setUniform ("uniform1i", "verticesIndex", numVertices ? verticesIndex : -1);
 
-               weight = Algorithm .clamp ((fraction - key0) / (key1 - key0), 0, 1);
-            }
-            else
+            if (polylineArraySize)
             {
-               index0 = 0;
-               weight = 0;
+               gl .bindTexture (gl .TEXTURE_2D, this .polylinesTexture);
+               gl .texImage2D (gl .TEXTURE_2D, 0, gl .RGBA32F, polylineArraySize, polylineArraySize, 0, gl .RGBA, gl .FLOAT, polylinesArray);
             }
-         }
-
-         // Interpolate and set position.
-
-         index0 *= 8;
-         index1  = index0 + 4;
-
-         var
-            vertices = this .vertices,
-            x1       = vertices [index0],
-            y1       = vertices [index0 + 1],
-            z1       = vertices [index0 + 2],
-            x2       = vertices [index1],
-            y2       = vertices [index1 + 1],
-            z2       = vertices [index1 + 2];
-
-         position .x = x1 + weight * (x2 - x1);
-         position .y = y1 + weight * (y2 - y1);
-         position .z = z1 + weight * (z2 - z1);
-
-         return position;
-      },
-      getRandomVelocity: function (velocity)
+         };
+      })(),
+      activateTextures: function (gl, program)
       {
-         var
-            direction = this .direction,
-            speed     = this .getRandomSpeed ();
-
-         velocity .x = direction .x * speed;
-         velocity .y = direction .y * speed;
-         velocity .z = direction .z * speed;
-
-         return velocity;
-       },
+         gl .activeTexture (gl .TEXTURE0 + program .polylinesTextureUnit);
+         gl .bindTexture (gl .TEXTURE_2D, this .polylinesTexture);
+      },
    });
 
-   function getPosition (position)
-   {
-      return position .set (0, 0, 0);
-   }
-
    return PolylineEmitter;
 });