x_ite 5.0.2 → 6.0.0

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

@@ -0,0 +1,183 @@
+#define BVH_NODE        0
+#define BVH_TRIANGLE    1
+#define BVH_STACK_SIZE  32
+
+int bvhNodeIndex = 0;
+
+void
+setBVHIndex (const in int index)
+{
+   bvhNodeIndex = index;
+}
+
+int
+getBVHRoot (const in sampler2D volume, const in int hierarchyIndex, const in int rootIndex)
+{
+   return int (texelFetch (volume, rootIndex, 0) .x) + hierarchyIndex;
+}
+
+int
+getBVHType (const in sampler2D volume)
+{
+   return int (texelFetch (volume, bvhNodeIndex, 0) .x);
+}
+
+vec3
+getBVHMin (const in sampler2D volume)
+{
+   return texelFetch (volume, bvhNodeIndex + 1, 0) .xyz;
+}
+
+vec3
+getBVHMax (const in sampler2D volume)
+{
+   return texelFetch (volume, bvhNodeIndex + 2, 0) .xyz;
+}
+
+int
+getBVHLeft (const in sampler2D volume, const in int hierarchyIndex)
+{
+   return int (texelFetch (volume, bvhNodeIndex, 0) .y) + hierarchyIndex;
+}
+
+int
+getBVHRight (const in sampler2D volume, const in int hierarchyIndex)
+{
+   return int (texelFetch (volume, bvhNodeIndex, 0) .z) + hierarchyIndex;
+}
+
+int
+getBVHTriangle (const in sampler2D volume)
+{
+   return int (texelFetch (volume, bvhNodeIndex, 0) .y);
+}
+
+/* Ray triangle intersection test */
+
+int
+getIntersections (const in sampler2D volume, const in int verticesIndex, const in int hierarchyIndex, const in int rootIndex, const in Line3 line, out vec4 points [ARRAY_SIZE])
+{
+   int current    = getBVHRoot (volume, hierarchyIndex, rootIndex);
+   int count      = 0;
+   int stackIndex = -1;
+   int stack [BVH_STACK_SIZE];
+
+   while (stackIndex >= 0 || current >= 0)
+   {
+      if (current >= 0)
+      {
+         setBVHIndex (current);
+
+         if (getBVHType (volume) == BVH_NODE)
+         {
+            // Node
+
+            if (intersects (getBVHMin (volume), getBVHMax (volume), line))
+            {
+               stack [++ stackIndex] = current;
+
+               current = getBVHLeft (volume, hierarchyIndex);
+            }
+            else
+            {
+               current = -1;
+            }
+         }
+         else
+         {
+            // Triangle
+
+            int  t = getBVHTriangle (volume);
+            int  v = verticesIndex + t;
+            vec3 r = vec3 (0.0);
+
+            vec3 a = texelFetch (volume, v,     0) .xyz;
+            vec3 b = texelFetch (volume, v + 1, 0) .xyz;
+            vec3 c = texelFetch (volume, v + 2, 0) .xyz;
+
+            if (intersects (line, a, b, c, r))
+               points [count ++] = vec4 (r .z * a + r .x * b + r .y * c, 1.0);
+
+            current = -1;
+         }
+      }
+      else
+      {
+         setBVHIndex (stack [stackIndex --]);
+
+         current = getBVHRight (volume, hierarchyIndex);
+      }
+   }
+
+   return count;
+}
+
+int
+getIntersections (const in sampler2D volume, const in int verticesIndex, const in int normalsIndex, const in int hierarchyIndex, const in int rootIndex, const in Line3 line, out vec4 points [ARRAY_SIZE], out vec3 normals [ARRAY_SIZE])
+{
+   int current    = getBVHRoot (volume, hierarchyIndex, rootIndex);
+   int count      = 0;
+   int stackIndex = -1;
+   int stack [BVH_STACK_SIZE];
+
+   while (stackIndex >= 0 || current >= 0)
+   {
+      if (current >= 0)
+      {
+         setBVHIndex (current);
+
+         if (getBVHType (volume) == BVH_NODE)
+         {
+            // Node
+
+            if (intersects (getBVHMin (volume), getBVHMax (volume), line))
+            {
+               stack [++ stackIndex] = current;
+
+               current = getBVHLeft (volume, hierarchyIndex);
+            }
+            else
+            {
+               current = -1;
+            }
+         }
+         else
+         {
+            // Triangle
+
+            int  t = getBVHTriangle (volume);
+            int  v = verticesIndex + t;
+            vec3 r = vec3 (0.0);
+
+            vec3 a = texelFetch (volume, v,     0) .xyz;
+            vec3 b = texelFetch (volume, v + 1, 0) .xyz;
+            vec3 c = texelFetch (volume, v + 2, 0) .xyz;
+
+            if (intersects (line, a, b, c, r))
+            {
+               points [count] = vec4 (r .z * a + r .x * b + r .y * c, 1.0);
+
+               int n = normalsIndex + t;
+
+               vec3 n0 = texelFetch (volume, n,     0) .xyz;
+               vec3 n1 = texelFetch (volume, n + 1, 0) .xyz;
+               vec3 n2 = texelFetch (volume, n + 2, 0) .xyz;
+
+               normals [count] = save_normalize (r .z * n0 + r .x * n1 + r .y * n2);
+
+               ++ count;
+            }
+
+            current = -1;
+         }
+      }
+      else
+      {
+         setBVHIndex (stack [stackIndex --]);
+
+         current = getBVHRight (volume, hierarchyIndex);
+      }
+   }
+
+   return count;
+}

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

