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

package/src/modules/math/fp64/fp64-functions-wgsl.ts

@@ -0,0 +1,157 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+/** WGSL double-single functions used by geographic projection. */
+export const fp64functionsWGSL = /* wgsl */ `\
+const E_FP64 = vec2f(2.7182817459106445, 8.254840366817007e-8);
+const LOG2_FP64 = vec2f(0.6931471824645996, -1.9046542121259336e-9);
+const PI_FP64 = vec2f(3.1415927410125732, -8.742278012618954e-8);
+const TWO_PI_FP64 = vec2f(6.2831854820251465, -1.7484556025237907e-7);
+const PI_2_FP64 = vec2f(1.5707963705062866, -4.371139006309477e-8);
+const PI_4_FP64 = vec2f(0.7853981852531433, -2.1855695031547384e-8);
+const PI_180_FP64 = vec2f(0.01745329238474369, 1.3519960498364902e-10);
+
+// High/low splits of 1/n!, 1/(2n+1)!, and 1/(2n)! respectively.
+const FP64_EXP_COEFFICIENTS = array<vec2f, 17>(
+  vec2f(1.0, 0.0),
+  vec2f(1.0, 0.0),
+  vec2f(0.5, 0.0),
+  vec2f(0.1666666716337204, -4.967053879312289e-09),
+  vec2f(0.0416666679084301, -1.2417634698280722e-09),
+  vec2f(0.008333333767950535, -4.34617203337595e-10),
+  vec2f(0.0013888889225199819, -3.3631094437103215e-11),
+  vec2f(0.00019841270113829523, -2.725596874933456e-12),
+  vec2f(2.4801587642286904e-05, -3.40699609366682e-13),
+  vec2f(2.7557318844628753e-06, 3.793571224297229e-14),
+  vec2f(2.755731998149713e-07, -7.575112209051195e-15),
+  vec2f(2.5052107943679403e-08, 4.4176230446483665e-16),
+  vec2f(2.0876755879584152e-09, 1.1082839809204342e-16),
+  vec2f(1.6059044372074283e-10, -5.352526511562726e-18),
+  vec2f(1.147074536050896e-11, 2.372207689231238e-19),
+  vec2f(7.647163609812713e-13, 1.2200710471178288e-20),
+  vec2f(4.7794772561329454e-14, 7.62544404448643e-22)
+);
+const FP64_SIN_COEFFICIENTS = array<vec2f, 9>(
+  vec2f(1.0, 0.0),
+  vec2f(0.1666666716337204, -4.967053879312289e-09),
+  vec2f(0.008333333767950535, -4.34617203337595e-10),
+  vec2f(0.00019841270113829523, -2.725596874933456e-12),
+  vec2f(2.7557318844628753e-06, 3.793571224297229e-14),
+  vec2f(2.5052107943679403e-08, 4.4176230446483665e-16),
+  vec2f(1.6059044372074283e-10, -5.352526511562726e-18),
+  vec2f(7.647163609812713e-13, 1.2200710471178288e-20),
+  vec2f(2.8114573589663704e-15, -1.0462084739763658e-22)
+);
+const FP64_COS_COEFFICIENTS = array<vec2f, 9>(
+  vec2f(1.0, 0.0),
+  vec2f(0.5, 0.0),
+  vec2f(0.0416666679084301, -1.2417634698280722e-09),
+  vec2f(0.0013888889225199819, -3.3631094437103215e-11),
+  vec2f(2.4801587642286904e-05, -3.40699609366682e-13),
+  vec2f(2.755731998149713e-07, -7.575112209051195e-15),
+  vec2f(2.0876755879584152e-09, 1.1082839809204342e-16),
+  vec2f(1.147074536050896e-11, 2.372207689231238e-19),
+  vec2f(4.7794772561329454e-14, 7.62544404448643e-22)
+);
+
+// Reduce by log(2) before evaluating the exponential. Horner evaluation uses split
+// coefficients to retain low terms without repeatedly expanding double-single division.
+fn exp_fp64(value: vec2f) -> vec2f {
+  let a = normalize_fp64(value);
+  if (is_nan_fp64(a)) { return a; }
+  // WGSL rejects non-finite constant expressions; construct infinity from runtime bits.
+  if (a.x > 88.72283905206835) { return vec2f(bitcast<f32>(0x7f800000u | (bitcast<u32>(a.x) & 0x80000000u)), 0.0); }
+  if (a.x < -103.9720770839918) { return vec2f(0.0); }
+  let exponent = min(127.0, floor(a.x / LOG2_FP64.x + 0.5));
+  let remainder = sub_fp64(a, mul_fp64(LOG2_FP64, vec2f(exponent, 0.0)));
+  var result = FP64_EXP_COEFFICIENTS[16];
+  for (var i = 15; i >= 0; i--) {
+    result = sum_fp64(FP64_EXP_COEFFICIENTS[i], mul_fp64(remainder, result));
+  }
+  return fp64_scale_fp64(result, i32(exponent));
+}
+
+fn log_fp64(value: vec2f) -> vec2f {
+  let a = normalize_fp64(value);
+  if (is_nan_fp64(a)) { return a; }
+  // Match the GLSL helper's domain: zero and negative inputs return NaN.
+  if (sign_fp64(a) <= 0) { return vec2f(fp64_nan(a.x), 0.0); }
+  if (!is_finite_fp64(a)) { return a; }
+  // Normalize the magnitude before Newton refinement so exp(estimate) cannot overflow
+  // for large inputs or underflow for tiny inputs. Bit extraction also handles subnormals.
+  let exponent = max(-126, i32((bitcast<u32>(a.x) >> 23u) & 255u) - 127);
+  let mantissa = fp64_scale_fp64(a, -exponent);
+  var result = vec2f(log(mantissa.x), 0.0);
+  // Newton correction, written as (a - exp(x)) / exp(x), preserves tiny log(1 + low).
+  // Two iterations remove the error in the native f32 starting estimate.
+  for (var i = 0; i < 2; i++) {
+    let estimate = exp_fp64(result);
+    result = sum_fp64(result, div_fp64(sub_fp64(mantissa, estimate), estimate));
+  }
+  return sum_fp64(result, mul_fp64(LOG2_FP64, vec2f(f32(exponent), 0.0)));
+}
+
+struct Fp64SinCos {
+  sine: vec2f,
+  cosine: vec2f,
+};
+
+fn fp64_sincos(value: vec2f) -> Fp64SinCos {
+  let a = normalize_fp64(value);
+  // The projection use case stays within one turn. Bound conversion to an integer quadrant;
+  // this is not a large-argument Payne-Hanek trigonometric range reducer.
+  if (!is_finite_fp64(a) || abs(a.x) > 1000000.0) {
+    return Fp64SinCos(vec2f(fp64_nan(a.x), 0.0), vec2f(fp64_nan(a.x), 0.0));
+  }
+  let quadrant = i32(floor(a.x / PI_2_FP64.x + 0.5));
+  let remainder = sub_fp64(a, mul_fp64(PI_2_FP64, vec2f(f32(quadrant), 0.0)));
+  let negativeSquare = -mul_fp64(remainder, remainder);
+  var sinePolynomial = FP64_SIN_COEFFICIENTS[8];
+  var cosine = FP64_COS_COEFFICIENTS[8];
+  for (var i = 7; i >= 0; i--) {
+    sinePolynomial = sum_fp64(FP64_SIN_COEFFICIENTS[i], mul_fp64(negativeSquare, sinePolynomial));
+    cosine = sum_fp64(FP64_COS_COEFFICIENTS[i], mul_fp64(negativeSquare, cosine));
+  }
+  let sine = mul_fp64(remainder, sinePolynomial);
+  switch ((quadrant % 4 + 4) % 4) {
+    case 0: { return Fp64SinCos(sine, cosine); }
+    case 1: { return Fp64SinCos(cosine, -sine); }
+    case 2: { return Fp64SinCos(-sine, -cosine); }
+    default: { return Fp64SinCos(-cosine, sine); }
+  }
+}
+
+fn sin_fp64(a: vec2f) -> vec2f { return fp64_sincos(a).sine; }
+fn cos_fp64(a: vec2f) -> vec2f { return fp64_sincos(a).cosine; }
+fn tan_fp64(a: vec2f) -> vec2f {
+  let result = fp64_sincos(a);
+  return div_fp64(result.sine, result.cosine);
+}
+
+fn radians_fp64(degree: vec2f) -> vec2f { return mul_fp64(degree, PI_180_FP64); }
+fn mix_fp64(a: vec2f, b: vec2f, x: f32) -> vec2f {
+  return sum_fp64(a, mul_fp64(sub_fp64(b, a), vec2f(x, 0.0)));
+}
+
+// WGSL returns arrays in place of GLSL out parameters. Each vec2f stores [high, low].
+fn vec4_fp64(a: vec4f) -> array<vec2f, 4> {
+  return array<vec2f, 4>(vec2f(a.x, 0.0), vec2f(a.y, 0.0), vec2f(a.z, 0.0), vec2f(a.w, 0.0));
+}
+
+fn vec4_dot_fp64(a: array<vec2f, 4>, b: array<vec2f, 4>) -> vec2f {
+  return sum_fp64(
+    sum_fp64(mul_fp64(a[0], b[0]), mul_fp64(a[1], b[1])),
+    sum_fp64(mul_fp64(a[2], b[2]), mul_fp64(a[3], b[3])));
+}
+
+// Same row-major pair ordering as the GLSL helper: result[i] = dot(matrix[i * 4..], a).
+fn mat4_vec4_mul_fp64(matrix: array<vec2f, 16>, a: array<vec2f, 4>) -> array<vec2f, 4> {
+  var result: array<vec2f, 4>;
+  for (var i = 0; i < 4; i++) {
+    let row = array<vec2f, 4>(matrix[i * 4], matrix[i * 4 + 1], matrix[i * 4 + 2], matrix[i * 4 + 3]);
+    result[i] = vec4_dot_fp64(a, row);
+  }
+  return result;
+}
+`;

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

