@luma.gl/shadertools 9.1.0-alpha.1 → 9.1.0-alpha.12

package/dist/modules/lighting/phong-material/phong-shaders-glsl.js

@@ -1,70 +1,98 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
-export const PHONG_VS = `\
+export const PHONG_VS = /* glsl */ `\
 uniform phongMaterialUniforms {
-uniform float ambient;
-uniform float diffuse;
-uniform float shininess;
-uniform vec3  specularColor;
+  uniform float ambient;
+  uniform float diffuse;
+  uniform float shininess;
+  uniform vec3  specularColor;
 } material;
 `;
-export const PHONG_FS = `\
+export const PHONG_FS = /* glsl */ `\
 uniform phongMaterialUniforms {
-uniform float ambient;
-uniform float diffuse;
-uniform float shininess;
-uniform vec3  specularColor;
+  uniform float ambient;
+  uniform float diffuse;
+  uniform float shininess;
+  uniform vec3  specularColor;
 } material;
+
 vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {
-vec3 halfway_direction = normalize(light_direction + view_direction);
-float lambertian = dot(light_direction, normal_worldspace);
-float specular = 0.0;
-if (lambertian > 0.0) {
-float specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);
-specular = pow(specular_angle, material.shininess);
-}
-lambertian = max(lambertian, 0.0);
-return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;
+  vec3 halfway_direction = normalize(light_direction + view_direction);
+  float lambertian = dot(light_direction, normal_worldspace);
+  float specular = 0.0;
+  if (lambertian > 0.0) {
+    float specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);
+    specular = pow(specular_angle, material.shininess);
+  }
+  lambertian = max(lambertian, 0.0);
+  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;
 }
+
 vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
-vec3 lightColor = surfaceColor;
-if (lighting.enabled == 0) {
-return lightColor;
-}
-vec3 view_direction = normalize(cameraPosition - position_worldspace);
-lightColor = material.ambient * surfaceColor * lighting.ambientColor;
-if (lighting.lightType == 0) {
-PointLight pointLight = lighting_getPointLight(0);
-vec3 light_position_worldspace = pointLight.position;
-vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-} else if (lighting.lightType == 1) {
-DirectionalLight directionalLight = lighting_getDirectionalLight(0);
-lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-}
-return lightColor;
+  vec3 lightColor = surfaceColor;
+
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
+
+  vec3 view_direction = normalize(cameraPosition - position_worldspace);
+  lightColor = material.ambient * surfaceColor * lighting.ambientColor;
+
+  if (lighting.lightType == 0) {
+    PointLight pointLight = lighting_getPointLight(0);
+    vec3 light_position_worldspace = pointLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+  } else if (lighting.lightType == 1) {
+    DirectionalLight directionalLight = lighting_getDirectionalLight(0);
+    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+  }
+  
+  /*
+  for (int i = 0; i < MAX_LIGHTS; i++) {
+    if (i >= lighting.pointLightCount) {
+      break;
+    }
+    PointLight pointLight = lighting.pointLight[i];
+    vec3 light_position_worldspace = pointLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+  }
+
+  for (int i = 0; i < MAX_LIGHTS; i++) {
+    if (i >= lighting.directionalLightCount) {
+      break;
+    }
+    DirectionalLight directionalLight = lighting.directionalLight[i];
+    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+  }
+  */
+  return lightColor;
 }
+
 vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
-vec3 lightColor = vec3(0, 0, 0);
-vec3 surfaceColor = vec3(0, 0, 0);
-if (lighting.enabled == 0) {
-vec3 view_direction = normalize(cameraPosition - position_worldspace);
-switch (lighting.lightType) {
-case 0:
-PointLight pointLight = lighting_getPointLight(0);
-vec3 light_position_worldspace = pointLight.position;
-vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-break;
-case 1:
-DirectionalLight directionalLight = lighting_getDirectionalLight(0);
-lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-break;
-}
-}
-return lightColor;
+  vec3 lightColor = vec3(0, 0, 0);
+  vec3 surfaceColor = vec3(0, 0, 0);
+
+  if (lighting.enabled == 0) {
+    vec3 view_direction = normalize(cameraPosition - position_worldspace);
+
+    switch (lighting.lightType) {
+      case 0:
+        PointLight pointLight = lighting_getPointLight(0);
+        vec3 light_position_worldspace = pointLight.position;
+        vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+        lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+        break;
+
+      case 1:
+        DirectionalLight directionalLight = lighting_getDirectionalLight(0);
+        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+        break;
+    }
+  }
+  return lightColor;
 }
 `;
 // TODO - handle multiple lights

