implement picking

Author: etpinard

lib/cone-position.glsl

@@ -0,0 +1,73 @@
+vec3 getOrthogonalVector(vec3 v) {
+  // Return up-vector for only-z vector.
+  // Return ax + by + cz = 0, a point that lies on the plane that has v as a normal and that isn't (0,0,0).
+  // From the above if-statement we have ||a|| > 0  U  ||b|| > 0.
+  // Assign z = 0, x = -b, y = a:
+  // a*-b + b*a + c*0 = -ba + ba + 0 = 0
+  if (v.x*v.x > v.z*v.z || v.y*v.y > v.z*v.z) {
+    return normalize(vec3(-v.y, v.x, 0.0));
+  } else {
+    return normalize(vec3(0.0, v.z, -v.y));
+  }
+}
+
+// Calculate the cone vertex and normal at the given index.
+//
+// The returned vertex is for a cone with its top at origin and height of 1.0,
+// pointing in the direction of the vector attribute.
+//
+// Each cone is made up of a top vertex, a center base vertex and base perimeter vertices.
+// These vertices are used to make up the triangles of the cone by the following:
+//   segment + 0 top vertex
+//   segment + 1 perimeter vertex a+1
+//   segment + 2 perimeter vertex a
+//   segment + 3 center base vertex
+//   segment + 4 perimeter vertex a
+//   segment + 5 perimeter vertex a+1
+// Where segment is the number of the radial segment * 6 and a is the angle at that radial segment.
+// To go from index to segment, floor(index / 6)
+// To go from segment to angle, 2*pi * (segment/segmentCount)
+// To go from index to segment index, index - (segment*6)
+//
+vec3 getConePosition(vec3 d, float index, float coneOffset, out vec3 normal) {
+
+  const float segmentCount = 8.0;
+
+  index = mod(index, segmentCount * 6.0);
+
+  float segment = floor(index/6.0);
+  float segmentIndex = index - (segment*6.0);
+
+  normal = -normalize(d);
+
+  if (segmentIndex == 3.0) {
+    return mix(vec3(0.0), -d, coneOffset);
+  }
+
+  // angle = 2pi * ((segment + ((segmentIndex == 1.0 || segmentIndex == 5.0) ? 1.0 : 0.0)) / segmentCount)
+  float nextAngle = float(segmentIndex == 1.0 || segmentIndex == 5.0);
+  float angle = 2.0 * 3.14159 * ((segment + nextAngle) / segmentCount);
+
+  vec3 v1 = mix(d, vec3(0.0), coneOffset);
+  vec3 v2 = v1 - d;
+
+  vec3 u = getOrthogonalVector(d);
+  vec3 v = normalize(cross(u, d));
+
+  vec3 x = u * cos(angle) * length(d)*0.25;
+  vec3 y = v * sin(angle) * length(d)*0.25;
+  vec3 v3 = v2 + x + y;
+  if (segmentIndex <= 2.0) {
+    vec3 tx = u * sin(angle);
+    vec3 ty = v * -cos(angle);
+    vec3 tangent = tx + ty;
+    normal = normalize(cross(v3 - v1, tangent));
+  }
+
+  if (segmentIndex == 0.0) {
+    return mix(d, vec3(0.0), coneOffset);
+  }
+  return v3;
+}
+
+#pragma glslify: export(getConePosition)

lib/conemesh.js

@@ -787,43 +787,13 @@ proto.pick = function(pickData) {
 
   var cellId    = pickData.value[0] + 256*pickData.value[1] + 65536*pickData.value[2]
   var cell      = this.cells[cellId]
-  var positions = this.positions
-
-  var simplex   = new Array(cell.length)
-  for(var i=0; i<cell.length; ++i) {
-    simplex[i] = positions[cell[i]]
-  }
-
-  var data = closestPoint(
-    simplex,
-    [pickData.coord[0], this._resolution[1]-pickData.coord[1]],
-    this._model,
-    this._view,
-    this._projection,
-    this._resolution)
-
-  if(!data) {
-    return null
-  }
-
-  var weights = data[2]
-  var interpIntensity = 0.0
-  for(var i=0; i<cell.length; ++i) {
-    interpIntensity += weights[i] * this.intensity[cell[i]]
-  }
+  var pos =     this.positions[cell[1]].slice(0, 3)
 
   return {
-    position: data[1],
-    index:    cell[data[0]],
-    cell:     cell,
-    cellId:   cellId,
-    intensity:  interpIntensity,
-
-    vectorScale: this.vectorScale,
-    coneScale: this.coneScale,
-    coneOffset: this.coneOffset,
-
-    dataCoordinate: this.positions[cell[data[0]]]
+    // corresponding to input indices
+    index: Math.floor(cell[1] / 48),
+    position: pos,
+    dataCoordinate: pos
   }
 }
 
@@ -892,9 +862,10 @@ function createPointShader(gl) {
 }
 
 function createPickShader(gl) {
-  var shader = createShader(gl, pickShader.vertex, pickShader.fragment)
+  var shader = createShader(gl, pickShader.vertex, pickShader.fragment, null, pickShader.attributes)
   shader.attributes.position.location = 0
   shader.attributes.id.location       = 1
+  shader.attributes.vector.location   = 5
   return shader
 }
 

lib/pick-vertex.glsl

@@ -1,15 +1,24 @@
 precision mediump float;
 
-attribute vec3 position;
+#pragma glslify: getConePosition = require(./cone-position.glsl)
+
+attribute vec3 vector;
+attribute vec4 position;
 attribute vec4 id;
 
 uniform mat4 model, view, projection;
 