@@ -0,0 +1,46 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {NumericArray} from '@math.gl/core';
+
+/**
+ * Calculate WebGL 64 bit float
+ * @param a  - the input float number
+ * @param out - the output array. If not supplied, a new array is created.
+ * @param startIndex - the index in the output array to fill from. Default 0.
+ * @returns - the fp64 representation of the input number
+ */
+export function fp64ify(a: number, out: NumericArray = [], startIndex: number = 0): NumericArray {
+  const hiPart = Math.fround(a);
+  const loPart = a - hiPart;
+  out[startIndex] = hiPart;
+  out[startIndex + 1] = loPart;
+  return out;
+}
+
+/**
+ * Calculate the low part of a WebGL 64 bit float
+ * @param a the input float number
+ * @returns the lower 32 bit of the number
+ */
+export function fp64LowPart(a: number): number {
+  return a - Math.fround(a);
+}
+
+/**
+ * Calculate WebGL 64 bit matrix (transposed "Float64Array")
+ * @param matrix  the input matrix
+ * @returns the fp64 representation of the input matrix
+ */
+export function fp64ifyMatrix4(matrix: NumericArray): Float32Array {
+  // Transpose the projection matrix to column major for GLSL.
+  const matrixFP64 = new Float32Array(32);
+  for (let i = 0; i < 4; ++i) {
+    for (let j = 0; j < 4; ++j) {
+      const index = i * 4 + j;
+      fp64ify(matrix[j * 4 + i], matrixFP64, index * 2);
+    }
+  }
+  return matrixFP64;
+}

