x_ite 5.0.3 → 6.1.0

package/src/x_ite/Browser/ParticleSystems/Plane3.glsl

@@ -0,0 +1,160 @@
+struct Plane3
+{
+   vec3  normal;
+   float distanceFromOrigin;
+};
+
+Plane3
+plane3 (const in vec3 point, const in vec3 normal)
+{
+   return Plane3 (normal, dot (normal, point));
+}
+
+float
+plane_distance (const in Plane3 plane, const in vec3 point)
+{
+   return dot (point, plane .normal) - plane .distanceFromOrigin;
+}
+
+/* Plane intersect line */
+bool
+intersects (const in Plane3 plane, const in Line3 line, out vec3 point)
+{
+   // Check if the line is parallel to the plane.
+   float theta = dot (line .direction, plane .normal);
+
+   // Plane and line are parallel.
+   if (theta == 0.0)
+      return false;
+
+   // Plane and line are not parallel. The intersection point can be calculated now.
+   float t = (plane .distanceFromOrigin - dot (plane .normal, line .point)) / theta;
+
+   point = line .point + line .direction * t;
+
+   return true;
+}
+
+/* Find find the first point that is farther to the plane than value. */
+// int
+// upper_bound (const in vec4 points [ARRAY_SIZE], in int count, const in float value, const in Plane3 plane)
+// {
+//    int first = 0;
+//    int step  = 0;
+
+//    while (count > 0)
+//    {
+//       int index = first;
+
+//       step = count >> 1;
+
+//       index += step;
+
+//       if (value < plane_distance (plane, points [index] .xyz))
+//       {
+//          count = step;
+//       }
+//       else
+//       {
+//          first  = ++ index;
+//          count -= step + 1;
+//       }
+//    }
+
+//    return first;
+// }
+
+/* CombSort: sort points in distance to a plane. */
+void
+sort (inout vec4 points [ARRAY_SIZE], const in int count, const in Plane3 plane)
+{
+   const float shrink = 1.0 / 1.3;
+
+   int  gap       = count;
+   bool exchanged = true;
+
+   while (exchanged)
+   {
+      gap = int (float (gap) * shrink);
+
+      if (gap <= 1)
+      {
+         exchanged = false;
+         gap       = 1;
+      }
+
+      for (int i = 0, l = count - gap; i < l; ++ i)
+      {
+         int j = gap + i;
+
+         if (plane_distance (plane, points [i] .xyz) > plane_distance (plane, points [j] .xyz))
+         {
+            vec4 tmp1 = points [i];
+            points [i] = points [j];
+            points [j] = tmp1;
+
+            exchanged = true;
+         }
+      }
+   }
+}
+
+
+// /* CombSort: sort points and normals in distance to a plane. */
+// void
+// sort (inout vec4 points [ARRAY_SIZE], inout vec3 normals [ARRAY_SIZE], const in int count, const in Plane3 plane)
+// {
+//    const float shrink = 1.0 / 1.3;
+
+//    int  gap       = count;
+//    bool exchanged = true;
+
+//    while (exchanged)
+//    {
+//       gap = int (float (gap) * shrink);
+
+//       if (gap <= 1)
+//       {
+//          exchanged = false;
+//          gap       = 1;
+//       }
+
+//       for (int i = 0, l = count - gap; i < l; ++ i)
+//       {
+//          int j = gap + i;
+
+//          if (plane_distance (plane, points [i] .xyz) > plane_distance (plane, points [j] .xyz))
+//          {
+//             vec4 tmp1 = points [i];
+//             points [i] = points [j];
+//             points [j] = tmp1;
+
+//             vec3 tmp2   = normals [i];
+//             normals [i] = normals [j];
+//             normals [j] = tmp2;
+
+//             exchanged = true;
+//          }
+//       }
+//    }
+// }
+
+int
+min_index (const in vec4 points [ARRAY_SIZE], const in int count, const in float value, const in Plane3 plane)
+{
+   int   index = -1;
+   float dist  = 1000000.0;
+
+   for (int i = 0; i < count; ++ i)
+   {
+      float d = plane_distance (plane, points [i] .xyz);
+
+      if (d >= value && d < dist)
+      {
+         dist  = d;
+         index = i;
+      }
+   }
+
+   return index;
+}

