@luma.gl/shaders 0.0.0-stage → 10.0.0-alpha.11

package/src/modules/math/fp16/fp16-utils.ts

@@ -0,0 +1,156 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) three.js authors
+
+// Forked from THREE.js under MIT license
+// Fast Half Float Conversions, http://www.fox-toolkit.org/ftp/fasthalffloatconversion.pdf
+
+import {clamp} from '@math.gl/core';
+
+/** Pre-calculated tables for float16 conversion */
+type Float16Tables = {
+  // float32 to float16 helpers
+  baseTable: Uint32Array;
+  shiftTable: Uint32Array;
+  // float16 to float32 helpers
+  mantissaTable: Uint32Array;
+  exponentTable: Uint32Array;
+  offsetTable: Uint32Array;
+};
+
+/**  */
+let float16Tables: Float16Tables | null = null;
+
+/** Storage that can be viewed both as float and integer */
+const buffer = new ArrayBuffer(4);
+const floatView = new Float32Array(buffer);
+const uint32View = new Uint32Array(buffer);
+
+/**
+ * float32 to float16
+ * @param val
+ * @returns
+ */
+export function toHalfFloat(val: number): number {
+  float16Tables ||= generateFloat16Tables();
+
+  // if ( Math.abs( val ) > 65504 ) console.warn( 'toHalfFloat(): Value out of range.' );
+
+  val = clamp(val, -65504, 65504);
+
+  floatView[0] = val;
+  const f = uint32View[0];
+  const e = (f >> 23) & 0x1ff;
+  return float16Tables.baseTable[e] + ((f & 0x007fffff) >> float16Tables.shiftTable[e]);
+}
+
+/**
+ * float16 to float32
+ * @param val
+ * @returns
+ */
+export function fromHalfFloat(val: number): number {
+  float16Tables ||= generateFloat16Tables();
+
+  const m = val >> 10;
+  uint32View[0] =
+    float16Tables.mantissaTable[float16Tables.offsetTable[m] + (val & 0x3ff)] +
+    float16Tables.exponentTable[m];
+  return floatView[0];
+}
+
+function generateFloat16Tables(): Float16Tables {
+  // float32 to float16 helpers
+
+  const baseTable = new Uint32Array(512);
+  const shiftTable = new Uint32Array(512);
+
+  for (let i = 0; i < 256; ++i) {
+    const e = i - 127;
+
+    // very small number (0, -0)
+
+    if (e < -27) {
+      baseTable[i] = 0x0000;
+      baseTable[i | 0x100] = 0x8000;
+      shiftTable[i] = 24;
+      shiftTable[i | 0x100] = 24;
+
+      // small number (denorm)
+    } else if (e < -14) {
+      baseTable[i] = 0x0400 >> (-e - 14);
+      baseTable[i | 0x100] = (0x0400 >> (-e - 14)) | 0x8000;
+      shiftTable[i] = -e - 1;
+      shiftTable[i | 0x100] = -e - 1;
+
+      // normal number
+    } else if (e <= 15) {
+      baseTable[i] = (e + 15) << 10;
+      baseTable[i | 0x100] = ((e + 15) << 10) | 0x8000;
+      shiftTable[i] = 13;
+      shiftTable[i | 0x100] = 13;
+
+      // large number (Infinity, -Infinity)
+    } else if (e < 128) {
+      baseTable[i] = 0x7c00;
+      baseTable[i | 0x100] = 0xfc00;
+      shiftTable[i] = 24;
+      shiftTable[i | 0x100] = 24;
+
+      // stay (NaN, Infinity, -Infinity)
+    } else {
+      baseTable[i] = 0x7c00;
+      baseTable[i | 0x100] = 0xfc00;
+      shiftTable[i] = 13;
+      shiftTable[i | 0x100] = 13;
+    }
+  }
+
+  // float16 to float32 helpers
+
+  const mantissaTable = new Uint32Array(2048);
+  const exponentTable = new Uint32Array(64);
+  const offsetTable = new Uint32Array(64);
+
+  for (let i = 1; i < 1024; ++i) {
+    let m = i << 13; // zero pad mantissa bits
+    let e = 0; // zero exponent
+
+    // normalized
+    while ((m & 0x00800000) === 0) {
+      m <<= 1;
+      e -= 0x00800000; // decrement exponent
+    }
+
+    m &= ~0x00800000; // clear leading 1 bit
+    e += 0x38800000; // adjust bias
+
+    mantissaTable[i] = m | e;
+  }
+
+  for (let i = 1024; i < 2048; ++i) {
+    mantissaTable[i] = 0x38000000 + ((i - 1024) << 13);
+  }
+
+  for (let i = 1; i < 31; ++i) {
+    exponentTable[i] = i << 23;
+  }
+
+  exponentTable[31] = 0x47800000;
+  exponentTable[32] = 0x80000000;
+
+  for (let i = 33; i < 63; ++i) {
+    exponentTable[i] = 0x80000000 + ((i - 32) << 23);
+  }
+
+  exponentTable[63] = 0xc7800000;
+
+  for (let i = 1; i < 64; ++i) {
+    if (i !== 32) {
+      offsetTable[i] = 1024;
+    }
+  }
+
+  return {baseTable, shiftTable, mantissaTable, exponentTable, offsetTable};
+}