package/src/modules/math/fp64/fp64.ts

@@ -0,0 +1,64 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {ShaderModule} from '../../../lib/shader-module/shader-module';
+
+import {fp64ify, fp64LowPart, fp64ifyMatrix4} from './fp64-utils';
+import {fp64arithmeticShader} from './fp64-arithmetic-glsl';
+import {fp64arithmeticWGSL} from './fp64-arithmetic-wgsl';
+import {fp64functionShader} from './fp64-functions-glsl';
+import {fp64functionsWGSL} from './fp64-functions-wgsl';
+
+type FP64Props = {};
+type FP64Uniforms = {ONE: number; SPLIT: number};
+type FP64Bindings = {};
+
+type FP64Utilities = {
+  fp64ify: typeof fp64ify;
+  fp64LowPart: typeof fp64LowPart;
+  fp64ifyMatrix4: typeof fp64ifyMatrix4;
+};
+
+const defaultUniforms: FP64Uniforms = {
+  // Used in LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  ONE: 1.0,
+  // Runtime split factor for Dekker splitting. Keeping this as a uniform helps
+  // prevent aggressive constant folding in shader compilers.
+  SPLIT: 4097.0
+};
+
+/**
+ * 64bit arithmetic: add, sub, mul, div (small subset of fp64 module)
+ */
+export const fp64arithmetic: ShaderModule<FP64Props, FP64Uniforms, FP64Bindings> & FP64Utilities = {
+  name: 'fp64arithmetic',
+  source: fp64arithmeticWGSL,
+  fs: fp64arithmeticShader,
+  vs: fp64arithmeticShader,
+  defaultUniforms,
+  uniformTypes: {ONE: 'f32', SPLIT: 'f32'},
+
+  // Additional Functions
+  fp64ify,
+  fp64LowPart,
+  fp64ifyMatrix4
+};
+
+/**
+ * Double-single math: full GLSL library and WGSL projection functions.
+ * WGSL vector/matrix helpers return arrays instead of using GLSL out parameters.
+ */
+export const fp64: ShaderModule<{}> & FP64Utilities = {
+  name: 'fp64',
+  source: fp64functionsWGSL,
+  vs: fp64functionShader,
+  dependencies: [fp64arithmetic],
+
+  // Additional Functions
+  fp64ify,
+  fp64LowPart,
+  fp64ifyMatrix4
+};
+
+export {fp64ify, fp64LowPart, fp64ifyMatrix4};