package/src/x_ite/Browser/PointingDeviceSensor/PointingDevice.js

@@ -56,6 +56,8 @@ function ($,
 {
 "use strict";
 
+   const CONTEXT_MENU_TIME = 1200;
+
    function PointingDevice (executionContext)
    {
       X3DBaseNode .call (this, executionContext);
@@ -96,9 +98,6 @@ function ($,
 
          browser .getElement () .focus ();
 
-         if (browser .getContextMenu () .getActive ())
-            return;
-
          if (browser .getShiftKey () && browser .getControlKey ())
             return;
 
@@ -190,6 +189,18 @@ function ($,
                event .pageY  = touches [0] .pageY;
 
                this .mousedown (event);
+
+               // Show context menu on long tab.
+
+               const nearestHit = this .getBrowser () .getNearestHit ();
+
+               if (! nearestHit || nearestHit .sensors .size === 0)
+               {
+                  this .touchX       = event .pageX;
+                  this .touchY       = event .pageY;
+                  this .touchTimeout = setTimeout (this .showContextMenu .bind (this, event), CONTEXT_MENU_TIME);
+               }
+
                break;
             }
             case 2:
@@ -202,7 +213,10 @@ function ($,
       touchend: function (event)
       {
          event .button = 0;
+
          this .mouseup (event);
+
+         clearTimeout (this .touchTimeout);
       },
       touchmove: function (event)
       {
@@ -219,6 +233,10 @@ function ($,
                event .pageY  = touches [0] .pageY;
 
                this .mousemove (event);
+
+               if (Math .hypot (this .touchX - event .pageX, this .touchY - event .pageY) > 7)
+                  clearTimeout (this .touchTimeout);
+
                break;
             }
          }
@@ -233,6 +251,7 @@ function ($,
             {
                this .isOver = true;
                this .cursor = browser .getCursor ();
+
                browser .setCursor ("HAND");
             }
          }
@@ -241,6 +260,7 @@ function ($,
             if (this .isOver)
             {
                this .isOver = false;
+
                browser .setCursor (this .cursor);
             }
          }
@@ -259,6 +279,10 @@ function ($,
 
          this .onmotion (x, y);
       },
+      showContextMenu: function (event)
+      {
+         this .getBrowser () .getContextMenu () .show (event);
+      },
    });
 
    return PointingDevice;

package/src/x_ite/Browser/PointingDeviceSensor/X3DPointingDeviceSensorContext.js

@@ -71,19 +71,20 @@ function (PointingDevice,
 "use strict";
 
    const
-      _pointingDevice = Symbol (),
-      _cursorType     = Symbol (),
-      _pointer        = Symbol (),
-      _hitRay         = Symbol (),
-      _hits           = Symbol (),
-      _enabledSensors = Symbol (),
-      _selectedLayer  = Symbol (),
-      _overSensors    = Symbol (),
-      _activeSensors  = Symbol (),
-      _hitPointSorter = Symbol (),
-      _layerNumber    = Symbol (),
-      _layerSorter    = Symbol (),
-      _pointerTime    = Symbol ();
+      _pointingDevice  = Symbol (),
+      _cursorType      = Symbol (),
+      _pointer         = Symbol (),
+      _hitRay          = Symbol (),
+      _hits            = Symbol (),
+      _enabledSensors  = Symbol (),
+      _pickOnlySensors = Symbol (),
+      _selectedLayer   = Symbol (),
+      _overSensors     = Symbol (),
+      _activeSensors   = Symbol (),
+      _hitPointSorter  = Symbol (),
+      _layerNumber     = Symbol (),
+      _layerSorter     = Symbol (),
+      _pointerTime     = Symbol ();
 
    const line = new Line3 (Vector3 .Zero, Vector3 .Zero);
 
@@ -95,8 +96,8 @@ function (PointingDevice,
       this [_hits]           = [ ];
       this [_enabledSensors] = [new Map ()];
       this [_selectedLayer]  = null;
-      this [_overSensors]    = new Map ();
-      this [_activeSensors]  = new Map ();
+      this [_overSensors]    = new Set ();
+      this [_activeSensors]  = new Set ();
       this [_hitPointSorter] = new MergeSort (this [_hits], function (lhs, rhs) { return lhs .intersection .point .z < rhs .intersection .point .z; });
       this [_layerSorter]    = new MergeSort (this [_hits], function (lhs, rhs) { return lhs .layerNumber < rhs .layerNumber; });
       this [_pointerTime]    = 0;
@@ -145,6 +146,10 @@ function (PointingDevice,
       {
          return this [_cursorType];
       },
+      getPointer: function ()
+      {
+         return this [_pointer];
+      },
       isPointerInRectangle: function (rectangle)
       {
          return this [_pointer] .x > rectangle .x &&
@@ -162,14 +167,7 @@ function (PointingDevice,
       },
       setHitRay: function (projectionMatrix, viewport)
       {
-         try
-         {
-            ViewVolume .unProjectRay (this [_pointer] .x, this [_pointer] .y, Matrix4 .Identity, projectionMatrix, viewport, this [_hitRay]);
-         }
-         catch (error)
-         {
-            this [_hitRay] .set (Vector3 .Zero, Vector3 .Zero);
-         }
+         ViewVolume .unProjectRay (this [_pointer] .x, this [_pointer] .y, Matrix4 .Identity, projectionMatrix, viewport, this [_hitRay]);
       },
       getHitRay: function ()
       {
@@ -179,6 +177,10 @@ function (PointingDevice,
       {
          return this [_enabledSensors];
       },
+      getPickOnlySensors: function ()
+      {
+         return this [_pickOnlySensors];
+      },
       addHit: function (intersection, layer, shape, modelViewMatrix)
       {
          const sensors = this [_enabledSensors] .at (-1);
@@ -187,7 +189,7 @@ function (PointingDevice,
             pointer:         this [_pointer],
             hitRay:          this [_hitRay] .copy (),
             intersection:    intersection,
-            sensors:         sensors .size ? new Map (sensors) : sensors,
+            sensors:         new Set (sensors .values ()),
             layer:           layer,
             layerNumber:     this [_layerNumber],
             shape:           shape,
@@ -204,7 +206,7 @@ function (PointingDevice,
       },
       buttonPressEvent: function (x, y)
       {
-         this .touch (x, y);
+         this .touch (x, y, true);
 
          if (this [_hits] .length === 0)
             return false;
@@ -214,7 +216,7 @@ function (PointingDevice,
          this [_selectedLayer] = nearestHit .layer;
          this [_activeSensors] = nearestHit .sensors;
 
-         for (const sensor of this [_activeSensors] .values ())
+         for (const sensor of this [_activeSensors])
             sensor .set_active__ (true, nearestHit);
 
          return !! nearestHit .sensors .size;
@@ -223,10 +225,10 @@ function (PointingDevice,
       {
          this [_selectedLayer] = null;
 
-         for (const sensor of this [_activeSensors] .values ())
+         for (const sensor of this [_activeSensors])
             sensor .set_active__ (false, null);
 
-         this [_activeSensors] = new Map ();
+         this [_activeSensors] = new Set ();
 
          // Selection
 
@@ -234,14 +236,14 @@ function (PointingDevice,
       },
       motionNotifyEvent: function (x, y)
       {
-         this .touch (x, y);
+         this .touch (x, y, true);
          this .motion ();
 
          return !! (this [_hits] .length && this [_hits] .at (-1) .sensors .size);
       },
       leaveNotifyEvent: function ()
       { },
-      touch: function (x, y)
+      touch: function (x, y, pickOnlySensors)
       {
          if (this .getViewer () ._isActive .getValue ())
          {
@@ -251,6 +253,8 @@ function (PointingDevice,
 
          const t0 = performance .now ();
 
+         this [_pickOnlySensors] = pickOnlySensors;
+
          this [_pointer] .set (x, y);
 
          // Clear hits.
@@ -282,7 +286,7 @@ function (PointingDevice,
                modelViewMatrix: new Matrix4 (),
                hitRay:          this [_selectedLayer] ? this [_hitRay] : line,
                intersection:    null,
-               sensors:         new Map (),
+               sensors:         new Set (),
                shape:           null,
                layer:           null,
                layerNumber:     0,
@@ -293,14 +297,14 @@ function (PointingDevice,
 
          if (this [_hits] .length)
          {
-            var difference = Algorithm .map_difference (this [_overSensors], nearestHit .sensors, new Map ());
+            var difference = Algorithm .set_difference (this [_overSensors], nearestHit .sensors, new Set ());
          }
          else
          {
-            var difference = new Map (this [_overSensors]);
+            var difference = new Set (this [_overSensors]);
          }
 
-         for (const sensor of difference .values ())
+         for (const sensor of difference)
             sensor .set_over__ (false, nearestHit);
 
          // Set isOver to TRUE for appropriate nodes
@@ -309,17 +313,17 @@ function (PointingDevice,
          {
             this [_overSensors] = nearestHit .sensors;
 
-            for (const sensor of this [_overSensors] .values ())
+            for (const sensor of this [_overSensors])
                sensor .set_over__ (true, nearestHit);
          }
          else
          {
-            this [_overSensors] = new Map ();
+            this [_overSensors] = new Set ();
          }
 
          // Forward motion event to active drag sensor nodes
 
-         for (const sensor of this [_activeSensors] .values ())
+         for (const sensor of this [_activeSensors])
             sensor .set_motion__ (nearestHit);
       },
       getPointerTime: function ()

package/src/x_ite/Browser/Rendering/X3DRenderingContext.js

@@ -93,29 +93,37 @@ function ($,
 
          this [_resizer] = new ResizeSensor (this .getSurface (), this .reshape .bind (this));
 
+			this .getSurface () .css ("position", ""); // Reset position, set from ResizeSensor.
+
          this .reshape ();
       },
       getRenderer: function ()
       {
-         const
-            gl            = this .getContext (),
-            dbgRenderInfo = this .getExtension ("WEBGL_debug_renderer_info");
+         const gl = this .getContext ();
+
+         if (! navigator .userAgent .match (/Firefox/))
+         {
+            const dbgRenderInfo = gl .getExtension ("WEBGL_debug_renderer_info");
 
-         if (dbgRenderInfo)
-            return gl .getParameter (dbgRenderInfo .UNMASKED_RENDERER_WEBGL);
+            if (dbgRenderInfo)
+               return gl .getParameter (dbgRenderInfo .UNMASKED_RENDERER_WEBGL);
+         }
 
-         return gl .getParameter (this .getContext () .RENDERER);
+         return gl .getParameter (gl .RENDERER);
       },
       getVendor: function ()
       {
-         const
-            gl            = this .getContext (),
-            dbgRenderInfo = this .getExtension ("WEBGL_debug_renderer_info");
+         const gl = this .getContext ();
+
+         if (! navigator .userAgent .match (/Firefox/))
+         {
+            const dbgRenderInfo = gl .getExtension ("WEBGL_debug_renderer_info");
 
-         if (dbgRenderInfo)
-            return gl .getParameter (dbgRenderInfo .UNMASKED_VENDOR_WEBGL);
+            if (dbgRenderInfo)
+               return gl .getParameter (dbgRenderInfo .UNMASKED_VENDOR_WEBGL);
+         }
 
-         return gl .getParameter (this .getContext () .VENDOR);
+         return gl .getParameter (gl .VENDOR);
       },
       getWebGLVersion: function ()
       {
@@ -181,7 +189,7 @@ function ($,
          const element = this .getElement ();
 
          if (element .fullScreen ())
-            element .addClass  ("x_ite-fullscreen");
+            element .addClass ("x_ite-fullscreen");
          else
             element .removeClass ("x_ite-fullscreen");
       },

package/src/x_ite/Browser/Shaders/Shader.js

@@ -72,14 +72,35 @@ function (ShaderSource,
 
          source = ShaderSource .get (gl, source);
 
-         const
-            COMMENTS = "\\s+|/\\*[^]*?\\*/|//.*?\\n",
-            VERSION  = "#version\\s+.*?\\n",
-            ANY      = "[^]*";
-
-         const
-            GLSL  = new RegExp ("^((?:" + COMMENTS + ")?(?:" + VERSION + ")?)(" + ANY + ")$"),
-            match = source .match (GLSL);
+			const
+				COMMENTS     = "\\s+|/\\*[\\s\\S]*?\\*/|//.*?\\n",
+				LINE         = "#line\\s+.*?\\n",
+				IF           = "#if\\s+.*?\\n",
+				ELIF         = "#elif\\s+.*?\\n",
+				IFDEF        = "#ifdef\\s+.*?\\n",
+				IFNDEF       = "#ifndef\\s+.*?\\n",
+				ELSE         = "#else.*?\\n",
+				ENDIF        = "#endif.*?\\n",
+				DEFINE       = "#define\\s+(?:[^\\n\\\\]|\\\\[^\\r\\n]|\\\\\\r?\\n)*\\n",
+				UNDEF        = "#undef\\s+.*?\\n",
+				PRAGMA       = "#pragma\\s+.*?\\n",
+				PREPROCESSOR =  LINE + "|" + IF + "|" + ELIF + "|" + IFDEF + "|" + IFNDEF + "|" + ELSE + "|" + ENDIF + "|" + DEFINE + "|" + UNDEF + "|" + PRAGMA,
+				VERSION      = "#version\\s+.*?\\n",
+				EXTENSION    = "#extension\\s+.*?\\n",
+				ANY          = "[\\s\\S]*";
+
+			const
+				GLSL  = new RegExp ("^((?:" + COMMENTS + "|" + PREPROCESSOR + ")*(?:" + VERSION + ")?(?:" + COMMENTS + "|" + PREPROCESSOR + "|" + EXTENSION + ")*)(" + ANY + ")$"),
+				match = source .match (GLSL);
+
+         // const
+         //    COMMENTS = "\\s+|/\\*[^]*?\\*/|//.*?\\n",
+         //    VERSION  = "#version\\s+.*?\\n",
+         //    ANY      = "[^]*";
+
+         // const
+         //    GLSL  = new RegExp ("^((?:" + COMMENTS + ")?(?:" + VERSION + ")?)(" + ANY + ")$"),
+         //    match = source .match (GLSL);
 
          if (! match)
             return source;
@@ -91,7 +112,7 @@ function (ShaderSource,
          if (browser .getRenderingProperty ("LogarithmicDepthBuffer"))
             constants += "#define X3D_LOGARITHMIC_DEPTH_BUFFER\n";
 
-         if (gl .getVersion () >= 2 || browser .getExtension ("WEBGL_depth_texture"))
+         if (gl .getVersion () >= 2 || gl .getExtension ("WEBGL_depth_texture"))
             constants += "#define X3D_DEPTH_TEXTURE\n";
 
          if (browser .getMultiTexturing ())
@@ -123,9 +144,9 @@ function (ShaderSource,
          definitions += "#define x3d_PointLight        2\n";
          definitions += "#define x3d_SpotLight         3\n";
 
-         definitions += "#define x3d_MaxTextures                " + browser .getMaxTextures () + "\n";
-         definitions += "#define x3d_TextureType2D              2\n";
-         definitions += "#define x3d_TextureType3D              3\n";
+         definitions += "#define x3d_MaxTextures      " + browser .getMaxTextures () + "\n";
+         definitions += "#define x3d_TextureType2D    2\n";
+         definitions += "#define x3d_TextureType3D    3\n";
          definitions += "#define x3d_TextureTypeCube  4\n";
 
          definitions += "#define x3d_Replace                   " + MultiTextureModeType .REPLACE                   + "\n";

package/src/x_ite/Browser/Shaders/ShaderSource.js

@@ -62,8 +62,10 @@ define ([
    "text!assets/shaders/webgl2/include/Colors.glsl",
    "text!assets/shaders/webgl2/include/Fog.glsl",
    "text!assets/shaders/webgl2/include/Hatch.glsl",
+   "text!assets/shaders/webgl2/include/Line2.glsl",
    "text!assets/shaders/webgl2/include/Normal.glsl",
    "text!assets/shaders/webgl2/include/Pack.glsl",
+   "text!assets/shaders/webgl2/include/Particle.glsl",
    "text!assets/shaders/webgl2/include/Perlin.glsl",
    "text!assets/shaders/webgl2/include/Shadow.glsl",
    "text!assets/shaders/webgl2/include/SpotFactor.glsl",
@@ -83,8 +85,10 @@ function (ClipPlanes1,
           Colors2,
           Fog2,
           Hatch2,
+          Line22,
           Normal2,
           Pack2,
+          Particle2,
           Perlin2,
           Shadow2,
           SpotFactor2,
@@ -112,8 +116,10 @@ function (ClipPlanes1,
       Colors: Colors2,
       Fog: Fog2,
       Hatch: Hatch2,
+      Line2: Line22,
       Normal: Normal2,
       Pack: Pack2,
+      Particle: Particle2,
       Perlin: Perlin2,
       Shadow: Shadow2,
       SpotFactor: SpotFactor2,

package/src/x_ite/Browser/Shaders/ShaderTest.js

@@ -48,14 +48,14 @@
 
 
 define ([
+   "x_ite/Rendering/VertexArray",
    "x_ite/Rendering/TextureBuffer",
-   "standard/Math/Numbers/Vector4",
    "standard/Math/Numbers/Matrix3",
    "standard/Math/Numbers/Matrix4",
    "standard/Math/Geometry/Camera",
 ],
-function (TextureBuffer,
-          Vector4,
+function (VertexArray,
+          TextureBuffer,
           Matrix3,
           Matrix4,
           Camera)
@@ -90,7 +90,8 @@ function (TextureBuffer,
                gl           = browser .getContext (),
                frameBuffer  = new TextureBuffer (browser, 16, 16),
                normalBuffer = gl .createBuffer (),
-               vertexBuffer = gl .createBuffer ();
+               vertexBuffer = gl .createBuffer (),
+               vertexArrayObject  = new VertexArray ();
 
             frameBuffer .bind ();
 
@@ -98,9 +99,9 @@ function (TextureBuffer,
             shaderNode .setLocalObjects (gl, [ ]);
 
             gl .bindBuffer (gl .ARRAY_BUFFER, vertexBuffer);
-            gl .bufferData (gl .ARRAY_BUFFER, new Float32Array (vertices), gl .STATIC_DRAW);
+            gl .bufferData (gl .ARRAY_BUFFER, new Float32Array (vertices), gl .DYNAMIC_DRAW);
             gl .bindBuffer (gl .ARRAY_BUFFER, normalBuffer);
-            gl .bufferData (gl .ARRAY_BUFFER, new Float32Array (normals), gl .STATIC_DRAW);
+            gl .bufferData (gl .ARRAY_BUFFER, new Float32Array (normals), gl .DYNAMIC_DRAW);
 
             // Matrices
 
@@ -137,16 +138,21 @@ function (TextureBuffer,
             gl .enable (gl .CULL_FACE);
             gl .cullFace (gl .BACK);
 
-            shaderNode .enableNormalAttribute (gl, normalBuffer);
-            shaderNode .enableVertexAttribute (gl, vertexBuffer);
+            vertexArrayObject .enable (gl, shaderNode);
+            shaderNode .enableNormalAttribute (gl, normalBuffer, 0, 0);
+            shaderNode .enableVertexAttribute (gl, vertexBuffer, 0, 0);
 
             gl .drawArrays (gl .TRIANGLES, 0, 6);
 
-            shaderNode .disableNormalAttribute (gl, normalBuffer);
-
             const data = frameBuffer .readPixels ();
 
             frameBuffer .unbind ();
+            frameBuffer .delete ();
+
+            gl .deleteBuffer (normalBuffer);
+            gl .deleteBuffer (vertexBuffer);
+
+            vertexArrayObject .delete (gl);
 
             return true || (data [0] == 255 && data [1] == 0 && data [2] == 0 && data [3] == 255);
          };