package/dist/modules/lighting/phong-material/phong-shaders-wgsl.d.ts

@@ -0,0 +1,41 @@
+export declare const PHONG_WGSL = "struct phongMaterialUniforms {\n  ambient: f32,\n  diffuse: f32,\n  shininess: f32,\n  specularColor: vec3<f32>,\n};\n\n@binding(2) @group(0) var<uniform> material : phongMaterialUniforms;\n\nfn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, view_direction: vec3<f32>, normal_worldspace: vec3<f32>, color: vec3<f32>) -> vec3<f32> {\n  let halfway_direction: vec3<f32> = normalize(light_direction + view_direction);\n  var lambertian: f32 = dot(light_direction, normal_worldspace);\n  var specular: f32 = 0.0;\n  if (lambertian > 0.0) {\n    let specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);\n    specular = pow(specular_angle, material.shininess);\n  }\n  lambertian = max(lambertian, 0.0);\n  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;\n}\n\nfn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32> {\n  var lightColor: vec3<f32> = surfaceColor;\n\n  if (lighting.enabled == 0) {\n    return lightColor;\n  }\n\n  let view_direction: vec3<f32> = normalize(cameraPosition - position_worldspace);\n  lightColor = material.ambient * surfaceColor * lighting.ambientColor;\n\n  if (lighting.lightType == 0) {\n    let pointLight: PointLight  = lighting_getPointLight(0);\n    let light_position_worldspace: vec3<f32> = pointLight.position;\n    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);\n    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n  } else if (lighting.lightType == 1) {\n    var directionalLight: DirectionalLight = lighting_getDirectionalLight(0);\n    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n  }\n  \n  return lightColor;\n  /*\n  for (int i = 0; i < MAX_LIGHTS; i++) {\n    if (i >= lighting.pointLightCount) {\n      break;\n    }\n    PointLight pointLight = lighting.pointLight[i];\n    vec3 light_position_worldspace = pointLight.position;\n    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);\n    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n  }\n\n  for (int i = 0; i < MAX_LIGHTS; i++) {\n    if (i >= lighting.directionalLightCount) {\n      break;\n    }\n    DirectionalLight directionalLight = lighting.directionalLight[i];\n    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n  }\n  */\n}\n\nfn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32>{\n  var lightColor = vec3<f32>(0, 0, 0);\n  let surfaceColor = vec3<f32>(0, 0, 0);\n\n  if (lighting.enabled == 0) {\n    let view_direction = normalize(cameraPosition - position_worldspace);\n\n    switch (lighting.lightType) {\n      case 0, default: {\n        let pointLight: PointLight = lighting_getPointLight(0);\n        let light_position_worldspace: vec3<f32> = pointLight.position;\n        let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);\n        lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);\n      }\n      case 1: {\n        let directionalLight: DirectionalLight = lighting_getDirectionalLight(0);\n        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);\n      }\n    }\n  }\n  return lightColor;\n}\n";
+/**
+    for (int i = 0; i < MAX_LIGHTS; i++) {
+      if (i >= lighting.pointLightCount) {
+        break;
+      }
+      PointLight pointLight = lighting_getPointLight(i);
+      vec3 light_position_worldspace = pointLight.position;
+      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+    }
+
+    for (int i = 0; i < MAX_LIGHTS; i++) {
+      if (i >= lighting.directionalLightCount) {
+        break;
+      }
+      PointLight pointLight = lighting_getDirectionalLight(i);
+      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+    }
+  }
+    /**
+    for (int i = 0; i < MAX_LIGHTS; i++) {
+      if (i >= lighting.pointLightCount) {
+        break;
+      }
+      PointLight pointLight = lighting_getPointLight(i);
+      vec3 light_position_worldspace = pointLight.position;
+      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+    }
+
+    for (int i = 0; i < MAX_LIGHTS; i++) {
+      if (i >= lighting.directionalLightCount) {
+        break;
+      }
+      PointLight pointLight = lighting_getDirectionalLight(i);
+      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+    }
+  }
+  */
+//# sourceMappingURL=phong-shaders-wgsl.d.ts.map