package/src/modules/math/random/random.ts

@@ -0,0 +1,25 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {ShaderModule} from '../../../lib/shader-module/shader-module';
+
+const source = /* wgsl */ `\
+fn random(scale: vec3f, seed: f32) -> f32 {
+  return fract(sin(dot(scale + vec3f(seed), vec3f(12.9898, 78.233, 151.7182))) * 43758.5453 + seed);
+}
+`;
+
+const fs = /* glsl */ `\
+float random(vec3 scale, float seed) {
+  /* use the fragment position for a different seed per-pixel */
+  return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);
+}
+`;
+
+/** Quick random generator for fragment shaders */
+export const random = {
+  name: 'random',
+  source,
+  fs
+} as const satisfies ShaderModule<{}, {}>;

package/src/modules/math/value-noise/value-noise.ts

@@ -0,0 +1,70 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {ShaderModule} from '../../../lib/shader-module/shader-module';
+
+/** Smooth, deterministic value noise shared by atmospheric shader modules. */
+export const valueNoise = {
+  name: 'valueNoise',
+  fs: /* glsl */ `
+float valueNoise_hash(vec2 cell) {
+  vec3 value = fract(vec3(cell.x, cell.y, cell.x) * 0.1031);
+  value += dot(value, value.yzx + 33.33);
+  return fract((value.x + value.y) * value.z);
+}
+float valueNoise_noise(vec2 position) {
+  vec2 cell = floor(position);
+  vec2 fraction = fract(position);
+  vec2 blend = fraction * fraction * (3.0 - 2.0 * fraction);
+  return mix(mix(valueNoise_hash(cell), valueNoise_hash(cell + vec2(1.0, 0.0)), blend.x),
+    mix(valueNoise_hash(cell + vec2(0.0, 1.0)), valueNoise_hash(cell + vec2(1.0)), blend.x), blend.y);
+}
+
+float valueNoise_hash3(vec3 cell) {
+  vec3 value = fract(cell * 0.1031);
+  value += dot(value, value.yzx + 33.33);
+  return fract((value.x + value.y) * value.z);
+}
+float valueNoise_noise3(vec3 position) {
+  vec3 cell = floor(position);
+  vec3 fraction = fract(position);
+  vec3 blend = fraction * fraction * (3.0 - 2.0 * fraction);
+  float bottom = mix(mix(valueNoise_hash3(cell), valueNoise_hash3(cell + vec3(1.0, 0.0, 0.0)), blend.x),
+    mix(valueNoise_hash3(cell + vec3(0.0, 1.0, 0.0)), valueNoise_hash3(cell + vec3(1.0, 1.0, 0.0)), blend.x), blend.y);
+  float top = mix(mix(valueNoise_hash3(cell + vec3(0.0, 0.0, 1.0)), valueNoise_hash3(cell + vec3(1.0, 0.0, 1.0)), blend.x),
+    mix(valueNoise_hash3(cell + vec3(0.0, 1.0, 1.0)), valueNoise_hash3(cell + vec3(1.0)), blend.x), blend.y);
+  return mix(bottom, top, blend.z);
+}
+`,
+  source: /* wgsl */ `
+fn valueNoise_hash(cell: vec2f) -> f32 {
+  var value = fract(vec3f(cell.x, cell.y, cell.x) * 0.1031);
+  value += vec3f(dot(value, value.yzx + vec3f(33.33)));
+  return fract((value.x + value.y) * value.z);
+}
+fn valueNoise_noise(position: vec2f) -> f32 {
+  let cell = floor(position);
+  let fraction = fract(position);
+  let blend = fraction * fraction * (vec2f(3.0) - 2.0 * fraction);
+  return mix(mix(valueNoise_hash(cell), valueNoise_hash(cell + vec2f(1.0, 0.0)), blend.x),
+    mix(valueNoise_hash(cell + vec2f(0.0, 1.0)), valueNoise_hash(cell + vec2f(1.0)), blend.x), blend.y);
+}
+
+fn valueNoise_hash3(cell: vec3f) -> f32 {
+  var value = fract(cell * 0.1031);
+  value += vec3f(dot(value, value.yzx + vec3f(33.33)));
+  return fract((value.x + value.y) * value.z);
+}
+fn valueNoise_noise3(position: vec3f) -> f32 {
+  let cell = floor(position);
+  let fraction = fract(position);
+  let blend = fraction * fraction * (vec3f(3.0) - 2.0 * fraction);
+  let bottom = mix(mix(valueNoise_hash3(cell), valueNoise_hash3(cell + vec3f(1.0, 0.0, 0.0)), blend.x),
+    mix(valueNoise_hash3(cell + vec3f(0.0, 1.0, 0.0)), valueNoise_hash3(cell + vec3f(1.0, 1.0, 0.0)), blend.x), blend.y);
+  let top = mix(mix(valueNoise_hash3(cell + vec3f(0.0, 0.0, 1.0)), valueNoise_hash3(cell + vec3f(1.0, 0.0, 1.0)), blend.x),
+    mix(valueNoise_hash3(cell + vec3f(0.0, 1.0, 1.0)), valueNoise_hash3(cell + vec3f(1.0)), blend.x), blend.y);
+  return mix(bottom, top, blend.z);
+}
+`
+} as const satisfies ShaderModule;

