x_ite 5.0.3 → 6.1.0

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

@@ -56,7 +56,6 @@ define ([
    "x_ite/Base/X3DCast",
    "standard/Math/Geometry/Triangle3",
    "standard/Math/Numbers/Vector3",
-   "standard/Math/Algorithm",
 ],
 function (Fields,
           X3DFieldDefinition,
@@ -65,8 +64,7 @@ function (Fields,
           X3DConstants,
           X3DCast,
           Triangle3,
-          Vector3,
-          Algorithm)
+          Vector3)
 {
 "use strict";
 
@@ -76,25 +74,52 @@ function (Fields,
 
       this .addType (X3DConstants .SurfaceEmitter);
 
-      this ._speed       .setUnit ("speed");
-      this ._mass        .setUnit ("mass");
-      this ._surfaceArea .setUnit ("area");
+      this .surfaceNode  = null;
+      this .surfaceArray = new Float32Array ();
 
-      this .surfaceNode    = null;
-      this .areaSoFarArray = [ 0 ];
-      this .direction      = new Vector3 (0, 0, 0);
+      this .addSampler ("surface");
+
+      this .addUniform ("solid",         "uniform bool solid;");
+      this .addUniform ("verticesIndex", "uniform int verticesIndex;");
+      this .addUniform ("normalsIndex",  "uniform int normalsIndex;");
+      this .addUniform ("surface",       "uniform sampler2D surface;");
+
+      this .addFunction (/* glsl */ `vec4 position; vec3 getRandomVelocity ()
+      {
+         if (verticesIndex < 0)
+         {
+            return vec3 (0.0);
+         }
+         else
+         {
+            vec3 normal;
+
+            getRandomPointOnSurface (surface, verticesIndex, normalsIndex, position, normal);
+
+            if (solid == false && random () > 0.5)
+               normal = -normal;
+
+            return normal * getRandomSpeed ();
+         }
+      }`);
+
+      this .addFunction (/* glsl */ `vec4 getRandomPosition ()
+      {
+         return verticesIndex < 0 ? vec4 (NaN) : position;
+      }`);
    }
 
    SurfaceEmitter .prototype = Object .assign (Object .create (X3DParticleEmitterNode .prototype),
    {
       constructor: SurfaceEmitter,
       [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new FieldDefinitionArray ([
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",    new Fields .SFNode ()),
-         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 .initializeOnly, "surface",     new Fields .SFNode ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "metadata",    new Fields .SFNode ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "on",          new Fields .SFBool (true)),
+         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, "surface",     new Fields .SFNode ()),
       ]),
       getTypeName: function ()
       {
@@ -112,6 +137,17 @@ function (Fields,
       {
          X3DParticleEmitterNode .prototype .initialize .call (this);
 
+         const browser = this .getBrowser ();
+
+         if (browser .getContext () .getVersion () < 2)
+            return;
+
+         // Create GL stuff.
+
+         this .surfaceTexture = this .createTexture ();
+
+         // Initialize fields.
+
          this ._surface .addInterest ("set_surface__", this);
 
          this .set_surface__ ();
@@ -119,141 +155,98 @@ function (Fields,
       set_surface__: function ()
       {
          if (this .surfaceNode)
+         {
+            this .surfaceNode ._solid   .removeInterest ("set_solid__",    this);
             this .surfaceNode ._rebuild .removeInterest ("set_geometry__", this);
+         }
 
          this .surfaceNode = X3DCast (X3DConstants .X3DGeometryNode, this ._surface);
 
          if (this .surfaceNode)
+         {
+            this .surfaceNode ._solid   .addInterest ("set_solid__",    this);
             this .surfaceNode ._rebuild .addInterest ("set_geometry__", this);
+         }
 
+         this .set_solid__ ();
          this .set_geometry__ ();
       },
+      set_solid__: function ()
+      {
+         if (this .surfaceNode)
+            this .setUniform ("uniform1i", "solid", this .surfaceNode ._solid .getValue ());
+      },
       set_geometry__: (function ()
       {
-         var
+         const
             vertex1  = new Vector3 (0, 0, 0),
             vertex2  = new Vector3 (0, 0, 0),
             vertex3  = new Vector3 (0, 0, 0);
 
          return function ()
          {
+            const gl = this .getBrowser () .getContext ();
+
             if (this .surfaceNode)
             {
-               delete this .getRandomPosition;
-               delete this .getRandomVelocity;
+               const
+                  vertices         = this .surfaceNode .getVertices () .getValue (),
+                  normals          = this .surfaceNode .getNormals () .getValue (),
+                  numVertices      = vertices .length / 4,
+                  numAreaSoFar     = numVertices / 3 + 1,
+                  surfaceArraySize = Math .ceil (Math .sqrt (numAreaSoFar + numVertices + numVertices));
 
-               var
-                  areaSoFar      = 0,
-                  areaSoFarArray = this .areaSoFarArray,
-                  vertices       = this .surfaceNode .getVertices () .getValue ();
+               const
+                  verticesIndex = numAreaSoFar,
+                  normalsIndex  = verticesIndex + numVertices;
 
-               this .normals  = this .surfaceNode .getNormals () .getValue ();
-               this .vertices = vertices;
+               let surfaceArray = this .surfaceArray;
 
-               areaSoFarArray .length = 1;
+               if (surfaceArray .length < surfaceArraySize * surfaceArraySize * 4)
+                  surfaceArray = this .surfaceArray = new Float32Array (surfaceArraySize * surfaceArraySize * 4);
 
-               for (var i = 0, length = vertices .length; i < length; i += 12)
+               let areaSoFar = 0;
+
+               for (let i = 0, length = vertices .length; i < length; i += 12)
                {
                   vertex1 .set (vertices [i],     vertices [i + 1], vertices [i + 2]);
                   vertex2 .set (vertices [i + 4], vertices [i + 5], vertices [i + 6]);
                   vertex3 .set (vertices [i + 8], vertices [i + 9], vertices [i + 10]);
 
-                  areaSoFar += Triangle3 .area (vertex1, vertex2, vertex3);
-                  areaSoFarArray .push (areaSoFar);
+                  surfaceArray [i / 3 + 4] = areaSoFar += Triangle3 .area (vertex1, vertex2, vertex3);
                }
-            }
-            else
-            {
-               this .getRandomPosition = getPosition;
-               this .getRandomVelocity = this .getSphericalRandomVelocity;
-            }
-         };
-      })(),
-      getRandomPosition: function (position)
-      {
-         // Determine index0.
 
-         var
-            areaSoFarArray = this .areaSoFarArray,
-            length         = areaSoFarArray .length,
-            fraction       = Math .random () * areaSoFarArray .at (-1),
-            index0         = 0;
+               surfaceArray .set (vertices, verticesIndex * 4);
 
-         if (length == 1 || fraction <= areaSoFarArray [0])
-         {
-            index0 = 0;
-         }
-         else if (fraction >= areaSoFarArray .at (-1))
-         {
-            index0 = length - 2;
-         }
-         else
-         {
-            var index = Algorithm .upperBound (areaSoFarArray, 0, length, fraction, Algorithm .less);
+               for (let s = normalsIndex * 4, n = 0, l = normals .length; n < l; s += 4, n += 3)
+               {
+                  surfaceArray [s + 0] = normals [n + 0];
+                  surfaceArray [s + 1] = normals [n + 1];
+                  surfaceArray [s + 2] = normals [n + 2];
+               }
 
-            if (index < length)
-            {
-               index0 = index - 1;
+               this .setUniform ("uniform1i", "verticesIndex", numVertices ? verticesIndex : -1);
+               this .setUniform ("uniform1i", "normalsIndex",  numVertices ? normalsIndex  : -1);
+
+               if (surfaceArraySize)
+               {
+                  gl .bindTexture (gl .TEXTURE_2D, this .surfaceTexture);
+                  gl .texImage2D (gl .TEXTURE_2D, 0, gl .RGBA32F, surfaceArraySize, surfaceArraySize, 0, gl .RGBA, gl .FLOAT, surfaceArray);
+               }
             }
             else
             {
-               index0 = 0;
+               this .setUniform ("uniform1i", "verticesIndex", -1);
+               this .setUniform ("uniform1i", "normalsIndex",  -1);
             }
-         }
-
-         // Random barycentric coordinates.
-
-         var
-            u = Math .random (),
-            v = Math .random ();
-
-         if (u + v > 1)
-         {
-            u = 1 - u;
-            v = 1 - v;
-         }
-
-         var t = 1 - u - v;
-
-         // Interpolate and set position.
-
-         var
-            i        = index0 * 12,
-            vertices = this .vertices;
-
-         position .x = u * vertices [i]     + v * vertices [i + 4] + t * vertices [i + 8];
-         position .y = u * vertices [i + 1] + v * vertices [i + 5] + t * vertices [i + 9];
-         position .z = u * vertices [i + 2] + v * vertices [i + 6] + t * vertices [i + 10];
-
-         var
-            i         = index0 * 9,
-            normals   = this .normals,
-            direction = this .direction;
-
-         direction .x = u * normals [i]     + v * normals [i + 3] + t * normals [i + 6];
-         direction .y = u * normals [i + 1] + v * normals [i + 4] + t * normals [i + 7];
-         direction .z = u * normals [i + 2] + v * normals [i + 5] + t * normals [i + 8];
-
-         return position;
-      },
-      getRandomVelocity: function (velocity)
+         };
+      })(),
+      activateTextures: function (gl, program)
       {
-         var
-            speed     = this .getRandomSpeed (),
-            direction = this .direction;
-
-         velocity .x = direction .x * speed;
-         velocity .y = direction .y * speed;
-         velocity .z = direction .z * speed;
-
-         return velocity;
-       },
+         gl .activeTexture (gl .TEXTURE0 + program .surfaceTextureUnit);
+         gl .bindTexture (gl .TEXTURE_2D, this .surfaceTexture);
+      },
    });
 
-   function getPosition (position)
-   {
-      return position .set (0, 0, 0);
-   }
-
    return SurfaceEmitter;
 });

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

