p5 2.0.0 → 2.0.1

package/src/webgl/shaders/filters/dilate.frag

@@ -1,39 +0,0 @@
-// Increase the bright areas in an image
-
-precision highp float;
-
-varying vec2 vTexCoord;
-
-uniform sampler2D tex0;
-uniform vec2 texelSize;
-
-float luma(vec3 color) {
-  // weighted grayscale with luminance values
-  // weights 77, 151, 28 taken from src/image/filters.js
-  return dot(color, vec3(0.300781, 0.589844, 0.109375));
-}
-
-void main() {
-  vec4 color = texture2D(tex0, vTexCoord);
-  float lum = luma(color.rgb);
-
-  // set current color as the brightest neighbor color
-
-  vec4 neighbors[4];
-  neighbors[0] = texture2D(tex0, vTexCoord + vec2( texelSize.x, 0.0));
-  neighbors[1] = texture2D(tex0, vTexCoord + vec2(-texelSize.x, 0.0));
-  neighbors[2] = texture2D(tex0, vTexCoord + vec2(0.0,  texelSize.y));
-  neighbors[3] = texture2D(tex0, vTexCoord + vec2(0.0, -texelSize.y));
-
-  for (int i = 0; i < 4; i++) {
-    vec4 neighborColor = neighbors[i];
-    float neighborLum = luma(neighborColor.rgb);
-
-    if (neighborLum > lum) {
-      color = neighborColor;
-      lum = neighborLum;
-    }
-  }
-
-  gl_FragColor = color;
-}

package/src/webgl/shaders/filters/erode.frag

@@ -1,39 +0,0 @@
-// Reduces the bright areas in an image
-
-precision highp float;
-
-varying vec2 vTexCoord;
-
-uniform sampler2D tex0;
-uniform vec2 texelSize;
-
-float luma(vec3 color) {
-  // weighted grayscale with luminance values
-  // weights 77, 151, 28 taken from src/image/filters.js
-  return dot(color, vec3(0.300781, 0.589844, 0.109375));
-}
-
-void main() {
-  vec4 color = texture2D(tex0, vTexCoord);
-  float lum = luma(color.rgb);
-
-  // set current color as the darkest neighbor color
-
-  vec4 neighbors[4];
-  neighbors[0] = texture2D(tex0, vTexCoord + vec2( texelSize.x, 0.0));
-  neighbors[1] = texture2D(tex0, vTexCoord + vec2(-texelSize.x, 0.0));
-  neighbors[2] = texture2D(tex0, vTexCoord + vec2(0.0,  texelSize.y));
-  neighbors[3] = texture2D(tex0, vTexCoord + vec2(0.0, -texelSize.y));
-
-  for (int i = 0; i < 4; i++) {
-    vec4 neighborColor = neighbors[i];
-    float neighborLum = luma(neighborColor.rgb);
-
-    if (neighborLum < lum) {
-      color = neighborColor;
-      lum = neighborLum;
-    }
-  }
-
-  gl_FragColor = color;
-}

package/src/webgl/shaders/filters/gray.frag

@@ -1,16 +0,0 @@
-precision highp float;
-
-varying vec2 vTexCoord;
-
-uniform sampler2D tex0;
-
-float luma(vec3 color) {
-  // weighted grayscale with luminance values
-  return dot(color, vec3(0.2126, 0.7152, 0.0722));
-}
-
-void main() {
-  vec4 tex = texture2D(tex0, vTexCoord);
-  float gray = luma(tex.rgb);
-  gl_FragColor = vec4(gray, gray, gray, tex.a);
-}

package/src/webgl/shaders/filters/invert.frag

@@ -1,15 +0,0 @@
-// Set each pixel to inverse value
-// Note that original INVERT does not change the opacity, so this follows suit
-
-precision highp float;
-
-varying vec2 vTexCoord;
-
-uniform sampler2D tex0;
-
-void main() {
-vec4 color = texture2D(tex0, vTexCoord);
-vec3 origColor = color.rgb / color.a;
-vec3 invertedColor = vec3(1.0) - origColor;
-gl_FragColor = vec4(invertedColor * color.a, color.a);
-}

package/src/webgl/shaders/filters/opaque.frag

@@ -1,12 +0,0 @@
-// Set alpha channel to entirely opaque
-
-precision highp float;
-
-varying vec2 vTexCoord;
-
-uniform sampler2D tex0;
-
-void main() {
-  vec4 color = texture2D(tex0, vTexCoord);
-  gl_FragColor = vec4(color.rgb / color.a, 1.0);
-}