package/src/modules/math/fp32/fp32.ts

@@ -0,0 +1,291 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+// import {ShaderModule} from '../../types';
+
+const fp32shader = /* glsl */ `\
+#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND
+
+// All these functions are for substituting tan() function from Intel GPU only
+const float TWO_PI = 6.2831854820251465;
+const float PI_2 = 1.5707963705062866;
+const float PI_16 = 0.1963495463132858;
+
+const float SIN_TABLE_0 = 0.19509032368659973;
+const float SIN_TABLE_1 = 0.3826834261417389;
+const float SIN_TABLE_2 = 0.5555702447891235;
+const float SIN_TABLE_3 = 0.7071067690849304;
+
+const float COS_TABLE_0 = 0.9807852506637573;
+const float COS_TABLE_1 = 0.9238795042037964;
+const float COS_TABLE_2 = 0.8314695954322815;
+const float COS_TABLE_3 = 0.7071067690849304;
+
+const float INVERSE_FACTORIAL_3 = 1.666666716337204e-01; // 1/3!
+const float INVERSE_FACTORIAL_5 = 8.333333767950535e-03; // 1/5!
+const float INVERSE_FACTORIAL_7 = 1.9841270113829523e-04; // 1/7!
+const float INVERSE_FACTORIAL_9 = 2.75573188446287533e-06; // 1/9!
+
+float sin_taylor_fp32(float a) {
+  float r, s, t, x;
+
+  if (a == 0.0) {
+    return 0.0;
+  }
+
+  x = -a * a;
+  s = a;
+  r = a;
+
+  r = r * x;
+  t = r * INVERSE_FACTORIAL_3;
+  s = s + t;
+
+  r = r * x;
+  t = r * INVERSE_FACTORIAL_5;
+  s = s + t;
+
+  r = r * x;
+  t = r * INVERSE_FACTORIAL_7;
+  s = s + t;
+
+  r = r * x;
+  t = r * INVERSE_FACTORIAL_9;
+  s = s + t;
+
+  return s;
+}
+
+void sincos_taylor_fp32(float a, out float sin_t, out float cos_t) {
+  if (a == 0.0) {
+    sin_t = 0.0;
+    cos_t = 1.0;
+  }
+  sin_t = sin_taylor_fp32(a);
+  cos_t = sqrt(1.0 - sin_t * sin_t);
+}
+
+float tan_taylor_fp32(float a) {
+    float sin_a;
+    float cos_a;
+
+    if (a == 0.0) {
+        return 0.0;
+    }
+
+    // 2pi range reduction
+    float z = floor(a / TWO_PI);
+    float r = a - TWO_PI * z;
+
+    float t;
+    float q = floor(r / PI_2 + 0.5);
+    int j = int(q);
+
+    if (j < -2 || j > 2) {
+        return 1.0 / 0.0;
+    }
+
+    t = r - PI_2 * q;
+
+    q = floor(t / PI_16 + 0.5);
+    int k = int(q);
+    int abs_k = int(abs(float(k)));
+
+    if (abs_k > 4) {
+        return 1.0 / 0.0;
+    } else {
+        t = t - PI_16 * q;
+    }
+
+    float u = 0.0;
+    float v = 0.0;
+
+    float sin_t, cos_t;
+    float s, c;
+    sincos_taylor_fp32(t, sin_t, cos_t);
+
+    if (k == 0) {
+        s = sin_t;
+        c = cos_t;
+    } else {
+        if (abs(float(abs_k) - 1.0) < 0.5) {
+            u = COS_TABLE_0;
+            v = SIN_TABLE_0;
+        } else if (abs(float(abs_k) - 2.0) < 0.5) {
+            u = COS_TABLE_1;
+            v = SIN_TABLE_1;
+        } else if (abs(float(abs_k) - 3.0) < 0.5) {
+            u = COS_TABLE_2;
+            v = SIN_TABLE_2;
+        } else if (abs(float(abs_k) - 4.0) < 0.5) {
+            u = COS_TABLE_3;
+            v = SIN_TABLE_3;
+        }
+        if (k > 0) {
+            s = u * sin_t + v * cos_t;
+            c = u * cos_t - v * sin_t;
+        } else {
+            s = u * sin_t - v * cos_t;
+            c = u * cos_t + v * sin_t;
+        }
+    }
+
+    if (j == 0) {
+        sin_a = s;
+        cos_a = c;
+    } else if (j == 1) {
+        sin_a = c;
+        cos_a = -s;
+    } else if (j == -1) {
+        sin_a = -c;
+        cos_a = s;
+    } else {
+        sin_a = -s;
+        cos_a = -c;
+    }
+    return sin_a / cos_a;
+}
+#endif
+
+float tan_fp32(float a) {
+#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND
+  return tan_taylor_fp32(a);
+#else
+  return tan(a);
+#endif
+}
+`;
+
+const fp32WGSL = /* wgsl */ `\
+#ifdef LUMA_FP32_TAN_PRECISION_WORKAROUND
+const FP32_TWO_PI: f32 = 6.2831854820251465;
+const FP32_PI_2: f32 = 1.5707963705062866;
+const FP32_PI_16: f32 = 0.1963495463132858;
+
+const FP32_SIN_TABLE_0: f32 = 0.19509032368659973;
+const FP32_SIN_TABLE_1: f32 = 0.3826834261417389;
+const FP32_SIN_TABLE_2: f32 = 0.5555702447891235;
+const FP32_SIN_TABLE_3: f32 = 0.7071067690849304;
+
+const FP32_COS_TABLE_0: f32 = 0.9807852506637573;
+const FP32_COS_TABLE_1: f32 = 0.9238795042037964;
+const FP32_COS_TABLE_2: f32 = 0.8314695954322815;
+const FP32_COS_TABLE_3: f32 = 0.7071067690849304;
+
+const FP32_INVERSE_FACTORIAL_3: f32 = 1.666666716337204e-01;
+const FP32_INVERSE_FACTORIAL_5: f32 = 8.333333767950535e-03;
+const FP32_INVERSE_FACTORIAL_7: f32 = 1.9841270113829523e-04;
+const FP32_INVERSE_FACTORIAL_9: f32 = 2.75573188446287533e-06;
+const FP32_OVERFLOW: f32 = 3.402823466e+38;
+
+fn sin_taylor_fp32(a: f32) -> f32 {
+  if (a == 0.0) {
+    return 0.0;
+  }
+
+  let x = -a * a;
+  var sum = a;
+  var term = a;
+
+  term = term * x;
+  sum = sum + term * FP32_INVERSE_FACTORIAL_3;
+  term = term * x;
+  sum = sum + term * FP32_INVERSE_FACTORIAL_5;
+  term = term * x;
+  sum = sum + term * FP32_INVERSE_FACTORIAL_7;
+  term = term * x;
+  sum = sum + term * FP32_INVERSE_FACTORIAL_9;
+
+  return sum;
+}
+
+fn tan_taylor_fp32(a: f32) -> f32 {
+  if (a == 0.0) {
+    return 0.0;
+  }
+
+  let z = floor(a / FP32_TWO_PI);
+  let reduced = a - FP32_TWO_PI * z;
+
+  var quadrantValue = floor(reduced / FP32_PI_2 + 0.5);
+  let quadrant = i32(quadrantValue);
+  if (quadrant < -2 || quadrant > 2) {
+    return FP32_OVERFLOW;
+  }
+
+  var angle = reduced - FP32_PI_2 * quadrantValue;
+  quadrantValue = floor(angle / FP32_PI_16 + 0.5);
+  let tableIndex = i32(quadrantValue);
+  let absoluteTableIndex = abs(tableIndex);
+  if (absoluteTableIndex > 4) {
+    return FP32_OVERFLOW;
+  }
+
+  angle = angle - FP32_PI_16 * quadrantValue;
+  let sinAngle = sin_taylor_fp32(angle);
+  let cosAngle = sqrt(1.0 - sinAngle * sinAngle);
+
+  var tableCos = 0.0;
+  var tableSin = 0.0;
+  if (absoluteTableIndex == 1) {
+    tableCos = FP32_COS_TABLE_0;
+    tableSin = FP32_SIN_TABLE_0;
+  } else if (absoluteTableIndex == 2) {
+    tableCos = FP32_COS_TABLE_1;
+    tableSin = FP32_SIN_TABLE_1;
+  } else if (absoluteTableIndex == 3) {
+    tableCos = FP32_COS_TABLE_2;
+    tableSin = FP32_SIN_TABLE_2;
+  } else if (absoluteTableIndex == 4) {
+    tableCos = FP32_COS_TABLE_3;
+    tableSin = FP32_SIN_TABLE_3;
+  }
+
+  var sinReduced = sinAngle;
+  var cosReduced = cosAngle;
+  if (tableIndex > 0) {
+    sinReduced = tableCos * sinAngle + tableSin * cosAngle;
+    cosReduced = tableCos * cosAngle - tableSin * sinAngle;
+  } else if (tableIndex < 0) {
+    sinReduced = tableCos * sinAngle - tableSin * cosAngle;
+    cosReduced = tableCos * cosAngle + tableSin * sinAngle;
+  }
+
+  var sinValue = 0.0;
+  var cosValue = 0.0;
+  if (quadrant == 0) {
+    sinValue = sinReduced;
+    cosValue = cosReduced;
+  } else if (quadrant == 1) {
+    sinValue = cosReduced;
+    cosValue = -sinReduced;
+  } else if (quadrant == -1) {
+    sinValue = -cosReduced;
+    cosValue = sinReduced;
+  } else {
+    sinValue = -sinReduced;
+    cosValue = -cosReduced;
+  }
+
+  return sinValue / cosValue;
+}
+
+fn tan_fp32(a: f32) -> f32 {
+  return tan_taylor_fp32(a);
+}
+#else
+fn tan_fp32(a: f32) -> f32 {
+  return tan(a);
+}
+#endif
+`;
+
+/**
+ * 32 bit math library (fixups for GPUs)
+ */
+export const fp32 = {
+  name: 'fp32',
+  source: fp32WGSL,
+  vs: fp32shader
+};