@@ -0,0 +1,47 @@
+bool
+intersects (const in vec3 min, const in vec3 max, const in Line3 line)
+{
+   vec3 intersection;
+
+   // front
+
+   if (intersects (plane3 (max, vec3 (0.0, 0.0, 1.0)), line, intersection))
+   {
+      if (all (greaterThanEqual (vec4 (intersection .xy, max .xy), vec4 (min .xy, intersection .xy))))
+         return true;
+   }
+
+   // back
+
+   if (intersects (plane3 (min, vec3 (0.0, 0.0, -1.0)), line, intersection))
+   {
+      if (all (greaterThanEqual (vec4 (intersection .xy, max .xy), vec4 (min .xy, intersection .xy))))
+         return true;
+   }
+
+   // top
+
+   if (intersects (plane3 (max, vec3 (0.0, 1.0, 0.0)), line, intersection))
+   {
+      if (all (greaterThanEqual (vec4 (intersection .xz, max .xz), vec4 (min .xz, intersection .xz))))
+         return true;
+   }
+
+   // bottom
+
+   if (intersects (plane3 (min, vec3 (0.0, -1.0, 0.0)), line, intersection))
+   {
+      if (all (greaterThanEqual (vec4 (intersection .xz, max .xz), vec4 (min .xz, intersection .xz))))
+         return true;
+   }
+
+   // right
+
+   if (intersects (plane3 (max, vec3 (1.0, 0.0, 0.0)), line, intersection))
+   {
+      if (all (greaterThanEqual (vec4 (intersection .yz, max .yz), vec4 (min .yz, intersection .yz))))
+         return true;
+   }
+
+   return false;
+}

package/src/x_ite/Browser/ParticleSystems/GeometryTypes.js

@@ -0,0 +1,66 @@
+/* -*- Mode: JavaScript; coding: utf-8; tab-width: 3; indent-tabs-mode: tab; c-basic-offset: 3 -*-
+ *******************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright create3000, Scheffelstraße 31a, Leipzig, Germany 2011.
+ *
+ * All rights reserved. Holger Seelig <holger.seelig@yahoo.de>.
+ *
+ * The copyright notice above does not evidence any actual of intended
+ * publication of such source code, and is an unpublished work by create3000.
+ * This material contains CONFIDENTIAL INFORMATION that is the property of
+ * create3000.
+ *
+ * No permission is granted to copy, distribute, or create derivative works from
+ * the contents of this software, in whole or in part, without the prior written
+ * permission of create3000.
+ *
+ * NON-MILITARY USE ONLY
+ *
+ * All create3000 software are effectively free software with a non-military use
+ * restriction. It is free. Well commented source is provided. You may reuse the
+ * source in any way you please with the exception anything that uses it must be
+ * marked to indicate is contains 'non-military use only' components.
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2015, 2016 Holger Seelig <holger.seelig@yahoo.de>.
+ *
+ * This file is part of the X_ITE Project.
+ *
+ * X_ITE is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License version 3 only, as published by the
+ * Free Software Foundation.
+ *
+ * X_ITE is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU General Public License version 3 for more
+ * details (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version 3
+ * along with X_ITE.  If not, see <http://www.gnu.org/licenses/gpl.html> for a
+ * copy of the GPLv3 License.
+ *
+ * For Silvio, Joy and Adi.
+ *
+ ******************************************************************************/
+
+
+ define (function ()
+{
+"use strict";
+
+   let i = 0;
+
+   const GeometryTypes = {
+      POINT:    i ++,
+      LINE:     i ++,
+      TRIANGLE: i ++,
+      QUAD:     i ++,
+      SPRITE:   i ++,
+      GEOMETRY: i ++,
+   };
+
+   return GeometryTypes;
+});

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

@@ -0,0 +1,55 @@
+struct Line3 {
+   vec3 point;
+   vec3 direction;
+};
+
+// Line3
+// line3 (const in vec3 point1, const in vec3 point2)
+// {
+//    return Line3 (point1, normalize (point2 - point1));
+// }
+
+/* Line intersect triangle */
+
+bool
+intersects (const in Line3 line, const in vec3 a, const in vec3 b, const in vec3 c, out vec3 r)
+{
+   // find vectors for two edges sharing vert0
+   vec3 edge1 = b - a;
+   vec3 edge2 = c - a;
+
+   // begin calculating determinant - also used to calculate U parameter
+   vec3 pvec = cross (line .direction, edge2);
+
+   // if determinant is near zero, ray lies in plane of triangle
+   float det = dot (edge1, pvec);
+
+   // Non culling intersection
+
+   if (det == 0.0)
+      return false;
+
+   float inv_det = 1.0 / det;
+
+   // calculate distance from vert0 to ray point
+   vec3 tvec = line .point - a;
+
+   // calculate U parameter and test bounds
+   float u = dot (tvec, pvec) * inv_det;
+
+   if (u < 0.0 || u > 1.0)
+      return false;
+
+   // prepare to test V parameter
+   vec3 qvec = cross (tvec, edge1);
+
+   // calculate V parameter and test bounds
+   float v = dot (line .direction, qvec) * inv_det;
+
+   if (v < 0.0 || u + v > 1.0)
+      return false;
+
+   r = vec3 (u, v, 1.0 - u - v);
+
+   return true;
+}

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;