package/src/webgl/shaders/filters/posterize.frag

@@ -1,29 +0,0 @@
-// Limit color space for a stylized cartoon / poster effect
-
-precision highp float;
-
-varying vec2 vTexCoord;
-
-uniform sampler2D tex0;
-uniform float filterParameter;
-
-vec3 quantize(vec3 color, float n) {
-  // restrict values to N options/bins
-  // and floor each channel to nearest value
-  //
-  // eg. when N = 5, values = 0.0, 0.25, 0.50, 0.75, 1.0
-  // then quantize (0.1, 0.7, 0.9) -> (0.0, 0.5, 1.0)
-
-  color = color * n;
-  color = floor(color);
-  color = color / (n - 1.0);
-  return color;
-}
-
-void main() {
-  vec4 color = texture2D(tex0, vTexCoord);
-
-  vec3 restrictedColor = quantize(color.rgb / color.a, filterParameter);
-
-  gl_FragColor = vec4(restrictedColor.rgb * color.a, color.a);
-}

package/src/webgl/shaders/filters/threshold.frag

@@ -1,23 +0,0 @@
-// Convert pixels to either white or black, 
-// depending on if their luma is above or below filterParameter
-
-precision highp float;
-
-varying vec2 vTexCoord;
-
-uniform sampler2D tex0;
-uniform float filterParameter;
-
-float luma(vec3 color) {
-  // weighted grayscale with luminance values
-  return dot(color, vec3(0.2126, 0.7152, 0.0722));
-}
-
-void main() {
-  vec4 color = texture2D(tex0, vTexCoord);
-  float gray = luma(color.rgb / color.a);
-  // floor() used to match src/image/filters.js
-  float threshold = floor(filterParameter * 255.0) / 255.0;
-  float blackOrWhite = step(threshold, gray);
-  gl_FragColor = vec4(vec3(blackOrWhite) * color.a, color.a);
-}

package/src/webgl/shaders/font.frag