+uniform float vectorScale;
+uniform float coneScale;
+uniform float coneOffset;
+
 varying vec3 f_position;
 varying vec4 f_id;
 
 void main() {
-  gl_Position = projection * view * model * vec4(position, 1.0);
+  vec3 normal;
+  vec4 conePosition = model * vec4(position.xyz, 1.0) + vec4(getConePosition(mat3(model) * ((vectorScale * coneScale) * vector), position.w, coneOffset, normal), 0.0);
+  gl_Position = projection * view * conePosition;
   f_id        = id;
-  f_position  = position;
-}
+  f_position  = position.xyz;
+}

lib/shaders.js

@@ -20,7 +20,8 @@ exports.pickShader = {
   vertex:   pickVertSrc,
   fragment: pickFragSrc,
   attributes: [
-    {name: 'position', type: 'vec3'},
-    {name: 'id', type: 'vec4'}
+    {name: 'position', type: 'vec4'},
+    {name: 'id', type: 'vec4'},
+    {name: 'vector', type: 'vec3'}
   ]
 }

lib/triangle-vertex.glsl

@@ -1,6 +1,7 @@
 precision mediump float;
 
 #pragma glslify: inverse = require(glsl-inverse)
+#pragma glslify: getConePosition = require(./cone-position.glsl)
 
 attribute vec3 vector;
 attribute vec4 color, position;
@@ -23,84 +24,11 @@ varying vec3 f_normal
 varying vec4 f_color;
 varying vec2 f_uv;
 
-
-vec3 getOrthogonalVector(vec3 v) {
-  // Return up-vector for only-z vector.
-  // Return ax + by + cz = 0, a point that lies on the plane that has v as a normal and that isn't (0,0,0).
-  // From the above if-statement we have ||a|| > 0  U  ||b|| > 0.
-  // Assign z = 0, x = -b, y = a:
-  // a*-b + b*a + c*0 = -ba + ba + 0 = 0
-  if (v.x*v.x > v.z*v.z || v.y*v.y > v.z*v.z) {
-    return normalize(vec3(-v.y, v.x, 0.0)); 
-  } else {
-    return normalize(vec3(0.0, v.z, -v.y));
-  }
-}
-
-// Calculate the cone vertex and normal at the given index.
-//
-// The returned vertex is for a cone with its top at origin and height of 1.0, 
-// pointing in the direction of the vector attribute.
-//
-// Each cone is made up of a top vertex, a center base vertex and base perimeter vertices.
-// These vertices are used to make up the triangles of the cone by the following:
-//   segment + 0 top vertex
-//   segment + 1 perimeter vertex a+1
-//   segment + 2 perimeter vertex a
-//   segment + 3 center base vertex
-//   segment + 4 perimeter vertex a
-//   segment + 5 perimeter vertex a+1
-// Where segment is the number of the radial segment * 6 and a is the angle at that radial segment.
-// To go from index to segment, floor(index / 6)
-// To go from segment to angle, 2*pi * (segment/segmentCount)
-// To go from index to segment index, index - (segment*6)
-//
-vec3 getConePosition(vec3 d, float index, out vec3 normal) {
-
-  const float segmentCount = 8.0;
-
-  index = mod(index, segmentCount * 6.0);
-
-  float segment = floor(index/6.0);
-  float segmentIndex = index - (segment*6.0);
-
-  normal = -normalize(d);
-
-  if (segmentIndex == 3.0) {
-    return mix(vec3(0.0), -d, coneOffset);
-  }
-
-  // angle = 2pi * ((segment + ((segmentIndex == 1.0 || segmentIndex == 5.0) ? 1.0 : 0.0)) / segmentCount)
-  float nextAngle = float(segmentIndex == 1.0 || segmentIndex == 5.0);
-  float angle = 2.0 * 3.14159 * ((segment + nextAngle) / segmentCount);
-
-  vec3 v1 = mix(d, vec3(0.0), coneOffset);
-  vec3 v2 = v1 - d;
-
-  vec3 u = getOrthogonalVector(d);
-  vec3 v = normalize(cross(u, d));
-
-  vec3 x = u * cos(angle) * length(d)*0.25;
-  vec3 y = v * sin(angle) * length(d)*0.25;
-  vec3 v3 = v2 + x + y;
-  if (segmentIndex <= 2.0) {
-    vec3 tx = u * sin(angle);
-    vec3 ty = v * -cos(angle);
-    vec3 tangent = tx + ty;
-    normal = normalize(cross(v3 - v1, tangent));
-  }
-
-  if (segmentIndex == 0.0) {
-    return mix(d, vec3(0.0), coneOffset);
-  }
-  return v3;
-}
-
 void main() {
   // Scale the vector magnitude to stay constant with
   // model & view changes.
   vec3 normal;
-  vec4 conePosition = model * vec4(position.xyz, 1.0) + vec4(getConePosition(mat3(model) * ((vectorScale * coneScale) * vector), position.w, normal), 0.0);
+  vec4 conePosition = model * vec4(position.xyz, 1.0) + vec4(getConePosition(mat3(model) * ((vectorScale * coneScale) * vector), position.w, coneOffset, normal), 0.0);
   normal = normalize(normal * inverse(mat3(model)));
 
   // vec4 m_position  = model * vec4(conePosition, 1.0);
@@ -112,4 +40,4 @@ void main() {
   f_eyeDirection   = eyePosition   - conePosition.xyz;
   f_lightDirection = lightPosition - conePosition.xyz;
   f_uv             = uv;
-}
+}