package/dist/modules/lighting/phong-material/phong-shaders-wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phong-shaders-wgsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/phong-material/phong-shaders-wgsl.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,UAAU,gvHAsFtB,CAAC;AAGF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsCI"}

package/dist/modules/lighting/phong-material/phong-shaders-wgsl.js

@@ -0,0 +1,130 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+export const PHONG_WGSL = /* wgsl */ `\
+struct phongMaterialUniforms {
+  ambient: f32,
+  diffuse: f32,
+  shininess: f32,
+  specularColor: vec3<f32>,
+};
+
+@binding(2) @group(0) var<uniform> material : phongMaterialUniforms;
+
+fn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, view_direction: vec3<f32>, normal_worldspace: vec3<f32>, color: vec3<f32>) -> vec3<f32> {
+  let halfway_direction: vec3<f32> = normalize(light_direction + view_direction);
+  var lambertian: f32 = dot(light_direction, normal_worldspace);
+  var specular: f32 = 0.0;
+  if (lambertian > 0.0) {
+    let specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);
+    specular = pow(specular_angle, material.shininess);
+  }
+  lambertian = max(lambertian, 0.0);
+  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;
+}
+
+fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32> {
+  var lightColor: vec3<f32> = surfaceColor;
+
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
+
+  let view_direction: vec3<f32> = normalize(cameraPosition - position_worldspace);
+  lightColor = material.ambient * surfaceColor * lighting.ambientColor;
+
+  if (lighting.lightType == 0) {
+    let pointLight: PointLight  = lighting_getPointLight(0);
+    let light_position_worldspace: vec3<f32> = pointLight.position;
+    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+  } else if (lighting.lightType == 1) {
+    var directionalLight: DirectionalLight = lighting_getDirectionalLight(0);
+    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+  }
+  
+  return lightColor;
+  /*
+  for (int i = 0; i < MAX_LIGHTS; i++) {
+    if (i >= lighting.pointLightCount) {
+      break;
+    }
+    PointLight pointLight = lighting.pointLight[i];
+    vec3 light_position_worldspace = pointLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+  }
+
+  for (int i = 0; i < MAX_LIGHTS; i++) {
+    if (i >= lighting.directionalLightCount) {
+      break;
+    }
+    DirectionalLight directionalLight = lighting.directionalLight[i];
+    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+  }
+  */
+}
+
+fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32>{
+  var lightColor = vec3<f32>(0, 0, 0);
+  let surfaceColor = vec3<f32>(0, 0, 0);
+
+  if (lighting.enabled == 0) {
+    let view_direction = normalize(cameraPosition - position_worldspace);
+
+    switch (lighting.lightType) {
+      case 0, default: {
+        let pointLight: PointLight = lighting_getPointLight(0);
+        let light_position_worldspace: vec3<f32> = pointLight.position;
+        let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+        lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+      }
+      case 1: {
+        let directionalLight: DirectionalLight = lighting_getDirectionalLight(0);
+        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+      }
+    }
+  }
+  return lightColor;
+}
+`;
+// TODO - handle multiple lights
+/**
+    for (int i = 0; i < MAX_LIGHTS; i++) {
+      if (i >= lighting.pointLightCount) {
+        break;
+      }
+      PointLight pointLight = lighting_getPointLight(i);
+      vec3 light_position_worldspace = pointLight.position;
+      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+    }
+
+    for (int i = 0; i < MAX_LIGHTS; i++) {
+      if (i >= lighting.directionalLightCount) {
+        break;
+      }
+      PointLight pointLight = lighting_getDirectionalLight(i);
+      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+    }
+  }
+    /**
+    for (int i = 0; i < MAX_LIGHTS; i++) {
+      if (i >= lighting.pointLightCount) {
+        break;
+      }
+      PointLight pointLight = lighting_getPointLight(i);
+      vec3 light_position_worldspace = pointLight.position;
+      vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+      lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+    }
+
+    for (int i = 0; i < MAX_LIGHTS; i++) {
+      if (i >= lighting.directionalLightCount) {
+        break;
+      }
+      PointLight pointLight = lighting_getDirectionalLight(i);
+      lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+    }
+  }
+  */