@@ -1,216 +0,0 @@
-#ifndef WEBGL2
-#extension GL_OES_standard_derivatives : enable
-#endif
-
-#if 0
-  // simulate integer math using floats
-	#define int float
-	#define ivec2 vec2
-	#define INT(x) float(x)
-
-	int ifloor(float v) { return floor(v); }
-	ivec2 ifloor(vec2 v) { return floor(v); }
-
-#else
-  // use native integer math
-	precision highp int;
-	#define INT(x) x
-
-	int ifloor(float v) { return int(v); }
-	int ifloor(int v) { return v; }
-	ivec2 ifloor(vec2 v) { return ivec2(v); }
-
-#endif
-
-uniform sampler2D uSamplerStrokes;
-uniform sampler2D uSamplerRowStrokes;
-uniform sampler2D uSamplerRows;
-uniform sampler2D uSamplerColStrokes;
-uniform sampler2D uSamplerCols;
-
-uniform ivec2 uStrokeImageSize;
-uniform ivec2 uCellsImageSize;
-uniform ivec2 uGridImageSize;
-
-uniform ivec2 uGridOffset;
-uniform ivec2 uGridSize;
-uniform vec4 uMaterialColor;
-
-IN vec2 vTexCoord;
-
-// some helper functions
-int ROUND(float v) { return ifloor(v + 0.5); }
-ivec2 ROUND(vec2 v) { return ifloor(v + 0.5); }
-float saturate(float v) { return clamp(v, 0.0, 1.0); }
-vec2 saturate(vec2 v) { return clamp(v, 0.0, 1.0); }
-
-int mul(float v1, int v2) {
-  return ifloor(v1 * float(v2));
-}
-
-ivec2 mul(vec2 v1, ivec2 v2) {
-  return ifloor(v1 * vec2(v2) + 0.5);
-}
-
-// unpack a 16-bit integer from a float vec2
-int getInt16(vec2 v) {
-  ivec2 iv = ROUND(v * 255.0);
-  return iv.x * INT(128) + iv.y;
-}
-
-vec2 pixelScale;
-vec2 coverage = vec2(0.0);
-vec2 weight = vec2(0.5);
-const float minDistance = 1.0/8192.0;
-const float hardness = 1.05; // amount of antialias
-
-// the maximum number of curves in a glyph
-const int N = INT(250);
-
-// retrieves an indexed pixel from a sampler
-vec4 getTexel(sampler2D sampler, int pos, ivec2 size) {
-  int width = size.x;
-  int y = ifloor(pos / width);
-  int x = pos - y * width;  // pos % width
-
-  return TEXTURE(sampler, (vec2(x, y) + 0.5) / vec2(size));
-}
-
-void calulateCrossings(vec2 p0, vec2 p1, vec2 p2, out vec2 C1, out vec2 C2) {
-
-  // get the coefficients of the quadratic in t
-  vec2 a = p0 - p1 * 2.0 + p2;
-  vec2 b = p0 - p1;
-  vec2 c = p0 - vTexCoord;
-
-  // found out which values of 't' it crosses the axes
-  vec2 surd = sqrt(max(vec2(0.0), b * b - a * c));
-  vec2 t1 = ((b - surd) / a).yx;
-  vec2 t2 = ((b + surd) / a).yx;
-
-  // approximate straight lines to avoid rounding errors
-  if (abs(a.y) < 0.001)
-    t1.x = t2.x = c.y / (2.0 * b.y);
-
-  if (abs(a.x) < 0.001)
-    t1.y = t2.y = c.x / (2.0 * b.x);
-
-  // plug into quadratic formula to find the corrdinates of the crossings
-  C1 = ((a * t1 - b * 2.0) * t1 + c) * pixelScale;
-  C2 = ((a * t2 - b * 2.0) * t2 + c) * pixelScale;
-}
-
-void coverageX(vec2 p0, vec2 p1, vec2 p2) {
-
-  vec2 C1, C2;
-  calulateCrossings(p0, p1, p2, C1, C2);
-
-  // determine on which side of the x-axis the points lie
-  bool y0 = p0.y > vTexCoord.y;
-  bool y1 = p1.y > vTexCoord.y;
-  bool y2 = p2.y > vTexCoord.y;
-
-  // could web be under the curve (after t1)?
-  if (y1 ? !y2 : y0) {
-    // add the coverage for t1
-    coverage.x += saturate(C1.x + 0.5);
-    // calculate the anti-aliasing for t1
-    weight.x = min(weight.x, abs(C1.x));
-  }
-
-  // are we outside the curve (after t2)?
-  if (y1 ? !y0 : y2) {
-    // subtract the coverage for t2
-    coverage.x -= saturate(C2.x + 0.5);
-    // calculate the anti-aliasing for t2
-    weight.x = min(weight.x, abs(C2.x));
-  }
-}
-
-// this is essentially the same as coverageX, but with the axes swapped
-void coverageY(vec2 p0, vec2 p1, vec2 p2) {
-
-  vec2 C1, C2;
-  calulateCrossings(p0, p1, p2, C1, C2);
-
-  bool x0 = p0.x > vTexCoord.x;
-  bool x1 = p1.x > vTexCoord.x;
-  bool x2 = p2.x > vTexCoord.x;
-
-  if (x1 ? !x2 : x0) {
-    coverage.y -= saturate(C1.y + 0.5);
-    weight.y = min(weight.y, abs(C1.y));
-  }
-
-  if (x1 ? !x0 : x2) {
-    coverage.y += saturate(C2.y + 0.5);
-    weight.y = min(weight.y, abs(C2.y));
-  }
-}
-
-void main() {
-
-  // calculate the pixel scale based on screen-coordinates
-  pixelScale = hardness / fwidth(vTexCoord);
-
-  // which grid cell is this pixel in?
-  ivec2 gridCoord = ifloor(vTexCoord * vec2(uGridSize));
-
-  // intersect curves in this row
-  {
-    // the index into the row info bitmap
-    int rowIndex = gridCoord.y + uGridOffset.y;
-    // fetch the info texel
-    vec4 rowInfo = getTexel(uSamplerRows, rowIndex, uGridImageSize);
-    // unpack the rowInfo
-    int rowStrokeIndex = getInt16(rowInfo.xy);
-    int rowStrokeCount = getInt16(rowInfo.zw);
-
-    for (int iRowStroke = INT(0); iRowStroke < N; iRowStroke++) {
-      if (iRowStroke >= rowStrokeCount)
-        break;
-
-      // each stroke is made up of 3 points: the start and control point
-      // and the start of the next curve.
-      // fetch the indices of this pair of strokes:
-      vec4 strokeIndices = getTexel(uSamplerRowStrokes, rowStrokeIndex++, uCellsImageSize);
-
-      // unpack the stroke index
-      int strokePos = getInt16(strokeIndices.xy);
-
-      // fetch the two strokes
-      vec4 stroke0 = getTexel(uSamplerStrokes, strokePos + INT(0), uStrokeImageSize);
-      vec4 stroke1 = getTexel(uSamplerStrokes, strokePos + INT(1), uStrokeImageSize);
-
-      // calculate the coverage
-      coverageX(stroke0.xy, stroke0.zw, stroke1.xy);
-    }
-  }
-
-  // intersect curves in this column
-  {
-    int colIndex = gridCoord.x + uGridOffset.x;
-    vec4 colInfo = getTexel(uSamplerCols, colIndex, uGridImageSize);
-    int colStrokeIndex = getInt16(colInfo.xy);
-    int colStrokeCount = getInt16(colInfo.zw);
-    
-    for (int iColStroke = INT(0); iColStroke < N; iColStroke++) {
-      if (iColStroke >= colStrokeCount)
-        break;
-
-      vec4 strokeIndices = getTexel(uSamplerColStrokes, colStrokeIndex++, uCellsImageSize);
-
-      int strokePos = getInt16(strokeIndices.xy);
-      vec4 stroke0 = getTexel(uSamplerStrokes, strokePos + INT(0), uStrokeImageSize);
-      vec4 stroke1 = getTexel(uSamplerStrokes, strokePos + INT(1), uStrokeImageSize);
-      coverageY(stroke0.xy, stroke0.zw, stroke1.xy);
-    }
-  }
-
-  weight = saturate(1.0 - weight * 2.0);
-  float distance = max(weight.x + weight.y, minDistance); // manhattan approx.
-  float antialias = abs(dot(coverage, weight) / distance);
-  float cover = min(abs(coverage.x), abs(coverage.y));
-  OUT_COLOR = vec4(uMaterialColor.rgb, 1.) * uMaterialColor.a;
-  OUT_COLOR *= saturate(max(antialias, cover));
-}