package/src/modules/volume/volume-raymarch.ts

@@ -0,0 +1,87 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {ShaderModule} from '../../lib/shader-module/shader-module';
+
+const source = /* wgsl */ `\
+fn volumeRaymarch_intersectBox(origin: vec3f, direction: vec3f, minimum: vec3f, maximum: vec3f) -> vec2f {
+  let safeDirection = select(vec3f(0.000001), direction, abs(direction) > vec3f(0.000001));
+  let first = (minimum - origin) / safeDirection;
+  let second = (maximum - origin) / safeDirection;
+  let nearPlane = min(first, second);
+  let farPlane = max(first, second);
+  return vec2f(
+    max(max(nearPlane.x, nearPlane.y), nearPlane.z),
+    min(min(farPlane.x, farPlane.y), farPlane.z)
+  );
+}
+
+fn volumeRaymarch_mixScalar(corners: array<f32, 8>, blend: vec3f) -> f32 {
+  let lower = mix(mix(corners[0], corners[1], blend.x), mix(corners[2], corners[3], blend.x), blend.y);
+  let upper = mix(mix(corners[4], corners[5], blend.x), mix(corners[6], corners[7], blend.x), blend.y);
+  return mix(lower, upper, blend.z);
+}
+
+fn volumeRaymarch_mixVector(corners: array<vec3f, 8>, blend: vec3f) -> vec3f {
+  let lower = mix(mix(corners[0], corners[1], blend.x), mix(corners[2], corners[3], blend.x), blend.y);
+  let upper = mix(mix(corners[4], corners[5], blend.x), mix(corners[6], corners[7], blend.x), blend.y);
+  return mix(lower, upper, blend.z);
+}
+
+fn volumeRaymarch_sequentialColor(value: f32, lowColor: vec3f, highColor: vec3f) -> vec3f {
+  return mix(lowColor, highColor, clamp(value, 0.0, 1.0));
+}
+
+fn volumeRaymarch_signedColor(value: f32, negativeColor: vec3f, neutralColor: vec3f, positiveColor: vec3f) -> vec3f {
+  let amount = clamp(abs(value), 0.0, 1.0);
+  let signedTarget = select(negativeColor, positiveColor, value >= 0.0);
+  return mix(neutralColor, signedTarget, amount);
+}
+
+fn volumeRaymarch_directionColor(vector: vec3f) -> vec3f {
+  let direction = normalize(vector + vec3f(0.00001));
+  return 0.18 + 0.82 * (direction * 0.5 + 0.5);
+}
+
+fn volumeRaymarch_segmentDistance(point: vec3f, start: vec3f, end: vec3f) -> f32 {
+  let segment = end - start;
+  let fraction = clamp(dot(point - start, segment) / max(dot(segment, segment), 0.000001), 0.0, 1.0);
+  return length(point - (start + segment * fraction));
+}
+
+fn volumeRaymarch_arrowDistance(
+  point: vec3f,
+  center: vec3f,
+  direction: vec3f,
+  arrowLength: f32,
+  shaftRadius: f32,
+  headRadius: f32
+) -> vec2f {
+  let tail = center - direction * arrowLength * 0.48;
+  let shoulder = center + direction * arrowLength * 0.18;
+  let tip = center + direction * arrowLength * 0.52;
+  let shaftDistance = volumeRaymarch_segmentDistance(point, tail, shoulder) - shaftRadius;
+  let headVector = point - shoulder;
+  let headLength = max(length(tip - shoulder), 0.000001);
+  let headPosition = dot(headVector, direction);
+  let taperedRadius = headRadius * (1.0 - clamp(headPosition / headLength, 0.0, 1.0));
+  let radialDistance = length(headVector - direction * headPosition);
+  let headDistance = max(
+    radialDistance - taperedRadius,
+    max(-headPosition, headPosition - headLength)
+  );
+  return vec2f(min(shaftDistance, headDistance), headDistance);
+}
+
+fn volumeRaymarch_composite(accumulated: vec4f, color: vec3f, alpha: f32) -> vec4f {
+  let contribution = (1.0 - accumulated.a) * clamp(alpha, 0.0, 1.0);
+  return vec4f(accumulated.rgb + color * contribution, accumulated.a + contribution);
+}
+`;
+
+/** WGSL helpers shared by structured-volume ray marchers. */
+export const volumeRaymarch = {
+  name: 'volumeRaymarch',
+  source
+} as const satisfies ShaderModule<{}, {}>;

