zincjs 1.16.2 → 1.16.3

package/src/shaders/volumeRender_old.js

@@ -0,0 +1,287 @@
+const THREE = require('three');
+
+const glslVersion = null;
+
+const fs =
+`
+  precision highp float;
+  precision highp sampler2DArray;
+  precision highp sampler2D;
+
+  uniform vec3 u_size;
+  uniform int u_renderstyle;
+  uniform float u_renderthreshold;
+  uniform vec2 u_clim;
+
+  uniform sampler2DArray u_data;
+  uniform sampler2D u_cmdata;
+
+  varying vec3 v_position;
+  varying vec4 v_nearpos;
+  varying vec4 v_farpos;
+
+  // The maximum distance through our rendering volume is sqrt(3).
+  const int MAX_STEPS = 887;	// 887 for 512^3, 1774 for 1024^3
+  const int REFINEMENT_STEPS = 4;
+  const float relative_step_size = 1.0;
+  const vec4 ambient_color = vec4(0.2, 0.4, 0.2, 1.0);
+  const vec4 diffuse_color = vec4(0.8, 0.2, 0.2, 1.0);
+  const vec4 specular_color = vec4(1.0, 1.0, 1.0, 1.0);
+  const float shininess = 40.0;
+
+  void cast_mip(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray);
+  void cast_iso(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray);
+
+  vec3 sample1(vec3 texcoords);
+  vec4 apply_colormap(float val);
+  vec4 add_lighting(float val, vec3 loc, vec3 step, vec3 view_ray);
+
+
+  void main() {
+      // Normalize clipping plane info
+      vec3 farpos = v_farpos.xyz / v_farpos.w;
+      vec3 nearpos = v_nearpos.xyz / v_nearpos.w;
+
+      // Calculate unit vector pointing in the view direction through this fragment.
+      vec3 view_ray = normalize(nearpos.xyz - farpos.xyz);
+
+      // Compute the (negative) distance to the front surface or near clipping plane.
+      // v_position is the back face of the cuboid, so the initial distance calculated in the dot
+      // product below is the distance from near clip plane to the back of the cuboid
+      float distance = dot(nearpos - v_position, view_ray);
+      distance = max(distance, min((-0.5 - v_position.x) / view_ray.x,
+                                  (u_size.x - 0.5 - v_position.x) / view_ray.x));
+      distance = max(distance, min((-0.5 - v_position.y) / view_ray.y,
+                                  (u_size.y - 0.5 - v_position.y) / view_ray.y));
+      distance = max(distance, min((-0.5 - v_position.z) / view_ray.z,
+                                  (u_size.z - 0.5 - v_position.z) / view_ray.z));
+
+      // Now we have the starting position on the front surface
+      vec3 front = v_position + view_ray * distance;
+
+      // Decide how many steps to take
+      int nsteps = int(-distance / relative_step_size + 0.5);
+      if ( nsteps < 1 )
+          discard;
+
+      // Get starting location and step vector in texture coordinates
+      vec3 step = ((v_position - front) / u_size) / float(nsteps);
+      vec3 start_loc = front / u_size;
+
+      // For testing: show the number of steps. This helps to establish
+      // whether the rays are correctly oriented
+      //gl_FragColor = vec4(0.0, float(nsteps) / 1.0 / u_size.x, 1.0, 1.0);
+      //return;
+
+      if (u_renderstyle == 0)
+          cast_mip(start_loc, step, nsteps, view_ray);
+      else if (u_renderstyle == 1)
+          cast_iso(start_loc, step, nsteps, view_ray);
+
+      if (gl_FragColor.a < 0.05)
+          discard;
+  }
+
+
+  vec3 sample1(vec3 texcoords) {
+      /* Sample float value from a 3D texture. Assumes intensity data. */
+      return texture(u_data, texcoords.xyz).rgb;
+  }
+
+
+  vec4 apply_colormap(float val) {
+      val = (val - u_clim[0]) / (u_clim[1] - u_clim[0]);
+      return texture2D(u_cmdata, vec2(val, 0.5));
+  }
+
+
+  void cast_mip(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray) {
+
+      float max_val = -1e6;
+      int max_i = 100;
+      vec3 loc = start_loc;
+
+      // Enter the raycasting loop. In WebGL 1 the loop index cannot be compared with
+      // non-constant expression. So we use a hard-coded max, and an additional condition
+      // inside the loop.
+      for (int iter=0; iter<MAX_STEPS; iter++) {
+          if (iter >= nsteps)
+              break;
+          // Sample from the 3D texture
+          vec3 val = sample1(loc);
+          float avg = (val.x + val.y + val.z) / 3.0;
+          // Apply MIP operation
+          if (val > max_val) {
+              max_val = val;
+              max_i = iter;
+          }
+          // Advance location deeper into the volume
+          loc += step;
+      }
+
+      // Refine location, gives crispier images
+      vec3 iloc = start_loc + step * (float(max_i) - 0.5);
+      vec3 istep = step / float(REFINEMENT_STEPS);
+      for (int i=0; i<REFINEMENT_STEPS; i++) {
+          max_val = max(max_val, sample1(iloc));
+          iloc += istep;
+      }
+
+      // Resolve final color
+      gl_FragColor = apply_colormap(max_val);
+  }
+
+
+  void cast_iso(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray) {
+
+      gl_FragColor = vec4(0.0);	// init transparent
+      vec4 color3 = vec4(0.0);	// final color
+      vec3 dstep = 1.5 / u_size;	// step to sample derivative
+      vec3 loc = start_loc;
+
+      float low_threshold = u_renderthreshold - 0.02 * (u_clim[1] - u_clim[0]);
+
+      // Enter the raycasting loop. In WebGL 1 the loop index cannot be compared with
+      // non-constant expression. So we use a hard-coded max, and an additional condition
+      // inside the loop.
+      for (int iter=0; iter<MAX_STEPS; iter++) {
+          if (iter >= nsteps)
+              break;
+
+          // Sample from the 3D texture
+          float val = sample1(loc);
+
+          if (val > low_threshold) {
+              // Take the last interval in smaller steps
+              vec3 iloc = loc - 0.5 * step;
+              vec3 istep = step / float(REFINEMENT_STEPS);
+              for (int i=0; i<REFINEMENT_STEPS; i++) {
+                  val = sample1(iloc);
+                  if (val > u_renderthreshold) {
+                      gl_FragColor = add_lighting(val, iloc, dstep, view_ray);
+                      return;
+                  }
+                  iloc += istep;
+              }
+          }
+
+          // Advance location deeper into the volume
+          loc += step;
+      }
+  }
+
+
+  vec4 add_lighting(float val, vec3 loc, vec3 step, vec3 view_ray)
+  {
+    // Calculate color by incorporating lighting
+
+      // View direction
+      vec3 V = normalize(view_ray);
+
+      // calculate normal vector from gradient
+      vec3 N;
+      float val1, val2;
+      val1 = sample1(loc + vec3(-step[0], 0.0, 0.0));
+      val2 = sample1(loc + vec3(+step[0], 0.0, 0.0));
+      N[0] = val1 - val2;
+      val = max(max(val1, val2), val);
+      val1 = sample1(loc + vec3(0.0, -step[1], 0.0));
+      val2 = sample1(loc + vec3(0.0, +step[1], 0.0));
+      N[1] = val1 - val2;
+      val = max(max(val1, val2), val);
+      val1 = sample1(loc + vec3(0.0, 0.0, -step[2]));
+      val2 = sample1(loc + vec3(0.0, 0.0, +step[2]));
+      N[2] = val1 - val2;
+      val = max(max(val1, val2), val);
+
+      float gm = length(N); // gradient magnitude
+      N = normalize(N);
+
+      // Flip normal so it points towards viewer
+      float Nselect = float(dot(N, V) > 0.0);
+      N = (2.0 * Nselect - 1.0) * N;	// ==	Nselect * N - (1.0-Nselect)*N;
+
+      // Init colors
+      vec4 ambient_color = vec4(0.0, 0.0, 0.0, 0.0);
+      vec4 diffuse_color = vec4(0.0, 0.0, 0.0, 0.0);
+      vec4 specular_color = vec4(0.0, 0.0, 0.0, 0.0);
+
+      // note: could allow multiple lights
+      for (int i=0; i<1; i++)
+      {
+            // Get light direction (make sure to prevent zero devision)
+          vec3 L = normalize(view_ray);	//lightDirs[i];
+          float lightEnabled = float( length(L) > 0.0 );
+          L = normalize(L + (1.0 - lightEnabled));
+
+          // Calculate lighting properties
+          float lambertTerm = clamp(dot(N, L), 0.0, 1.0);
+          vec3 H = normalize(L+V); // Halfway vector
+          float specularTerm = pow(max(dot(H, N), 0.0), shininess);
+
+          // Calculate mask
+          float mask1 = lightEnabled;
+
+          // Calculate colors
+          ambient_color +=	mask1 * ambient_color;	// * gl_LightSource[i].ambient;
+          diffuse_color +=	mask1 * lambertTerm;
+          specular_color += mask1 * specularTerm * specular_color;
+      }
+
+      // Calculate final color by componing different components
+      vec4 final_color;
+      vec4 color = apply_colormap(val);
+      final_color = color * (ambient_color + diffuse_color) + specular_color;
+      final_color.a = color.a;
+      return final_color;
+  }
+`;
+
+const vs = 
+`
+  varying vec4 v_nearpos;
+  varying vec4 v_farpos;
+  varying vec3 v_position;
+
+  void main() {
+      // Prepare transforms to map to "camera view". See also:
+      // https://threejs.org/docs/#api/renderers/webgl/WebGLProgram
+      mat4 viewtransformf = modelViewMatrix;
+      mat4 viewtransformi = inverse(modelViewMatrix);
+
+      // Project local vertex coordinate to camera position. Then do a step
+      // backward (in cam coords) to the near clipping plane, and project back. Do
+      // the same for the far clipping plane. This gives us all the information we
+      // need to calculate the ray and truncate it to the viewing cone.
+      vec4 position4 = vec4(position, 1.0);
+      vec4 pos_in_cam = viewtransformf * position4;
+
+      // Intersection of ray and near clipping plane (z = -1 in clip coords)
+      pos_in_cam.z = -pos_in_cam.w;
+      v_nearpos = viewtransformi * pos_in_cam;
+
+      // Intersection of ray and far clipping plane (z = +1 in clip coords)
+      pos_in_cam.z = pos_in_cam.w;
+      v_farpos = viewtransformi * pos_in_cam;
+
+      // Set varyings and output pos
+      v_position = position;
+      gl_Position = projectionMatrix * viewMatrix * modelMatrix * position4;
+  }
+`;
+
+const getUniforms = function() {
+  return {
+		u_size: { value: new THREE.Vector3( 1, 1, 1 ) },
+		u_renderstyle: { value: 0 },
+		u_renderthreshold: { value: 0.5 },
+		u_clim: { value: new THREE.Vector2( 1, 1 ) },
+		u_data: { value: null },
+		u_cmdata: { value: null },
+  }
+};
+
+exports.fs = fs;
+exports.vs = vs;
+exports.glslVersion = glslVersion;
+exports.getUniforms = getUniforms;