package/src/webgl/shaders/font.vert

@@ -1,44 +0,0 @@
-IN vec3 aPosition;
-IN vec2 aTexCoord;
-uniform mat4 uModelViewMatrix;
-uniform mat4 uProjectionMatrix;
-
-uniform vec4 uGlyphRect;
-uniform float uGlyphOffset;
-
-OUT vec2 vTexCoord;
-OUT float w;
-
-void main() {
-  vec4 positionVec4 = vec4(aPosition, 1.0);
-
-  // scale by the size of the glyph's rectangle
-  positionVec4.xy *= uGlyphRect.zw - uGlyphRect.xy;
-
-  // Expand glyph bounding boxes by 1px on each side to give a bit of room
-  // for antialiasing
-  vec3 newOrigin = (uModelViewMatrix * vec4(0., 0., 0., 1.)).xyz;
-  vec3 newDX = (uModelViewMatrix * vec4(1., 0., 0., 1.)).xyz;
-  vec3 newDY = (uModelViewMatrix * vec4(0., 1., 0., 1.)).xyz;
-  vec2 pixelScale = vec2(
-    1. / length(newOrigin - newDX),
-    1. / length(newOrigin - newDY)
-  );
-  vec2 offset = pixelScale * normalize(aTexCoord - vec2(0.5, 0.5));
-  vec2 textureOffset = offset * (1. / vec2(
-    uGlyphRect.z - uGlyphRect.x,
-    uGlyphRect.w - uGlyphRect.y
-  ));
-
-  // move to the corner of the glyph
-  positionVec4.xy += uGlyphRect.xy;
-
-  // move to the letter's line offset
-  positionVec4.x += uGlyphOffset;
-
-  positionVec4.xy += offset;
-  
-  gl_Position = uProjectionMatrix * uModelViewMatrix * positionVec4;
-  vTexCoord = aTexCoord + textureOffset;
-  w = gl_Position.w;
-}

package/src/webgl/shaders/imageLight.vert

@@ -1,33 +0,0 @@
-precision highp float;
-attribute vec3 aPosition;
-attribute vec3 aNormal;
-attribute vec2 aTexCoord;
-
-varying vec3 localPos;
-varying vec3 vWorldNormal;
-varying vec3 vWorldPosition;
-varying vec2 vTexCoord;
-
-uniform mat4 uModelViewMatrix;
-uniform mat4 uProjectionMatrix;
-uniform mat3 uNormalMatrix;
-
-void main() {
-  // Multiply the position by the matrix.
-  vec4 viewModelPosition = uModelViewMatrix * vec4(aPosition, 1.0);
-  gl_Position = uProjectionMatrix * viewModelPosition;  
-  
-  // orient the normals and pass to the fragment shader
-  vWorldNormal = uNormalMatrix * aNormal;
-  
-  // send the view position to the fragment shader
-  vWorldPosition = (uModelViewMatrix * vec4(aPosition, 1.0)).xyz;
-  
-  localPos = vWorldPosition;
-  vTexCoord = aTexCoord;
-}
-
-
-/*
-in the vertex shader we'll compute the world position and world oriented normal of the vertices and pass those to the fragment shader as varyings.
-*/