@@ -55,13 +55,8 @@ define ([
    "x_ite/Components/Geometry3D/IndexedFaceSet",
    "x_ite/Base/X3DConstants",
    "standard/Math/Numbers/Vector3",
-   "standard/Math/Numbers/Rotation4",
-   "standard/Math/Geometry/Line3",
-   "standard/Math/Geometry/Plane3",
    "standard/Math/Geometry/Triangle3",
-   "standard/Math/Algorithm",
    "standard/Math/Utility/BVH",
-   "standard/Math/Algorithms/QuickSort",
 ],
 function (Fields,
           X3DFieldDefinition,
@@ -70,13 +65,8 @@ function (Fields,
           IndexedFaceSet,
           X3DConstants,
           Vector3,
-          Rotation4,
-          Line3,
-          Plane3,
           Triangle3,
-          Algorithm,
-          BVH,
-          QuickSort)
+          BVH)
 {
 "use strict";
 
@@ -86,28 +76,87 @@ function (Fields,
 
       this .addType (X3DConstants .VolumeEmitter);
 
-      this ._speed       .setUnit ("speed");
-      this ._mass        .setUnit ("mass");
-      this ._surfaceArea .setUnit ("area");
+      this .volumeNode  = new IndexedFaceSet (executionContext);
+      this .volumeArray = new Float32Array ();
 
-      this .direction      = new Vector3 (0, 0, 0);
-      this .volumeNode     = new IndexedFaceSet (executionContext);
-      this .areaSoFarArray = [ 0 ];
+      this .addSampler ("volume");
+
+      this .addUniform ("direction",      "uniform vec3 direction;");
+      this .addUniform ("verticesIndex",  "uniform int verticesIndex;");
+      this .addUniform ("normalsIndex",   "uniform int normalsIndex;");
+      this .addUniform ("hierarchyIndex", "uniform int hierarchyIndex;");
+      this .addUniform ("hierarchyRoot",  "uniform int hierarchyRoot;");
+      this .addUniform ("volume",         "uniform sampler2D volume;");
+
+      this .addFunction (/* glsl */ `vec3 getRandomVelocity ()
+      {
+         if (hierarchyRoot < 0)
+         {
+            return vec3 (0.0);
+         }
+         else
+         {
+            if (direction == vec3 (0.0))
+               return getRandomSphericalVelocity ();
+
+            else
+               return direction * getRandomSpeed ();
+         }
+      }`);
+
+      this .addFunction (/* glsl */ `vec4 getRandomPosition ()
+      {
+         if (hierarchyRoot < 0)
+         {
+            return vec4 (NaN);
+         }
+         else
+         {
+            vec4 point;
+            vec3 normal;
+
+            getRandomPointOnSurface (volume, verticesIndex, normalsIndex, point, normal);
+
+            Line3 line = Line3 (point .xyz, getRandomSurfaceNormal (normal));
+
+            vec4 points [ARRAY_SIZE];
+
+            int numIntersections = getIntersections (volume, verticesIndex, hierarchyIndex, hierarchyRoot, line, points);
+
+            numIntersections -= numIntersections % 2; // We need an even count of intersections.
+
+            switch (numIntersections)
+            {
+               case 0:
+                  return vec4 (0.0);
+               case 2:
+                  break;
+               default:
+                  sort (points, numIntersections, plane3 (line .point, line .direction));
+                  break;
+            }
+
+            int index = int (fract (random ()) * float (numIntersections / 2)) * 2; // Select random intersection.
+
+            return mix (points [index], points [index + 1], random ());
+         }
+      }`);
    }
 
    VolumeEmitter .prototype = Object .assign (Object .create (X3DParticleEmitterNode .prototype),
    {
       constructor: VolumeEmitter,
       [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new FieldDefinitionArray ([
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",    new Fields .SFNode ()),
-         new X3DFieldDefinition (X3DConstants .initializeOnly, "internal",    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 .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, "internal",    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 ()
       {
@@ -125,6 +174,17 @@ function (Fields,
       {
          X3DParticleEmitterNode .prototype .initialize .call (this);
 
+         const browser = this .getBrowser ();
+
+         if (browser .getContext () .getVersion () < 2)
+            return;
+
+         // Create GL stuff.
+
+         this .volumeTexture = this .createTexture ();
+
+         // Initialize fields.
+
          this ._direction .addInterest ("set_direction__", this);
 
          this ._coordIndex .addFieldInterest (this .volumeNode ._coordIndex);
@@ -142,184 +202,86 @@ function (Fields,
          this .set_direction__ ();
          this .set_geometry__ ();
       },
-      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_geometry__: (function ()
       {
-         var
+         const
             vertex1 = new Vector3 (0, 0, 0),
             vertex2 = new Vector3 (0, 0, 0),
             vertex3 = new Vector3 (0, 0, 0);
 
          return function ()
          {
-            var
-               areaSoFar      = 0,
-               areaSoFarArray = this .areaSoFarArray,
-               normals        = this .volumeNode .getNormals () .getValue (),
-               vertices       = this .volumeNode .getVertices () .getValue ();
-
-            this .normals  = normals;
-            this .vertices = vertices;
-
-            areaSoFarArray .length = 1;
-
-            for (var i = 0, length = vertices .length; i < length; i += 12)
+            const
+               gl              = this .getBrowser () .getContext (),
+               vertices        = this .volumeNode .getVertices () .getValue (),
+               normals         = this .volumeNode .getNormals () .getValue (),
+               hierarchy       = new BVH (vertices, normals) .toArray ([ ]),
+               numVertices     = vertices .length / 4,
+               numNormals      = normals .length / 3,
+               numAreaSoFar    = numVertices / 3 + 1,
+               hierarchyLength = hierarchy .length / 4,
+               volumeArraySize = Math .ceil (Math .sqrt (numAreaSoFar + numVertices + numVertices + hierarchyLength));
+
+            const
+               verticesIndex  = numAreaSoFar,
+               normalsIndex   = verticesIndex + numVertices,
+               hierarchyIndex = normalsIndex + numNormals;
+
+            let volumeArray = this .volumeArray;
+
+            if (volumeArray .length < volumeArraySize * volumeArraySize * 4)
+               volumeArray = this .volumeArray = new Float32Array (volumeArraySize * volumeArraySize * 4);
+
+            let areaSoFar = 0;
+
+            for (let i = 0, length = vertices .length; i < length; i += 12)
             {
                vertex1 .set (vertices [i],     vertices [i + 1], vertices [i + 2]);
                vertex2 .set (vertices [i + 4], vertices [i + 5], vertices [i + 6]);
                vertex3 .set (vertices [i + 8], vertices [i + 9], vertices [i + 10]);
 
-               areaSoFar += Triangle3 .area (vertex1, vertex2, vertex3);
-               areaSoFarArray .push (areaSoFar);
+               volumeArray [i / 3 + 4] = areaSoFar += Triangle3 .area (vertex1, vertex2, vertex3);
             }
 
-            this .bvh = new BVH (vertices, normals);
-         };
-      })(),
-      getRandomPosition: (function ()
-      {
-         var
-            point         = new Vector3 (0, 0, 0),
-            normal        = new Vector3 (0, 0, 0),
-            rotation      = new Rotation4 (0, 0, 1, 0),
-            line          = new Line3 (Vector3 .Zero, Vector3 .zAxis),
-            plane         = new Plane3 (Vector3 .Zero, Vector3 .zAxis),
-            intersections = [ ],
-            sorter        = new QuickSort (intersections, PlaneCompare);
-
-         function PlaneCompare (a, b)
-         {
-            return plane .getDistanceToPoint (a) < plane .getDistanceToPoint (b);
-         }
+            volumeArray .set (vertices, verticesIndex * 4);
 
-         return function (position)
-         {
-            // Get random point on surface
-
-            // Determine index0.
-
-            var
-               areaSoFarArray = this .areaSoFarArray,
-               length         = areaSoFarArray .length,
-               fraction       = Math .random () * areaSoFarArray .at (-1),
-               index0         = 0;
-
-            if (length == 1 || fraction <= areaSoFarArray [0])
+            for (let s = normalsIndex * 4, n = 0, l = normals .length; n < l; s += 4, n += 3)
             {
-               index0 = 0;
-            }
-            else if (fraction >= areaSoFarArray .at (-1))
-            {
-               index0 = length - 2;
-            }
-            else
-            {
-               var index = Algorithm .upperBound (areaSoFarArray, 0, length, fraction, Algorithm .less);
-
-               if (index < length)
-               {
-                  index0 = index - 1;
-               }
-               else
-               {
-                  index0 = 0;
-               }
+               volumeArray [s + 0] = normals [n + 0];
+               volumeArray [s + 1] = normals [n + 1];
+               volumeArray [s + 2] = normals [n + 2];
             }
 
-            // Random barycentric coordinates.
+            volumeArray .set (hierarchy, hierarchyIndex * 4);
 
-            var
-               u = Math .random (),
-               v = Math .random ();
+            this .setUniform ("uniform1i", "verticesIndex",  verticesIndex);
+            this .setUniform ("uniform1i", "normalsIndex",   normalsIndex);
+            this .setUniform ("uniform1i", "hierarchyIndex", hierarchyIndex);
+            this .setUniform ("uniform1i", "hierarchyRoot",  hierarchyIndex + hierarchyLength - 1);
 
-            if (u + v > 1)
+            if (volumeArraySize)
             {
-               u = 1 - u;
-               v = 1 - v;
+               gl .bindTexture (gl .TEXTURE_2D, this .volumeTexture);
+               gl .texImage2D (gl .TEXTURE_2D, 0, gl .RGBA32F, volumeArraySize, volumeArraySize, 0, gl .RGBA, gl .FLOAT, volumeArray);
             }
-
-            var t = 1 - u - v;
-
-            // Interpolate and determine random point on surface and normal.
-
-            var
-               i        = index0 * 12,
-               vertices = this .vertices;
-
-            point .x = u * vertices [i]     + v * vertices [i + 4] + t * vertices [i + 8];
-            point .y = u * vertices [i + 1] + v * vertices [i + 5] + t * vertices [i + 9];
-            point .z = u * vertices [i + 2] + v * vertices [i + 6] + t * vertices [i + 10];
-
-            var
-               i       = index0 * 9,
-               normals = this .normals;
-
-            normal .x = u * normals [i]     + v * normals [i + 3] + t * normals [i + 6];
-            normal .y = u * normals [i + 1] + v * normals [i + 4] + t * normals [i + 7];
-            normal .z = u * normals [i + 2] + v * normals [i + 5] + t * normals [i + 8];
-
-            rotation .setFromToVec (Vector3 .zAxis, normal);
-            rotation .multVecRot (this .getRandomSurfaceNormal (normal));
-
-            // Setup random line throu volume for intersection text
-            // and a plane corresponding to the line for intersection sorting.
-
-            line  .set (point, normal);
-            plane .set (point, normal);
-
-            // Find random point in volume.
-
-            var numIntersections = this .bvh .intersectsLine (line, intersections);
-
-            numIntersections -= numIntersections % 2; // We need an even count of intersections.
-
-            if (numIntersections)
-            {
-               // Sort intersections along line with a little help from the plane.
-
-               sorter .sort (0, numIntersections);
-
-               // Select random intersection pair.
-
-               var
-                  index  = Math .round (this .getRandomValue (0, numIntersections / 2 - 1)) * 2,
-                  point0 = intersections [index],
-                  point1 = intersections [index + 1],
-                  t      = Math .random ();
-
-               // lerp
-               position .x = point0 .x + (point1 .x - point0 .x) * t;
-               position .y = point0 .y + (point1 .y - point0 .y) * t;
-               position .z = point0 .z + (point1 .z - point0 .z) * t;
-
-               return position;
-            }
-
-            // Discard point.
-
-            return position .set (Number .POSITIVE_INFINITY, Number .POSITIVE_INFINITY, Number .POSITIVE_INFINITY);
          };
       })(),
-      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 .volumeTextureUnit);
+         gl .bindTexture (gl .TEXTURE_2D, this .volumeTexture);
+      },
    });
 
    return VolumeEmitter;