package/dist/modules/math/fp32/fp32.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fp32.d.ts","sourceRoot":"","sources":["../../../../src/modules/math/fp32/fp32.ts"],"names":[],"mappings":"AAgKA;;GAEG;AACH,eAAO,MAAM,IAAI;;;CAGhB,CAAC"}
+{"version":3,"file":"fp32.d.ts","sourceRoot":"","sources":["../../../../src/modules/math/fp32/fp32.ts"],"names":[],"mappings":"AA+JA;;GAEG;AACH,eAAO,MAAM,IAAI;;;CAGhB,CAAC"}

package/dist/modules/math/fp32/fp32.js

@@ -1,129 +1,156 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
 // import {ShaderModule} from '../../types';
-const fp32shader = `\
+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;
-const float INVERSE_FACTORIAL_5 = 8.333333767950535e-03;
-const float INVERSE_FACTORIAL_7 = 1.9841270113829523e-04;
-const float INVERSE_FACTORIAL_9 = 2.75573188446287533e-06;
+
+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;
+  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);
+  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;
-}
-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;
+    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);
+  return tan_taylor_fp32(a);
 #else
-return tan(a);
+  return tan(a);
 #endif
 }
 `;

package/dist/modules/math/fp64/fp64-utils.d.ts

@@ -1,4 +1,4 @@
-import type { NumberArray } from '@math.gl/types';
+import type { NumericArray } from '@math.gl/types';
 /**
  * Calculate WebGL 64 bit float
  * @param a  - the input float number
@@ -6,7 +6,7 @@ import type { NumberArray } from '@math.gl/types';
  * @param startIndex - the index in the output array to fill from. Default 0.
  * @returns - the fp64 representation of the input number
  */
-export declare function fp64ify(a: number, out?: NumberArray, startIndex?: number): NumberArray;
+export declare function fp64ify(a: number, out?: NumericArray, startIndex?: number): NumericArray;
 /**
  * Calculate the low part of a WebGL 64 bit float
  * @param a the input float number
@@ -18,5 +18,5 @@ export declare function fp64LowPart(a: number): number;
  * @param matrix  the input matrix
  * @returns the fp64 representation of the input matrix
  */
-export declare function fp64ifyMatrix4(matrix: NumberArray): Float32Array;
+export declare function fp64ifyMatrix4(matrix: NumericArray): Float32Array;
 //# sourceMappingURL=fp64-utils.d.ts.map

package/dist/modules/math/fp64/fp64-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fp64-utils.d.ts","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64-utils.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAEhD;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,GAAE,WAAgB,EAAE,UAAU,GAAE,MAAU,GAAG,WAAW,CAM7F;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,YAAY,CAUhE"}
+{"version":3,"file":"fp64-utils.d.ts","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64-utils.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAEjD;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,GAAE,YAAiB,EAAE,UAAU,GAAE,MAAU,GAAG,YAAY,CAM/F;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,YAAY,GAAG,YAAY,CAUjE"}

package/dist/modules/math/random/random.d.ts

@@ -1,6 +1,6 @@
 /** Quick random generator for fragment shaders */
 export declare const random: {
     readonly name: "random";
-    readonly fs: string;
+    readonly fs: "float random(vec3 scale, float seed) {\n  /* use the fragment position for a different seed per-pixel */\n  return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);\n}\n";
 };
 //# sourceMappingURL=random.d.ts.map

package/dist/modules/math/random/random.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"random.d.ts","sourceRoot":"","sources":["../../../../src/modules/math/random/random.ts"],"names":[],"mappings":"AAcA,kDAAkD;AAClD,eAAO,MAAM,MAAM;;;CAGsB,CAAC"}
+{"version":3,"file":"random.d.ts","sourceRoot":"","sources":["../../../../src/modules/math/random/random.ts"],"names":[],"mappings":"AAaA,kDAAkD;AAClD,eAAO,MAAM,MAAM;;;CAGsB,CAAC"}

package/dist/modules/math/random/random.js

@@ -1,10 +1,10 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
-const fs = `\
+const fs = /* glsl */ `\
 float random(vec3 scale, float seed) {
-return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + 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 */