package/src/webgl/shaders/imageLightDiffused.frag

@@ -1,82 +0,0 @@
-precision highp float;
-varying vec3 localPos;
-
-// the HDR cubemap converted (can be from an equirectangular environment map.)
-uniform sampler2D environmentMap;
-varying vec2 vTexCoord;
-
-const float PI = 3.14159265359;
-
-vec2 nTOE( vec3 v ){
-  // x = r sin(phi) cos(theta)   
-  // y = r cos(phi)  
-  // z = r sin(phi) sin(theta)
-  float phi = acos( v.y );
-  // if phi is 0, then there are no x, z components
-  float theta = 0.0;
-  // else 
-  theta = acos(v.x / sin(phi));
-  float sinTheta = v.z / sin(phi);
-  if (sinTheta < 0.0) {
-    // Turn it into -theta, but in the 0-2PI range
-    theta = 2.0 * PI - theta;
-  }
-  theta = theta / (2.0 * 3.14159);
-  phi = phi / 3.14159 ;
-  
-  vec2 angles = vec2( phi, theta );
-  return angles;
-}
-
-float random(vec2 p) {
-  vec3 p3  = fract(vec3(p.xyx) * .1031);
-  p3 += dot(p3, p3.yzx + 33.33);
-  return fract((p3.x + p3.y) * p3.z);
-}
-
-void main()
-{   	 
-	// the sample direction equals the hemisphere's orientation
-  float phi = vTexCoord.x * 2.0 * PI;
-  float theta = vTexCoord.y * PI;
-  float x = sin(theta) * cos(phi);
-  float y = sin(theta) * sin(phi);
-  float z = cos(theta);
-  vec3 normal = vec3( x, y, z);
-
-	// Discretely sampling the hemisphere given the integral's
-  // spherical coordinates translates to the following fragment code:
-	vec3 irradiance = vec3(0.0);  
-	vec3 up	= vec3(0.0, 1.0, 0.0);
-	vec3 right = normalize(cross(up, normal));
-	up = normalize(cross(normal, right));
-
-	//  We specify a fixed sampleDelta delta value to traverse
-  // the hemisphere; decreasing or increasing the sample delta
-  // will increase or decrease the accuracy respectively.
-	const float sampleDelta = 0.100;
-	float nrSamples = 0.0;
-  float randomOffset = random(gl_FragCoord.xy) * sampleDelta;
-	for(float rawPhi = 0.0; rawPhi < 2.0 * PI; rawPhi += sampleDelta)
-	{
-    float phi = rawPhi + randomOffset;
-    for(float rawTheta = 0.0; rawTheta < ( 0.5 ) * PI; rawTheta += sampleDelta)
-    {
-      float theta = rawTheta + randomOffset;
-      // spherical to cartesian (in tangent space) // tangent space to world // add each sample result to irradiance
-      float x = sin(theta) * cos(phi);
-      float y = sin(theta) * sin(phi);
-      float z = cos(theta);
-      vec3 tangentSample = vec3( x, y, z);
-      
-      vec3 sampleVec = tangentSample.x * right + tangentSample.y * up + tangentSample.z * normal;
-        irradiance += (texture2D(environmentMap, nTOE(sampleVec)).xyz) * cos(theta) * sin(theta);
-      nrSamples++;
-    }
-	}
-	// divide by the total number of samples taken, giving us the average sampled irradiance.
-	irradiance = PI * irradiance * (1.0 / float(nrSamples )) ;
-  
- 
-	gl_FragColor = vec4(irradiance, 1.0);
-}

package/src/webgl/shaders/imageLightSpecular.frag