package/src/types/align-to.ts

@@ -0,0 +1,13 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+/** Align offset to 1, 2 or 4 elements (4, 8 or 16 bytes) */
+export function alignTo(size: number, count: number): number {
+  // biome-ignore format: preserve layout
+  switch (count) {
+    case 1: return size; // Pad upwards to even multiple of 2
+    case 2: return size + (size % 2); // Pad upwards to even multiple of 2
+    default: return size + ((4 - (size % 4)) % 4); // Pad upwards to even multiple of 4
+  }
+}

package/src/types/primitive-data-types.ts

@@ -0,0 +1,10 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+/**
+ * Primitive data types that shaders can perform calculations in and declare variables with.
+ * @note attribute inputs and texture samples can be populated from a different in-memory types, see below.
+ * @note `f16` requires the `f16` extension
+ */
+export type PrimitiveDataType = 'u32' | 'i32' | 'f32' | 'f16';

package/src/types/sampler-props.ts

@@ -0,0 +1,39 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export type CompareFunction =
+  | 'never'
+  | 'less'
+  | 'equal'
+  | 'less-equal'
+  | 'greater'
+  | 'not-equal'
+  | 'greater-equal'
+  | 'always';
+
+export type SamplerProps = {
+  /** Comparison / shadow samplers are used with depth textures. See the `Sampler.compare` field */
+  type?: 'color-sampler' | 'comparison-sampler';
+  /** Edge value sampling in X direction */
+  addressModeU?: 'clamp-to-edge' | 'repeat' | 'mirror-repeat';
+  /** Edge value sampling in Y direction */
+  addressModeV?: 'clamp-to-edge' | 'repeat' | 'mirror-repeat';
+  /** Edge value sampling in Z direction */
+  addressModeW?: 'clamp-to-edge' | 'repeat' | 'mirror-repeat';
+
+  /** Magnification: the area of the fragment in texture space is smaller than a texel */
+  magFilter?: 'nearest' | 'linear';
+  /** Minification: the area of the fragment in texture space is larger than a texel */
+  minFilter?: 'nearest' | 'linear';
+  /** mipmapping: select between multiple mipmaps based on angle and size of the texture relative to the screen. */
+  mipmapFilter?: 'none' | 'nearest' | 'linear';
+  /** Affects the mipmap image selection */
+  lodMinClamp?: number;
+  /** Affects the mipmap image selection */
+  lodMaxClamp?: number;
+  /** Maximum number of samples that can be taken of the texture during any one texture fetch */
+  maxAnisotropy?: number;
+  /** How to compare reference values provided in shader shadow sampler calls with those pulled from the texture */
+  compare?: CompareFunction;
+};