package/src/modules/math/fp64/fp64-arithmetic-glsl.ts

@@ -0,0 +1,205 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export const fp64arithmeticShader = /* glsl */ `\
+
+layout(std140) uniform fp64arithmeticUniforms {
+  uniform float ONE;
+  uniform float SPLIT;
+} fp64;
+
+/*
+About LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+
+The purpose of this workaround is to prevent shader compilers from
+optimizing away necessary arithmetic operations by swapping their sequences
+or transform the equation to some 'equivalent' form.
+
+These helpers implement Dekker/Veltkamp-style error tracking. If the compiler
+folds constants or reassociates the arithmetic, the high/low split can stop
+tracking the rounding error correctly. That failure mode tends to look fine in
+simple coordinate setup, but then breaks down inside iterative arithmetic such
+as fp64 Mandelbrot loops.
+
+The method is to multiply an artifical variable, ONE, which will be known to
+the compiler to be 1 only at runtime. The whole expression is then represented
+as a polynomial with respective to ONE. In the coefficients of all terms, only one a
+and one b should appear
+
+err = (a + b) * ONE^6 - a * ONE^5 - (a + b) * ONE^4 + a * ONE^3 - b - (a + b) * ONE^2 + a * ONE
+*/
+
+float prevent_fp64_optimization(float value) {
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  return value + fp64.ONE * 0.0;
+#else
+  return value;
+#endif
+}
+
+// Divide float number to high and low floats to extend fraction bits
+vec2 split(float a) {
+  // Keep SPLIT as a runtime uniform so the compiler cannot fold the Dekker
+  // split into a constant expression and reassociate the recovery steps.
+  float split = prevent_fp64_optimization(fp64.SPLIT);
+  float t = prevent_fp64_optimization(a * split);
+  float temp = t - a;
+  float a_hi = t - temp;
+  float a_lo = a - a_hi;
+  return vec2(a_hi, a_lo);
+}
+
+// Divide float number again when high float uses too many fraction bits
+vec2 split2(vec2 a) {
+  vec2 b = split(a.x);
+  b.y += a.y;
+  return b;
+}
+
+// Special sum operation when a > b
+vec2 quickTwoSum(float a, float b) {
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float sum = (a + b) * fp64.ONE;
+  float err = b - (sum - a) * fp64.ONE;
+#else
+  float sum = a + b;
+  float err = b - (sum - a);
+#endif
+  return vec2(sum, err);
+}
+
+// General sum operation
+vec2 twoSum(float a, float b) {
+  float s = (a + b);
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float v = (s * fp64.ONE - a) * fp64.ONE;
+  float err = (a - (s - v) * fp64.ONE) * fp64.ONE * fp64.ONE * fp64.ONE + (b - v);
+#else
+  float v = s - a;
+  float err = (a - (s - v)) + (b - v);
+#endif
+  return vec2(s, err);
+}
+
+vec2 twoSub(float a, float b) {
+  float s = (a - b);
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float v = (s * fp64.ONE - a) * fp64.ONE;
+  float err = (a - (s - v) * fp64.ONE) * fp64.ONE * fp64.ONE * fp64.ONE - (b + v);
+#else
+  float v = s - a;
+  float err = (a - (s - v)) - (b + v);
+#endif
+  return vec2(s, err);
+}
+
+vec2 twoSqr(float a) {
+  float prod = a * a;
+  vec2 a_fp64 = split(a);
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float err = ((a_fp64.x * a_fp64.x - prod) * fp64.ONE + 2.0 * a_fp64.x *
+    a_fp64.y * fp64.ONE * fp64.ONE) + a_fp64.y * a_fp64.y * fp64.ONE * fp64.ONE * fp64.ONE;
+#else
+  float err = ((a_fp64.x * a_fp64.x - prod) + 2.0 * a_fp64.x * a_fp64.y) + a_fp64.y * a_fp64.y;
+#endif
+  return vec2(prod, err);
+}
+
+vec2 twoProd(float a, float b) {
+  float prod = a * b;
+  vec2 a_fp64 = split(a);
+  vec2 b_fp64 = split(b);
+  // twoProd is especially sensitive because mul_fp64 and div_fp64 both depend
+  // on the split terms and cross terms staying in the original evaluation
+  // order. If the compiler folds or reassociates them, the low part tends to
+  // collapse to zero or NaN on some drivers.
+  float highProduct = prevent_fp64_optimization(a_fp64.x * b_fp64.x);
+  float crossProduct1 = prevent_fp64_optimization(a_fp64.x * b_fp64.y);
+  float crossProduct2 = prevent_fp64_optimization(a_fp64.y * b_fp64.x);
+  float lowProduct = prevent_fp64_optimization(a_fp64.y * b_fp64.y);
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float err1 = (highProduct - prod) * fp64.ONE;
+  float err2 = crossProduct1 * fp64.ONE * fp64.ONE;
+  float err3 = crossProduct2 * fp64.ONE * fp64.ONE * fp64.ONE;
+  float err4 = lowProduct * fp64.ONE * fp64.ONE * fp64.ONE * fp64.ONE;
+#else
+  float err1 = highProduct - prod;
+  float err2 = crossProduct1;
+  float err3 = crossProduct2;
+  float err4 = lowProduct;
+#endif
+  float err = ((err1 + err2) + err3) + err4;
+  return vec2(prod, err);
+}
+
+vec2 sum_fp64(vec2 a, vec2 b) {
+  vec2 s, t;
+  s = twoSum(a.x, b.x);
+  t = twoSum(a.y, b.y);
+  s.y += t.x;
+  s = quickTwoSum(s.x, s.y);
+  s.y += t.y;
+  s = quickTwoSum(s.x, s.y);
+  return s;
+}
+
+vec2 sub_fp64(vec2 a, vec2 b) {
+  vec2 s, t;
+  s = twoSub(a.x, b.x);
+  t = twoSub(a.y, b.y);
+  s.y += t.x;
+  s = quickTwoSum(s.x, s.y);
+  s.y += t.y;
+  s = quickTwoSum(s.x, s.y);
+  return s;
+}
+
+vec2 mul_fp64(vec2 a, vec2 b) {
+  vec2 prod = twoProd(a.x, b.x);
+  // y component is for the error
+  prod.y += a.x * b.y;
+#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
+  prod = split2(prod);
+#endif
+  prod = quickTwoSum(prod.x, prod.y);
+  prod.y += a.y * b.x;
+#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
+  prod = split2(prod);
+#endif
+  prod = quickTwoSum(prod.x, prod.y);
+  return prod;
+}
+
+vec2 div_fp64(vec2 a, vec2 b) {
+  float xn = 1.0 / b.x;
+#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
+  vec2 yn = mul_fp64(a, vec2(xn, 0));
+#else
+  vec2 yn = a * xn;
+#endif
+  float diff = (sub_fp64(a, mul_fp64(b, yn))).x;
+  vec2 prod = twoProd(xn, diff);
+  return sum_fp64(yn, prod);
+}
+
+vec2 sqrt_fp64(vec2 a) {
+  if (a.x == 0.0 && a.y == 0.0) return vec2(0.0, 0.0);
+  if (a.x < 0.0) return vec2(0.0 / 0.0, 0.0 / 0.0);
+
+  float x = 1.0 / sqrt(a.x);
+  float yn = a.x * x;
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  vec2 yn_sqr = twoSqr(yn) * fp64.ONE;
+#else
+  vec2 yn_sqr = twoSqr(yn);
+#endif
+  float diff = sub_fp64(a, yn_sqr).x;
+  vec2 prod = twoProd(x * 0.5, diff);
+#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
+  return sum_fp64(split(yn), prod);
+#else
+  return sum_fp64(vec2(yn, 0.0), prod);
+#endif
+}
+`;