@@ -1,134 +0,0 @@
-precision highp float;
-varying vec3 localPos;
-varying vec2 vTexCoord;
-
-// our texture
-uniform sampler2D environmentMap;
-uniform float roughness;
-
-const float PI = 3.14159265359;
-
-float VanDerCorput(int bits);
-vec2 HammersleyNoBitOps(int i, int N);
-vec3 ImportanceSampleGGX(vec2 Xi, vec3 N, float roughness);
-
-
-vec2 nTOE( vec3 v ){
-  // x = r sin(phi) cos(theta)   
-  // y = r cos(phi)  
-  // z = r sin(phi) sin(theta)
-  float phi = acos( v.y );
-  // if phi is 0, then there are no x, z components
-  float theta = 0.0;
-  // else 
-  theta = acos(v.x / sin(phi));
-  float sinTheta = v.z / sin(phi);
-  if (sinTheta < 0.0) {
-    // Turn it into -theta, but in the 0-2PI range
-    theta = 2.0 * PI - theta;
-  }
-  theta = theta / (2.0 * 3.14159);
-  phi = phi / 3.14159 ;
-  
-  vec2 angles = vec2( phi, theta );
-  return angles;
-}
-
-
-void main(){
-  const int SAMPLE_COUNT = 400; // 4096
-  int lowRoughnessLimit = int(pow(2.0,(roughness+0.1)*20.0));
-  float totalWeight = 0.0;
-  vec3 prefilteredColor = vec3(0.0);
-  float phi = vTexCoord.x * 2.0 * PI;
-  float theta = vTexCoord.y * PI;
-  float x = sin(theta) * cos(phi);
-  float y = sin(theta) * sin(phi);
-  float z = cos(theta);
-  vec3 N = vec3(x,y,z);
-  vec3 V = N;
-  for (int i = 0; i < SAMPLE_COUNT; ++i)
-  {
-    // break at smaller sample numbers for low roughness levels
-    if(i == lowRoughnessLimit)
-    {
-      break;
-    }
-    vec2 Xi = HammersleyNoBitOps(i, SAMPLE_COUNT);
-    vec3 H = ImportanceSampleGGX(Xi, N, roughness);
-    vec3 L = normalize(2.0 * dot(V, H) * H - V);
-
-    float NdotL = max(dot(N, L), 0.0);
-    if (NdotL > 0.0)
-    {
-      prefilteredColor += texture2D(environmentMap, nTOE(L)).xyz * NdotL;
-      totalWeight += NdotL;
-    }
-  }
-  prefilteredColor = prefilteredColor / totalWeight;
-
-  gl_FragColor = vec4(prefilteredColor, 1.0);
-}
-
-vec3 ImportanceSampleGGX(vec2 Xi, vec3 N, float roughness){
-  float a = roughness * roughness;
-
-  float phi = 2.0 * PI * Xi.x;
-  float cosTheta = sqrt((1.0 - Xi.y) / (1.0 + (a * a - 1.0) * Xi.y));
-  float sinTheta = sqrt(1.0 - cosTheta * cosTheta);
-  // from spherical coordinates to cartesian coordinates
-  vec3 H;
-  H.x = cos(phi) * sinTheta;
-  H.y = sin(phi) * sinTheta;
-  H.z = cosTheta;
-
-  // from tangent-space vector to world-space sample vector
-  vec3 up = abs(N.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
-  vec3 tangent = normalize(cross(up, N));
-  vec3 bitangent = cross(N, tangent);
-
-  vec3 sampleVec = tangent * H.x + bitangent * H.y + N * H.z;
-  return normalize(sampleVec);
-}
-
-
-float VanDerCorput(int n, int base)
-{
-#ifdef WEBGL2
-
-    uint bits = uint(n);
-    bits = (bits << 16u) | (bits >> 16u);
-    bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u);
-    bits = ((bits & 0x33333333u) << 2u) | ((bits & 0xCCCCCCCCu) >> 2u);
-    bits = ((bits & 0x0F0F0F0Fu) << 4u) | ((bits & 0xF0F0F0F0u) >> 4u);
-    bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u);
-    return float(bits) * 2.3283064365386963e-10; // / 0x100000000
-
-#else
-
-  float invBase = 1.0 / float(base);
-  float denom = 1.0;
-  float result = 0.0;
-
-
-  for (int i = 0; i < 32; ++i)
-  {
-        if (n > 0)
-        {
-        denom = mod(float(n), 2.0);
-        result += denom * invBase;
-        invBase = invBase / 2.0;
-        n = int(float(n) / 2.0);
-        }
-  }
-
-
-  return result;
-
-#endif
-}
-
-vec2 HammersleyNoBitOps(int i, int N)
-{
-  return vec2(float(i) / float(N), VanDerCorput(i, 2));
-}