@luma.gl/shadertools 9.3.6 → 9.4.0-alpha.1

package/dist/modules/lighting/water-material/water-shaders-glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"water-shaders-glsl.js","sourceRoot":"","sources":["../../../../src/modules/lighting/water-material/water-shaders-glsl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC,MAAM,CAAC,MAAM,QAAQ,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;CAqBlC,CAAC;AAEF,MAAM,CAAC,MAAM,QAAQ,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6MlC,CAAC"}

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

@@ -0,0 +1,2 @@
+export declare const WATER_WGSL = "struct waterMaterialUniforms {\n  time: f32,\n  baseColor: vec3<f32>,\n  opacity: f32,\n  fresnelColor: vec3<f32>,\n  fresnelPower: f32,\n  specularIntensity: f32,\n  normalStrength: f32,\n  mappingMode: i32,\n  coordinateScale: vec2<f32>,\n  coordinateOffset: vec2<f32>,\n  waveADirection: vec2<f32>,\n  waveASpeed: f32,\n  waveAFrequency: f32,\n  waveAAmplitude: f32,\n  waveBDirection: vec2<f32>,\n  waveBSpeed: f32,\n  waveBFrequency: f32,\n  waveBAmplitude: f32,\n};\n\n@group(3) @binding(auto) var<uniform> waterMaterial : waterMaterialUniforms;\n\nfn water_getDirection(direction: vec2<f32>) -> vec2<f32> {\n  let directionLength = length(direction);\n  if (directionLength > 0.0) {\n    return direction / directionLength;\n  }\n\n  return vec2<f32>(1.0, 0.0);\n}\n\nfn water_getCoordinates(\n  position_worldspace: vec3<f32>,\n  position_objectspace: vec3<f32>,\n  uv: vec2<f32>\n) -> vec2<f32> {\n  var baseCoordinates = uv;\n  if (waterMaterial.mappingMode == 1) {\n    baseCoordinates = position_worldspace.xz;\n  } else if (waterMaterial.mappingMode == 2) {\n    let globeDirection = normalize(position_objectspace);\n    let longitude = atan2(globeDirection.x, globeDirection.z);\n    let latitude = asin(clamp(globeDirection.y, -1.0, 1.0));\n    baseCoordinates = vec2<f32>(longitude, latitude);\n  }\n\n  return baseCoordinates * waterMaterial.coordinateScale + waterMaterial.coordinateOffset;\n}\n\nfn water_getWaveGradient(\n  coordinates: vec2<f32>,\n  direction: vec2<f32>,\n  speed: f32,\n  frequency: f32,\n  amplitude: f32\n) -> vec2<f32> {\n  let normalizedDirection = water_getDirection(direction);\n  let phase = dot(coordinates * frequency, normalizedDirection) + waterMaterial.time * speed;\n  return cos(phase) * normalizedDirection * frequency * amplitude;\n}\n\nfn water_getTangent(normal_worldspace: vec3<f32>) -> vec3<f32> {\n  var referenceAxis = vec3<f32>(0.0, 0.0, 1.0);\n  if (abs(normal_worldspace.z) >= 0.999) {\n    referenceAxis = vec3<f32>(0.0, 1.0, 0.0);\n  }\n\n  return normalize(cross(referenceAxis, normal_worldspace));\n}\n\nfn water_getNormal(\n  position_worldspace: vec3<f32>,\n  position_objectspace: vec3<f32>,\n  normal_worldspace: vec3<f32>,\n  uv: vec2<f32>\n) -> vec3<f32> {\n  let coordinates = water_getCoordinates(position_worldspace, position_objectspace, uv);\n  let gradient =\n    water_getWaveGradient(\n      coordinates,\n      waterMaterial.waveADirection,\n      waterMaterial.waveASpeed,\n      waterMaterial.waveAFrequency,\n      waterMaterial.waveAAmplitude\n    ) +\n    water_getWaveGradient(\n      coordinates,\n      waterMaterial.waveBDirection,\n      waterMaterial.waveBSpeed,\n      waterMaterial.waveBFrequency,\n      waterMaterial.waveBAmplitude\n    );\n  let tangent = water_getTangent(normal_worldspace);\n  let bitangent = normalize(cross(normal_worldspace, tangent));\n  let perturbation =\n    waterMaterial.normalStrength * (gradient.x * tangent + gradient.y * bitangent);\n\n  return normalize(normal_worldspace + perturbation);\n}\n\nfn water_getSpecularContribution(\n  light_direction: vec3<f32>,\n  view_direction: vec3<f32>,\n  normal_worldspace: vec3<f32>,\n  light_color: vec3<f32>,\n  fresnel: f32\n) -> vec3<f32> {\n  let halfwayDirection = normalize(light_direction + view_direction);\n  let specular =\n    pow(max(dot(normal_worldspace, halfwayDirection), 0.0), 72.0) *\n    waterMaterial.specularIntensity *\n    (0.25 + 0.75 * fresnel);\n\n  return waterMaterial.fresnelColor * light_color * specular;\n}\n\nfn water_getColorMapped(\n  cameraPosition: vec3<f32>,\n  position_worldspace: vec3<f32>,\n  position_objectspace: vec3<f32>,\n  normal_worldspace: vec3<f32>,\n  uv: vec2<f32>\n) -> vec4<f32> {\n  let waterNormal = water_getNormal(\n    position_worldspace,\n    position_objectspace,\n    normalize(normal_worldspace),\n    uv\n  );\n  let viewDirection = normalize(cameraPosition - position_worldspace);\n  let fresnel =\n    pow(\n      1.0 - max(dot(viewDirection, waterNormal), 0.0),\n      max(waterMaterial.fresnelPower, 0.0001)\n    );\n  let surfaceColor = mix(\n    waterMaterial.baseColor,\n    waterMaterial.fresnelColor,\n    clamp(fresnel * 0.6, 0.0, 1.0)\n  );\n\n  if (lighting.enabled == 0) {\n    return vec4<f32>(surfaceColor, waterMaterial.opacity);\n  }\n\n  var lightColor = surfaceColor * (0.15 + 0.85 * lighting.ambientColor);\n\n  for (var i: i32 = 0; i < lighting.pointLightCount; i++) {\n    let pointLight = lighting_getPointLight(i);\n    let lightPosition = pointLight.position;\n    let lightDirection = normalize(lightPosition - position_worldspace);\n    let attenuation = getPointLightAttenuation(\n      pointLight,\n      distance(lightPosition, position_worldspace)\n    );\n    let incidentLight = pointLight.color / attenuation;\n    let diffuse = max(dot(waterNormal, lightDirection), 0.0);\n\n    lightColor += surfaceColor * incidentLight * diffuse;\n    lightColor += water_getSpecularContribution(\n      lightDirection,\n      viewDirection,\n      waterNormal,\n      incidentLight,\n      fresnel\n    );\n  }\n\n  for (var i: i32 = 0; i < lighting.spotLightCount; i++) {\n    let spotLight = lighting_getSpotLight(i);\n    let lightPosition = spotLight.position;\n    let lightDirection = normalize(lightPosition - position_worldspace);\n    let attenuation = getSpotLightAttenuation(spotLight, position_worldspace);\n    let incidentLight = spotLight.color / attenuation;\n    let diffuse = max(dot(waterNormal, lightDirection), 0.0);\n\n    lightColor += surfaceColor * incidentLight * diffuse;\n    lightColor += water_getSpecularContribution(\n      lightDirection,\n      viewDirection,\n      waterNormal,\n      incidentLight,\n      fresnel\n    );\n  }\n\n  for (var i: i32 = 0; i < lighting.directionalLightCount; i++) {\n    let directionalLight = lighting_getDirectionalLight(i);\n    let lightDirection = normalize(-directionalLight.direction);\n    let diffuse = max(dot(waterNormal, lightDirection), 0.0);\n\n    lightColor += surfaceColor * directionalLight.color * diffuse;\n    lightColor += water_getSpecularContribution(\n      lightDirection,\n      viewDirection,\n      waterNormal,\n      directionalLight.color,\n      fresnel\n    );\n  }\n\n  lightColor = mix(\n    lightColor,\n    waterMaterial.fresnelColor,\n    clamp(fresnel, 0.0, 1.0) * 0.35\n  );\n  return vec4<f32>(lightColor, waterMaterial.opacity);\n}\n\nfn water_getColor(\n  cameraPosition: vec3<f32>,\n  position_worldspace: vec3<f32>,\n  normal_worldspace: vec3<f32>,\n  uv: vec2<f32>\n) -> vec4<f32> {\n  return water_getColorMapped(\n    cameraPosition,\n    position_worldspace,\n    position_worldspace,\n    normal_worldspace,\n    uv\n  );\n}\n";
+//# sourceMappingURL=water-shaders-wgsl.d.ts.map

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

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

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

@@ -0,0 +1,230 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+export const WATER_WGSL = /* wgsl */ `\
+struct waterMaterialUniforms {
+  time: f32,
+  baseColor: vec3<f32>,
+  opacity: f32,
+  fresnelColor: vec3<f32>,
+  fresnelPower: f32,
+  specularIntensity: f32,
+  normalStrength: f32,
+  mappingMode: i32,
+  coordinateScale: vec2<f32>,
+  coordinateOffset: vec2<f32>,
+  waveADirection: vec2<f32>,
+  waveASpeed: f32,
+  waveAFrequency: f32,
+  waveAAmplitude: f32,
+  waveBDirection: vec2<f32>,
+  waveBSpeed: f32,
+  waveBFrequency: f32,
+  waveBAmplitude: f32,
+};
+
+@group(3) @binding(auto) var<uniform> waterMaterial : waterMaterialUniforms;
+
+fn water_getDirection(direction: vec2<f32>) -> vec2<f32> {
+  let directionLength = length(direction);
+  if (directionLength > 0.0) {
+    return direction / directionLength;
+  }
+
+  return vec2<f32>(1.0, 0.0);
+}
+
+fn water_getCoordinates(
+  position_worldspace: vec3<f32>,
+  position_objectspace: vec3<f32>,
+  uv: vec2<f32>
+) -> vec2<f32> {
+  var baseCoordinates = uv;
+  if (waterMaterial.mappingMode == 1) {
+    baseCoordinates = position_worldspace.xz;
+  } else if (waterMaterial.mappingMode == 2) {
+    let globeDirection = normalize(position_objectspace);
+    let longitude = atan2(globeDirection.x, globeDirection.z);
+    let latitude = asin(clamp(globeDirection.y, -1.0, 1.0));
+    baseCoordinates = vec2<f32>(longitude, latitude);
+  }
+
+  return baseCoordinates * waterMaterial.coordinateScale + waterMaterial.coordinateOffset;
+}
+
+fn water_getWaveGradient(
+  coordinates: vec2<f32>,
+  direction: vec2<f32>,
+  speed: f32,
+  frequency: f32,
+  amplitude: f32
+) -> vec2<f32> {
+  let normalizedDirection = water_getDirection(direction);
+  let phase = dot(coordinates * frequency, normalizedDirection) + waterMaterial.time * speed;
+  return cos(phase) * normalizedDirection * frequency * amplitude;
+}
+
+fn water_getTangent(normal_worldspace: vec3<f32>) -> vec3<f32> {
+  var referenceAxis = vec3<f32>(0.0, 0.0, 1.0);
+  if (abs(normal_worldspace.z) >= 0.999) {
+    referenceAxis = vec3<f32>(0.0, 1.0, 0.0);
+  }
+
+  return normalize(cross(referenceAxis, normal_worldspace));
+}
+
+fn water_getNormal(
+  position_worldspace: vec3<f32>,
+  position_objectspace: vec3<f32>,
+  normal_worldspace: vec3<f32>,
+  uv: vec2<f32>
+) -> vec3<f32> {
+  let coordinates = water_getCoordinates(position_worldspace, position_objectspace, uv);
+  let gradient =
+    water_getWaveGradient(
+      coordinates,
+      waterMaterial.waveADirection,
+      waterMaterial.waveASpeed,
+      waterMaterial.waveAFrequency,
+      waterMaterial.waveAAmplitude
+    ) +
+    water_getWaveGradient(
+      coordinates,
+      waterMaterial.waveBDirection,
+      waterMaterial.waveBSpeed,
+      waterMaterial.waveBFrequency,
+      waterMaterial.waveBAmplitude
+    );
+  let tangent = water_getTangent(normal_worldspace);
+  let bitangent = normalize(cross(normal_worldspace, tangent));
+  let perturbation =
+    waterMaterial.normalStrength * (gradient.x * tangent + gradient.y * bitangent);
+
+  return normalize(normal_worldspace + perturbation);
+}
+
+fn water_getSpecularContribution(
+  light_direction: vec3<f32>,
+  view_direction: vec3<f32>,
+  normal_worldspace: vec3<f32>,
+  light_color: vec3<f32>,
+  fresnel: f32
+) -> vec3<f32> {
+  let halfwayDirection = normalize(light_direction + view_direction);
+  let specular =
+    pow(max(dot(normal_worldspace, halfwayDirection), 0.0), 72.0) *
+    waterMaterial.specularIntensity *
+    (0.25 + 0.75 * fresnel);
+
+  return waterMaterial.fresnelColor * light_color * specular;
+}
+
+fn water_getColorMapped(
+  cameraPosition: vec3<f32>,
+  position_worldspace: vec3<f32>,
+  position_objectspace: vec3<f32>,
+  normal_worldspace: vec3<f32>,
+  uv: vec2<f32>
+) -> vec4<f32> {
+  let waterNormal = water_getNormal(
+    position_worldspace,
+    position_objectspace,
+    normalize(normal_worldspace),
+    uv
+  );
+  let viewDirection = normalize(cameraPosition - position_worldspace);
+  let fresnel =
+    pow(
+      1.0 - max(dot(viewDirection, waterNormal), 0.0),
+      max(waterMaterial.fresnelPower, 0.0001)
+    );
+  let surfaceColor = mix(
+    waterMaterial.baseColor,
+    waterMaterial.fresnelColor,
+    clamp(fresnel * 0.6, 0.0, 1.0)
+  );
+
+  if (lighting.enabled == 0) {
+    return vec4<f32>(surfaceColor, waterMaterial.opacity);
+  }
+
+  var lightColor = surfaceColor * (0.15 + 0.85 * lighting.ambientColor);
+
+  for (var i: i32 = 0; i < lighting.pointLightCount; i++) {
+    let pointLight = lighting_getPointLight(i);
+    let lightPosition = pointLight.position;
+    let lightDirection = normalize(lightPosition - position_worldspace);
+    let attenuation = getPointLightAttenuation(
+      pointLight,
+      distance(lightPosition, position_worldspace)
+    );
+    let incidentLight = pointLight.color / attenuation;
+    let diffuse = max(dot(waterNormal, lightDirection), 0.0);
+
+    lightColor += surfaceColor * incidentLight * diffuse;
+    lightColor += water_getSpecularContribution(
+      lightDirection,
+      viewDirection,
+      waterNormal,
+      incidentLight,
+      fresnel
+    );
+  }
+
+  for (var i: i32 = 0; i < lighting.spotLightCount; i++) {
+    let spotLight = lighting_getSpotLight(i);
+    let lightPosition = spotLight.position;
+    let lightDirection = normalize(lightPosition - position_worldspace);
+    let attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+    let incidentLight = spotLight.color / attenuation;
+    let diffuse = max(dot(waterNormal, lightDirection), 0.0);
+
+    lightColor += surfaceColor * incidentLight * diffuse;
+    lightColor += water_getSpecularContribution(
+      lightDirection,
+      viewDirection,
+      waterNormal,
+      incidentLight,
+      fresnel
+    );
+  }
+
+  for (var i: i32 = 0; i < lighting.directionalLightCount; i++) {
+    let directionalLight = lighting_getDirectionalLight(i);
+    let lightDirection = normalize(-directionalLight.direction);
+    let diffuse = max(dot(waterNormal, lightDirection), 0.0);
+
+    lightColor += surfaceColor * directionalLight.color * diffuse;
+    lightColor += water_getSpecularContribution(
+      lightDirection,
+      viewDirection,
+      waterNormal,
+      directionalLight.color,
+      fresnel
+    );
+  }
+
+  lightColor = mix(
+    lightColor,
+    waterMaterial.fresnelColor,
+    clamp(fresnel, 0.0, 1.0) * 0.35
+  );
+  return vec4<f32>(lightColor, waterMaterial.opacity);
+}
+
+fn water_getColor(
+  cameraPosition: vec3<f32>,
+  position_worldspace: vec3<f32>,
+  normal_worldspace: vec3<f32>,
+  uv: vec2<f32>
+) -> vec4<f32> {
+  return water_getColorMapped(
+    cameraPosition,
+    position_worldspace,
+    position_worldspace,
+    normal_worldspace,
+    uv
+  );
+}
+`;
+//# sourceMappingURL=water-shaders-wgsl.js.map

package/dist/modules/lighting/water-material/water-shaders-wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"water-shaders-wgsl.js","sourceRoot":"","sources":["../../../../src/modules/lighting/water-material/water-shaders-wgsl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC,MAAM,CAAC,MAAM,UAAU,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiOpC,CAAC"}

package/dist/modules/math/fp64/fp64-arithmetic-wgsl.d.ts

@@ -1,2 +1,3 @@
-export declare const fp64arithmeticWGSL = "struct Fp64ArithmeticUniforms {\n  ONE: f32,\n  SPLIT: f32,\n};\n\n@group(0) @binding(auto) var<uniform> fp64arithmetic : Fp64ArithmeticUniforms;\n\nfn fp64_nan(seed: f32) -> f32 {\n  let nanBits = 0x7fc00000u | select(0u, 1u, seed < 0.0);\n  return bitcast<f32>(nanBits);\n}\n\nfn fp64_runtime_zero() -> f32 {\n  return fp64arithmetic.ONE * 0.0;\n}\n\nfn prevent_fp64_optimization(value: f32) -> f32 {\n#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n  return value + fp64_runtime_zero();\n#else\n  return value;\n#endif\n}\n\nfn split(a: f32) -> vec2f {\n  let splitValue = prevent_fp64_optimization(fp64arithmetic.SPLIT + fp64_runtime_zero());\n  let t = prevent_fp64_optimization(a * splitValue);\n  let temp = prevent_fp64_optimization(t - a);\n  let aHi = prevent_fp64_optimization(t - temp);\n  let aLo = prevent_fp64_optimization(a - aHi);\n  return vec2f(aHi, aLo);\n}\n\nfn split2(a: vec2f) -> vec2f {\n  var b = split(a.x);\n  b.y = b.y + a.y;\n  return b;\n}\n\nfn quickTwoSum(a: f32, b: f32) -> vec2f {\n#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n  let sum = prevent_fp64_optimization((a + b) * fp64arithmetic.ONE);\n  let err = prevent_fp64_optimization(b - (sum - a) * fp64arithmetic.ONE);\n#else\n  let sum = prevent_fp64_optimization(a + b);\n  let err = prevent_fp64_optimization(b - (sum - a));\n#endif\n  return vec2f(sum, err);\n}\n\nfn twoSum(a: f32, b: f32) -> vec2f {\n  let s = prevent_fp64_optimization(a + b);\n#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n  let v = prevent_fp64_optimization((s * fp64arithmetic.ONE - a) * fp64arithmetic.ONE);\n  let err =\n    prevent_fp64_optimization((a - (s - v) * fp64arithmetic.ONE) *\n      fp64arithmetic.ONE *\n      fp64arithmetic.ONE *\n      fp64arithmetic.ONE) +\n    prevent_fp64_optimization(b - v);\n#else\n  let v = prevent_fp64_optimization(s - a);\n  let err = prevent_fp64_optimization(a - (s - v)) + prevent_fp64_optimization(b - v);\n#endif\n  return vec2f(s, err);\n}\n\nfn twoSub(a: f32, b: f32) -> vec2f {\n  let s = prevent_fp64_optimization(a - b);\n#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n  let v = prevent_fp64_optimization((s * fp64arithmetic.ONE - a) * fp64arithmetic.ONE);\n  let err =\n    prevent_fp64_optimization((a - (s - v) * fp64arithmetic.ONE) *\n      fp64arithmetic.ONE *\n      fp64arithmetic.ONE *\n      fp64arithmetic.ONE) -\n    prevent_fp64_optimization(b + v);\n#else\n  let v = prevent_fp64_optimization(s - a);\n  let err = prevent_fp64_optimization(a - (s - v)) - prevent_fp64_optimization(b + v);\n#endif\n  return vec2f(s, err);\n}\n\nfn twoSqr(a: f32) -> vec2f {\n  let prod = prevent_fp64_optimization(a * a);\n  let aFp64 = split(a);\n  let highProduct = prevent_fp64_optimization(aFp64.x * aFp64.x);\n  let crossProduct = prevent_fp64_optimization(2.0 * aFp64.x * aFp64.y);\n  let lowProduct = prevent_fp64_optimization(aFp64.y * aFp64.y);\n#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n  let err =\n    (prevent_fp64_optimization(highProduct - prod) * fp64arithmetic.ONE +\n      crossProduct * fp64arithmetic.ONE * fp64arithmetic.ONE) +\n    lowProduct * fp64arithmetic.ONE * fp64arithmetic.ONE * fp64arithmetic.ONE;\n#else\n  let err = ((prevent_fp64_optimization(highProduct - prod) + crossProduct) + lowProduct);\n#endif\n  return vec2f(prod, err);\n}\n\nfn twoProd(a: f32, b: f32) -> vec2f {\n  let prod = prevent_fp64_optimization(a * b);\n  let aFp64 = split(a);\n  let bFp64 = split(b);\n  let highProduct = prevent_fp64_optimization(aFp64.x * bFp64.x);\n  let crossProduct1 = prevent_fp64_optimization(aFp64.x * bFp64.y);\n  let crossProduct2 = prevent_fp64_optimization(aFp64.y * bFp64.x);\n  let lowProduct = prevent_fp64_optimization(aFp64.y * bFp64.y);\n#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n  let err1 = (highProduct - prod) * fp64arithmetic.ONE;\n  let err2 = crossProduct1 * fp64arithmetic.ONE * fp64arithmetic.ONE;\n  let err3 = crossProduct2 * fp64arithmetic.ONE * fp64arithmetic.ONE * fp64arithmetic.ONE;\n  let err4 =\n    lowProduct *\n    fp64arithmetic.ONE *\n    fp64arithmetic.ONE *\n    fp64arithmetic.ONE *\n    fp64arithmetic.ONE;\n#else\n  let err1 = highProduct - prod;\n  let err2 = crossProduct1;\n  let err3 = crossProduct2;\n  let err4 = lowProduct;\n#endif\n  let err12InputA = prevent_fp64_optimization(err1);\n  let err12InputB = prevent_fp64_optimization(err2);\n  let err12 = prevent_fp64_optimization(err12InputA + err12InputB);\n  let err123InputA = prevent_fp64_optimization(err12);\n  let err123InputB = prevent_fp64_optimization(err3);\n  let err123 = prevent_fp64_optimization(err123InputA + err123InputB);\n  let err1234InputA = prevent_fp64_optimization(err123);\n  let err1234InputB = prevent_fp64_optimization(err4);\n  let err = prevent_fp64_optimization(err1234InputA + err1234InputB);\n  return vec2f(prod, err);\n}\n\nfn sum_fp64(a: vec2f, b: vec2f) -> vec2f {\n  var s = twoSum(a.x, b.x);\n  let t = twoSum(a.y, b.y);\n  s.y = prevent_fp64_optimization(s.y + t.x);\n  s = quickTwoSum(s.x, s.y);\n  s.y = prevent_fp64_optimization(s.y + t.y);\n  s = quickTwoSum(s.x, s.y);\n  return s;\n}\n\nfn sub_fp64(a: vec2f, b: vec2f) -> vec2f {\n  var s = twoSub(a.x, b.x);\n  let t = twoSub(a.y, b.y);\n  s.y = prevent_fp64_optimization(s.y + t.x);\n  s = quickTwoSum(s.x, s.y);\n  s.y = prevent_fp64_optimization(s.y + t.y);\n  s = quickTwoSum(s.x, s.y);\n  return s;\n}\n\nfn mul_fp64(a: vec2f, b: vec2f) -> vec2f {\n  var prod = twoProd(a.x, b.x);\n  let crossProduct1 = prevent_fp64_optimization(a.x * b.y);\n  prod.y = prevent_fp64_optimization(prod.y + crossProduct1);\n#ifdef LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND\n  prod = split2(prod);\n#endif\n  prod = quickTwoSum(prod.x, prod.y);\n  let crossProduct2 = prevent_fp64_optimization(a.y * b.x);\n  prod.y = prevent_fp64_optimization(prod.y + crossProduct2);\n#ifdef LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND\n  prod = split2(prod);\n#endif\n  prod = quickTwoSum(prod.x, prod.y);\n  return prod;\n}\n\nfn div_fp64(a: vec2f, b: vec2f) -> vec2f {\n  let xn = prevent_fp64_optimization(1.0 / b.x);\n  let yn = mul_fp64(a, vec2f(xn, fp64_runtime_zero()));\n  let diff = prevent_fp64_optimization(sub_fp64(a, mul_fp64(b, yn)).x);\n  let prod = twoProd(xn, diff);\n  return sum_fp64(yn, prod);\n}\n\nfn sqrt_fp64(a: vec2f) -> vec2f {\n  if (a.x == 0.0 && a.y == 0.0) {\n    return vec2f(0.0, 0.0);\n  }\n  if (a.x < 0.0) {\n    let nanValue = fp64_nan(a.x);\n    return vec2f(nanValue, nanValue);\n  }\n\n  let x = prevent_fp64_optimization(1.0 / sqrt(a.x));\n  let yn = prevent_fp64_optimization(a.x * x);\n#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n  let ynSqr = twoSqr(yn) * fp64arithmetic.ONE;\n#else\n  let ynSqr = twoSqr(yn);\n#endif\n  let diff = prevent_fp64_optimization(sub_fp64(a, ynSqr).x);\n  let prod = twoProd(prevent_fp64_optimization(x * 0.5), diff);\n#ifdef LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND\n  return sum_fp64(split(yn), prod);\n#else\n  return sum_fp64(vec2f(yn, 0.0), prod);\n#endif\n}\n";
+/** WGSL source for fp64 arithmetic helpers and raw binary64-to-Float32 subtraction. */
+export declare const fp64arithmeticWGSL = "struct Fp64ArithmeticUniforms {\n  ONE: f32,\n  SPLIT: f32,\n};\n\n@group(0) @binding(auto) var<uniform> fp64arithmetic : Fp64ArithmeticUniforms;\n\nstruct Fp64Bits {\n  sign: u32,\n  exponent: i32,\n  significand: vec2u,\n  isZero: bool,\n  isInf: bool,\n  isNan: bool,\n};\n\nfn fp64_nan(seed: f32) -> f32 {\n  let nanBits = 0x7fc00000u | select(0u, 1u, seed < 0.0);\n  return bitcast<f32>(nanBits);\n}\n\nfn fp64_u64_is_zero(value: vec2u) -> bool {\n  return value.x == 0u && value.y == 0u;\n}\n\nfn fp64_u64_compare(a: vec2u, b: vec2u) -> i32 {\n  if (a.x != b.x) {\n    return select(-1, 1, a.x > b.x);\n  }\n  if (a.y != b.y) {\n    return select(-1, 1, a.y > b.y);\n  }\n  return 0;\n}\n\nfn fp64_u64_add(a: vec2u, b: vec2u) -> vec2u {\n  let low = a.y + b.y;\n  let carry = select(0u, 1u, low < a.y);\n  return vec2u(a.x + b.x + carry, low);\n}\n\nfn fp64_u64_sub(a: vec2u, b: vec2u) -> vec2u {\n  let borrow = select(0u, 1u, a.y < b.y);\n  return vec2u(a.x - b.x - borrow, a.y - b.y);\n}\n\nfn fp64_u64_shift_left(value: vec2u, shift: u32) -> vec2u {\n  if (shift == 0u) {\n    return value;\n  }\n  if (shift < 32u) {\n    return vec2u((value.x << shift) | (value.y >> (32u - shift)), value.y << shift);\n  }\n  if (shift == 32u) {\n    return vec2u(value.y, 0u);\n  }\n  if (shift < 64u) {\n    return vec2u(value.y << (shift - 32u), 0u);\n  }\n  return vec2u(0u);\n}\n\nfn fp64_u64_shift_right(value: vec2u, shift: u32) -> vec2u {\n  if (shift == 0u) {\n    return value;\n  }\n  if (shift < 32u) {\n    return vec2u(value.x >> shift, (value.y >> shift) | (value.x << (32u - shift)));\n  }\n  if (shift == 32u) {\n    return vec2u(0u, value.x);\n  }\n  if (shift < 64u) {\n    return vec2u(0u, value.x >> (shift - 32u));\n  }\n  return vec2u(0u);\n}\n\nfn fp64_u64_get_bit(value: vec2u, bitIndex: u32) -> bool {\n  if (bitIndex >= 64u) {\n    return false;\n  }\n  if (bitIndex >= 32u) {\n    return ((value.x >> (bitIndex - 32u)) & 1u) != 0u;\n  }\n  return ((value.y >> bitIndex) & 1u) != 0u;\n}\n\nfn fp64_u64_has_bits_below(value: vec2u, bitCount: u32) -> bool {\n  if (bitCount == 0u) {\n    return false;\n  }\n  if (bitCount >= 64u) {\n    return !fp64_u64_is_zero(value);\n  }\n  if (bitCount > 32u) {\n    let highBitCount = bitCount - 32u;\n    let highMask = (1u << highBitCount) - 1u;\n    return value.y != 0u || (value.x & highMask) != 0u;\n  }\n  if (bitCount == 32u) {\n    return value.y != 0u;\n  }\n  let lowMask = (1u << bitCount) - 1u;\n  return (value.y & lowMask) != 0u;\n}\n\nfn fp64_u64_shift_right_sticky(value: vec2u, shift: u32) -> vec2u {\n  var shifted = fp64_u64_shift_right(value, shift);\n  if (fp64_u64_has_bits_below(value, shift)) {\n    shifted.y = shifted.y | 1u;\n  }\n  return shifted;\n}\n\nfn fp64_u64_count_leading_zeros(value: vec2u) -> u32 {\n  if (value.x != 0u) {\n    return countLeadingZeros(value.x);\n  }\n  return 32u + countLeadingZeros(value.y);\n}\n\nfn fp64_round_shift_right_to_u32(value: vec2u, shift: u32) -> u32 {\n  if (shift == 0u) {\n    return value.y;\n  }\n\n  let truncated = fp64_u64_shift_right(value, shift);\n  var rounded = truncated.y;\n  let guard = fp64_u64_get_bit(value, shift - 1u);\n  let hasTrailingBits = fp64_u64_has_bits_below(value, shift - 1u);\n  if (guard && (hasTrailingBits || (rounded & 1u) == 1u)) {\n    rounded = rounded + 1u;\n  }\n  return rounded;\n}\n\nfn fp64_make_f32_bits_from_u64(sign: u32, significand: vec2u, baseExponent: i32) -> u32 {\n  if (fp64_u64_is_zero(significand)) {\n    return sign << 31u;\n  }\n\n  let leadingZeros = fp64_u64_count_leading_zeros(significand);\n  let mostSignificantBit = 63u - leadingZeros;\n  var exponent = baseExponent + i32(mostSignificantBit);\n\n  if (exponent > 127) {\n    return (sign << 31u) | 0x7f800000u;\n  }\n\n  if (exponent >= -126) {\n    let shift = i32(mostSignificantBit) - 23;\n    var significand24: u32;\n    if (shift > 0) {\n      significand24 = fp64_round_shift_right_to_u32(significand, u32(shift));\n    } else {\n      significand24 = fp64_u64_shift_left(significand, u32(-shift)).y;\n    }\n\n    if (significand24 >= 0x1000000u) {\n      significand24 = significand24 >> 1u;\n      exponent = exponent + 1;\n      if (exponent > 127) {\n        return (sign << 31u) | 0x7f800000u;\n      }\n    }\n\n    return (sign << 31u) | (u32(exponent + 127) << 23u) | (significand24 & 0x7fffffu);\n  }\n\n  let scaleExponent = baseExponent + 149;\n  var mantissa: u32;\n  if (scaleExponent >= 0) {\n    mantissa = fp64_u64_shift_left(significand, u32(scaleExponent)).y;\n  } else {\n    mantissa = fp64_round_shift_right_to_u32(significand, u32(-scaleExponent));\n  }\n\n  if (mantissa >= 0x800000u) {\n    return (sign << 31u) | 0x00800000u;\n  }\n  return (sign << 31u) | mantissa;\n}\n\nfn fp64_decode_bits(bits: vec2u) -> Fp64Bits {\n  let sign = bits.x >> 31u;\n  let exponentBits = (bits.x >> 20u) & 0x7ffu;\n  let fractionHigh = bits.x & 0xfffffu;\n  let fractionLow = bits.y;\n  let fraction = vec2u(fractionHigh, fractionLow);\n\n  if (exponentBits == 0x7ffu) {\n    let isInf = fp64_u64_is_zero(fraction);\n    return Fp64Bits(sign, 0, vec2u(0u), false, isInf, !isInf);\n  }\n\n  if (exponentBits == 0u) {\n    let isZero = fp64_u64_is_zero(fraction);\n    return Fp64Bits(sign, -1022, fraction, isZero, false, false);\n  }\n\n  return Fp64Bits(sign, i32(exponentBits) - 1023, vec2u((1u << 20u) | fractionHigh, fractionLow), false, false, false);\n}\n\nfn fp64_finite_magnitude_compare(a: Fp64Bits, b: Fp64Bits) -> i32 {\n  if (a.exponent != b.exponent) {\n    return select(-1, 1, a.exponent > b.exponent);\n  }\n  return fp64_u64_compare(a.significand, b.significand);\n}\n\nfn fp64_add_aligned_magnitudes_to_f32_bits(sign: u32, larger: Fp64Bits, smaller: Fp64Bits) -> u32 {\n  let largeSignificand = fp64_u64_shift_left(larger.significand, 3u);\n  let smallSignificand = fp64_u64_shift_right_sticky(\n    fp64_u64_shift_left(smaller.significand, 3u),\n    u32(larger.exponent - smaller.exponent)\n  );\n  let resultSignificand = fp64_u64_add(largeSignificand, smallSignificand);\n  return fp64_make_f32_bits_from_u64(sign, resultSignificand, larger.exponent - 55);\n}\n\nfn fp64_sub_aligned_magnitudes_to_f32_bits(sign: u32, larger: Fp64Bits, smaller: Fp64Bits) -> u32 {\n  let largeSignificand = fp64_u64_shift_left(larger.significand, 3u);\n  let smallSignificand = fp64_u64_shift_right_sticky(\n    fp64_u64_shift_left(smaller.significand, 3u),\n    u32(larger.exponent - smaller.exponent)\n  );\n  let resultSignificand = fp64_u64_sub(largeSignificand, smallSignificand);\n  return fp64_make_f32_bits_from_u64(sign, resultSignificand, larger.exponent - 55);\n}\n\n// Subtract two raw binary64 values and round the exact result once to f32.\n// The input words are canonical high/low words: .x contains sign/exponent/high\n// fraction bits, and .y contains the low 32 fraction bits.\nfn sub_fp64u32_to_f32_bits(aBits: vec2u, bBits: vec2u) -> u32 {\n  let a = fp64_decode_bits(aBits);\n  let b = fp64_decode_bits(bBits);\n  let bSubtractionSign = b.sign ^ 1u;\n\n  if (a.isNan || b.isNan) {\n    return 0x7fc00000u;\n  }\n  if (a.isInf && b.isInf) {\n    if (a.sign == bSubtractionSign) {\n      return (a.sign << 31u) | 0x7f800000u;\n    }\n    return 0x7fc00000u;\n  }\n  if (a.isInf) {\n    return (a.sign << 31u) | 0x7f800000u;\n  }\n  if (b.isInf) {\n    return (bSubtractionSign << 31u) | 0x7f800000u;\n  }\n  if (a.isZero && b.isZero) {\n    return select(0u, 0x80000000u, a.sign == 1u && b.sign == 0u);\n  }\n\n  let magnitudeComparison = fp64_finite_magnitude_compare(a, b);\n  if (a.sign == bSubtractionSign) {\n    if (magnitudeComparison >= 0) {\n      return fp64_add_aligned_magnitudes_to_f32_bits(a.sign, a, b);\n    }\n    return fp64_add_aligned_magnitudes_to_f32_bits(a.sign, b, a);\n  }\n\n  if (magnitudeComparison == 0) {\n    return 0u;\n  }\n  if (magnitudeComparison > 0) {\n    return fp64_sub_aligned_magnitudes_to_f32_bits(a.sign, a, b);\n  }\n  return fp64_sub_aligned_magnitudes_to_f32_bits(bSubtractionSign, b, a);\n}\n\nfn sub_fp64u32_to_f32(aBits: vec2u, bBits: vec2u) -> f32 {\n  return bitcast<f32>(sub_fp64u32_to_f32_bits(aBits, bBits));\n}\n\nfn fp64_runtime_zero() -> f32 {\n  return fp64arithmetic.ONE * 0.0;\n}\n\nfn prevent_fp64_optimization(value: f32) -> f32 {\n#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n  return value + fp64_runtime_zero();\n#else\n  return value;\n#endif\n}\n\nfn split(a: f32) -> vec2f {\n  let splitValue = prevent_fp64_optimization(fp64arithmetic.SPLIT + fp64_runtime_zero());\n  let t = prevent_fp64_optimization(a * splitValue);\n  let temp = prevent_fp64_optimization(t - a);\n  let aHi = prevent_fp64_optimization(t - temp);\n  let aLo = prevent_fp64_optimization(a - aHi);\n  return vec2f(aHi, aLo);\n}\n\nfn split2(a: vec2f) -> vec2f {\n  var b = split(a.x);\n  b.y = b.y + a.y;\n  return b;\n}\n\nfn quickTwoSum(a: f32, b: f32) -> vec2f {\n#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n  let sum = prevent_fp64_optimization((a + b) * fp64arithmetic.ONE);\n  let err = prevent_fp64_optimization(b - (sum - a) * fp64arithmetic.ONE);\n#else\n  let sum = prevent_fp64_optimization(a + b);\n  let err = prevent_fp64_optimization(b - (sum - a));\n#endif\n  return vec2f(sum, err);\n}\n\nfn twoSum(a: f32, b: f32) -> vec2f {\n  let s = prevent_fp64_optimization(a + b);\n#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n  let v = prevent_fp64_optimization((s * fp64arithmetic.ONE - a) * fp64arithmetic.ONE);\n  let err =\n    prevent_fp64_optimization((a - (s - v) * fp64arithmetic.ONE) *\n      fp64arithmetic.ONE *\n      fp64arithmetic.ONE *\n      fp64arithmetic.ONE) +\n    prevent_fp64_optimization(b - v);\n#else\n  let v = prevent_fp64_optimization(s - a);\n  let err = prevent_fp64_optimization(a - (s - v)) + prevent_fp64_optimization(b - v);\n#endif\n  return vec2f(s, err);\n}\n\nfn twoSub(a: f32, b: f32) -> vec2f {\n  let s = prevent_fp64_optimization(a - b);\n#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n  let v = prevent_fp64_optimization((s * fp64arithmetic.ONE - a) * fp64arithmetic.ONE);\n  let err =\n    prevent_fp64_optimization((a - (s - v) * fp64arithmetic.ONE) *\n      fp64arithmetic.ONE *\n      fp64arithmetic.ONE *\n      fp64arithmetic.ONE) -\n    prevent_fp64_optimization(b + v);\n#else\n  let v = prevent_fp64_optimization(s - a);\n  let err = prevent_fp64_optimization(a - (s - v)) - prevent_fp64_optimization(b + v);\n#endif\n  return vec2f(s, err);\n}\n\nfn twoSqr(a: f32) -> vec2f {\n  let prod = prevent_fp64_optimization(a * a);\n  let aFp64 = split(a);\n  let highProduct = prevent_fp64_optimization(aFp64.x * aFp64.x);\n  let crossProduct = prevent_fp64_optimization(2.0 * aFp64.x * aFp64.y);\n  let lowProduct = prevent_fp64_optimization(aFp64.y * aFp64.y);\n#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n  let err =\n    (prevent_fp64_optimization(highProduct - prod) * fp64arithmetic.ONE +\n      crossProduct * fp64arithmetic.ONE * fp64arithmetic.ONE) +\n    lowProduct * fp64arithmetic.ONE * fp64arithmetic.ONE * fp64arithmetic.ONE;\n#else\n  let err = ((prevent_fp64_optimization(highProduct - prod) + crossProduct) + lowProduct);\n#endif\n  return vec2f(prod, err);\n}\n\nfn twoProd(a: f32, b: f32) -> vec2f {\n  let prod = prevent_fp64_optimization(a * b);\n  let aFp64 = split(a);\n  let bFp64 = split(b);\n  let highProduct = prevent_fp64_optimization(aFp64.x * bFp64.x);\n  let crossProduct1 = prevent_fp64_optimization(aFp64.x * bFp64.y);\n  let crossProduct2 = prevent_fp64_optimization(aFp64.y * bFp64.x);\n  let lowProduct = prevent_fp64_optimization(aFp64.y * bFp64.y);\n#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n  let err1 = (highProduct - prod) * fp64arithmetic.ONE;\n  let err2 = crossProduct1 * fp64arithmetic.ONE * fp64arithmetic.ONE;\n  let err3 = crossProduct2 * fp64arithmetic.ONE * fp64arithmetic.ONE * fp64arithmetic.ONE;\n  let err4 =\n    lowProduct *\n    fp64arithmetic.ONE *\n    fp64arithmetic.ONE *\n    fp64arithmetic.ONE *\n    fp64arithmetic.ONE;\n#else\n  let err1 = highProduct - prod;\n  let err2 = crossProduct1;\n  let err3 = crossProduct2;\n  let err4 = lowProduct;\n#endif\n  let err12InputA = prevent_fp64_optimization(err1);\n  let err12InputB = prevent_fp64_optimization(err2);\n  let err12 = prevent_fp64_optimization(err12InputA + err12InputB);\n  let err123InputA = prevent_fp64_optimization(err12);\n  let err123InputB = prevent_fp64_optimization(err3);\n  let err123 = prevent_fp64_optimization(err123InputA + err123InputB);\n  let err1234InputA = prevent_fp64_optimization(err123);\n  let err1234InputB = prevent_fp64_optimization(err4);\n  let err = prevent_fp64_optimization(err1234InputA + err1234InputB);\n  return vec2f(prod, err);\n}\n\nfn sum_fp64(a: vec2f, b: vec2f) -> vec2f {\n  var s = twoSum(a.x, b.x);\n  let t = twoSum(a.y, b.y);\n  s.y = prevent_fp64_optimization(s.y + t.x);\n  s = quickTwoSum(s.x, s.y);\n  s.y = prevent_fp64_optimization(s.y + t.y);\n  s = quickTwoSum(s.x, s.y);\n  return s;\n}\n\nfn sub_fp64(a: vec2f, b: vec2f) -> vec2f {\n  var s = twoSub(a.x, b.x);\n  let t = twoSub(a.y, b.y);\n  s.y = prevent_fp64_optimization(s.y + t.x);\n  s = quickTwoSum(s.x, s.y);\n  s.y = prevent_fp64_optimization(s.y + t.y);\n  s = quickTwoSum(s.x, s.y);\n  return s;\n}\n\nfn mul_fp64(a: vec2f, b: vec2f) -> vec2f {\n  var prod = twoProd(a.x, b.x);\n  let crossProduct1 = prevent_fp64_optimization(a.x * b.y);\n  prod.y = prevent_fp64_optimization(prod.y + crossProduct1);\n#ifdef LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND\n  prod = split2(prod);\n#endif\n  prod = quickTwoSum(prod.x, prod.y);\n  let crossProduct2 = prevent_fp64_optimization(a.y * b.x);\n  prod.y = prevent_fp64_optimization(prod.y + crossProduct2);\n#ifdef LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND\n  prod = split2(prod);\n#endif\n  prod = quickTwoSum(prod.x, prod.y);\n  return prod;\n}\n\nfn div_fp64(a: vec2f, b: vec2f) -> vec2f {\n  let xn = prevent_fp64_optimization(1.0 / b.x);\n  let yn = mul_fp64(a, vec2f(xn, fp64_runtime_zero()));\n  let diff = prevent_fp64_optimization(sub_fp64(a, mul_fp64(b, yn)).x);\n  let prod = twoProd(xn, diff);\n  return sum_fp64(yn, prod);\n}\n\nfn sqrt_fp64(a: vec2f) -> vec2f {\n  if (a.x == 0.0 && a.y == 0.0) {\n    return vec2f(0.0, 0.0);\n  }\n  if (a.x < 0.0) {\n    let nanValue = fp64_nan(a.x);\n    return vec2f(nanValue, nanValue);\n  }\n\n  let x = prevent_fp64_optimization(1.0 / sqrt(a.x));\n  let yn = prevent_fp64_optimization(a.x * x);\n#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND\n  let ynSqr = twoSqr(yn) * fp64arithmetic.ONE;\n#else\n  let ynSqr = twoSqr(yn);\n#endif\n  let diff = prevent_fp64_optimization(sub_fp64(a, ynSqr).x);\n  let prod = twoProd(prevent_fp64_optimization(x * 0.5), diff);\n#ifdef LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND\n  return sum_fp64(split(yn), prod);\n#else\n  return sum_fp64(vec2f(yn, 0.0), prod);\n#endif\n}\n";
 //# sourceMappingURL=fp64-arithmetic-wgsl.d.ts.map

package/dist/modules/math/fp64/fp64-arithmetic-wgsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fp64-arithmetic-wgsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64-arithmetic-wgsl.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,kBAAkB,yyNA+M9B,CAAC"}
+{"version":3,"file":"fp64-arithmetic-wgsl.d.ts","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64-arithmetic-wgsl.ts"],"names":[],"mappings":"AAIA,uFAAuF;AACvF,eAAO,MAAM,kBAAkB,o/cA0d9B,CAAC"}

package/dist/modules/math/fp64/fp64-arithmetic-wgsl.js

@@ -1,6 +1,7 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
+/** WGSL source for fp64 arithmetic helpers and raw binary64-to-Float32 subtraction. */
 export const fp64arithmeticWGSL = /* wgsl */ `\
 struct Fp64ArithmeticUniforms {
   ONE: f32,
@@ -9,11 +10,278 @@ struct Fp64ArithmeticUniforms {
 
 @group(0) @binding(auto) var<uniform> fp64arithmetic : Fp64ArithmeticUniforms;
 
+struct Fp64Bits {
+  sign: u32,
+  exponent: i32,
+  significand: vec2u,
+  isZero: bool,
+  isInf: bool,
+  isNan: bool,
+};
+
 fn fp64_nan(seed: f32) -> f32 {
   let nanBits = 0x7fc00000u | select(0u, 1u, seed < 0.0);
   return bitcast<f32>(nanBits);
 }
 
+fn fp64_u64_is_zero(value: vec2u) -> bool {
+  return value.x == 0u && value.y == 0u;
+}
+
+fn fp64_u64_compare(a: vec2u, b: vec2u) -> i32 {
+  if (a.x != b.x) {
+    return select(-1, 1, a.x > b.x);
+  }
+  if (a.y != b.y) {
+    return select(-1, 1, a.y > b.y);
+  }
+  return 0;
+}
+
+fn fp64_u64_add(a: vec2u, b: vec2u) -> vec2u {
+  let low = a.y + b.y;
+  let carry = select(0u, 1u, low < a.y);
+  return vec2u(a.x + b.x + carry, low);
+}
+
+fn fp64_u64_sub(a: vec2u, b: vec2u) -> vec2u {
+  let borrow = select(0u, 1u, a.y < b.y);
+  return vec2u(a.x - b.x - borrow, a.y - b.y);
+}
+
+fn fp64_u64_shift_left(value: vec2u, shift: u32) -> vec2u {
+  if (shift == 0u) {
+    return value;
+  }
+  if (shift < 32u) {
+    return vec2u((value.x << shift) | (value.y >> (32u - shift)), value.y << shift);
+  }
+  if (shift == 32u) {
+    return vec2u(value.y, 0u);
+  }
+  if (shift < 64u) {
+    return vec2u(value.y << (shift - 32u), 0u);
+  }
+  return vec2u(0u);
+}
+
+fn fp64_u64_shift_right(value: vec2u, shift: u32) -> vec2u {
+  if (shift == 0u) {
+    return value;
+  }
+  if (shift < 32u) {
+    return vec2u(value.x >> shift, (value.y >> shift) | (value.x << (32u - shift)));
+  }
+  if (shift == 32u) {
+    return vec2u(0u, value.x);
+  }
+  if (shift < 64u) {
+    return vec2u(0u, value.x >> (shift - 32u));
+  }
+  return vec2u(0u);
+}
+
+fn fp64_u64_get_bit(value: vec2u, bitIndex: u32) -> bool {
+  if (bitIndex >= 64u) {
+    return false;
+  }
+  if (bitIndex >= 32u) {
+    return ((value.x >> (bitIndex - 32u)) & 1u) != 0u;
+  }
+  return ((value.y >> bitIndex) & 1u) != 0u;
+}
+
+fn fp64_u64_has_bits_below(value: vec2u, bitCount: u32) -> bool {
+  if (bitCount == 0u) {
+    return false;
+  }
+  if (bitCount >= 64u) {
+    return !fp64_u64_is_zero(value);
+  }
+  if (bitCount > 32u) {
+    let highBitCount = bitCount - 32u;
+    let highMask = (1u << highBitCount) - 1u;
+    return value.y != 0u || (value.x & highMask) != 0u;
+  }
+  if (bitCount == 32u) {
+    return value.y != 0u;
+  }
+  let lowMask = (1u << bitCount) - 1u;
+  return (value.y & lowMask) != 0u;
+}
+
+fn fp64_u64_shift_right_sticky(value: vec2u, shift: u32) -> vec2u {
+  var shifted = fp64_u64_shift_right(value, shift);
+  if (fp64_u64_has_bits_below(value, shift)) {
+    shifted.y = shifted.y | 1u;
+  }
+  return shifted;
+}
+
+fn fp64_u64_count_leading_zeros(value: vec2u) -> u32 {
+  if (value.x != 0u) {
+    return countLeadingZeros(value.x);
+  }
+  return 32u + countLeadingZeros(value.y);
+}
+
+fn fp64_round_shift_right_to_u32(value: vec2u, shift: u32) -> u32 {
+  if (shift == 0u) {
+    return value.y;
+  }
+
+  let truncated = fp64_u64_shift_right(value, shift);
+  var rounded = truncated.y;
+  let guard = fp64_u64_get_bit(value, shift - 1u);
+  let hasTrailingBits = fp64_u64_has_bits_below(value, shift - 1u);
+  if (guard && (hasTrailingBits || (rounded & 1u) == 1u)) {
+    rounded = rounded + 1u;
+  }
+  return rounded;
+}
+
+fn fp64_make_f32_bits_from_u64(sign: u32, significand: vec2u, baseExponent: i32) -> u32 {
+  if (fp64_u64_is_zero(significand)) {
+    return sign << 31u;
+  }
+
+  let leadingZeros = fp64_u64_count_leading_zeros(significand);
+  let mostSignificantBit = 63u - leadingZeros;
+  var exponent = baseExponent + i32(mostSignificantBit);
+
+  if (exponent > 127) {
+    return (sign << 31u) | 0x7f800000u;
+  }
+
+  if (exponent >= -126) {
+    let shift = i32(mostSignificantBit) - 23;
+    var significand24: u32;
+    if (shift > 0) {
+      significand24 = fp64_round_shift_right_to_u32(significand, u32(shift));
+    } else {
+      significand24 = fp64_u64_shift_left(significand, u32(-shift)).y;
+    }
+
+    if (significand24 >= 0x1000000u) {
+      significand24 = significand24 >> 1u;
+      exponent = exponent + 1;
+      if (exponent > 127) {
+        return (sign << 31u) | 0x7f800000u;
+      }
+    }
+
+    return (sign << 31u) | (u32(exponent + 127) << 23u) | (significand24 & 0x7fffffu);
+  }
+
+  let scaleExponent = baseExponent + 149;
+  var mantissa: u32;
+  if (scaleExponent >= 0) {
+    mantissa = fp64_u64_shift_left(significand, u32(scaleExponent)).y;
+  } else {
+    mantissa = fp64_round_shift_right_to_u32(significand, u32(-scaleExponent));
+  }
+
+  if (mantissa >= 0x800000u) {
+    return (sign << 31u) | 0x00800000u;
+  }
+  return (sign << 31u) | mantissa;
+}
+
+fn fp64_decode_bits(bits: vec2u) -> Fp64Bits {
+  let sign = bits.x >> 31u;
+  let exponentBits = (bits.x >> 20u) & 0x7ffu;
+  let fractionHigh = bits.x & 0xfffffu;
+  let fractionLow = bits.y;
+  let fraction = vec2u(fractionHigh, fractionLow);
+
+  if (exponentBits == 0x7ffu) {
+    let isInf = fp64_u64_is_zero(fraction);
+    return Fp64Bits(sign, 0, vec2u(0u), false, isInf, !isInf);
+  }
+
+  if (exponentBits == 0u) {
+    let isZero = fp64_u64_is_zero(fraction);
+    return Fp64Bits(sign, -1022, fraction, isZero, false, false);
+  }
+
+  return Fp64Bits(sign, i32(exponentBits) - 1023, vec2u((1u << 20u) | fractionHigh, fractionLow), false, false, false);
+}
+
+fn fp64_finite_magnitude_compare(a: Fp64Bits, b: Fp64Bits) -> i32 {
+  if (a.exponent != b.exponent) {
+    return select(-1, 1, a.exponent > b.exponent);
+  }
+  return fp64_u64_compare(a.significand, b.significand);
+}
+
+fn fp64_add_aligned_magnitudes_to_f32_bits(sign: u32, larger: Fp64Bits, smaller: Fp64Bits) -> u32 {
+  let largeSignificand = fp64_u64_shift_left(larger.significand, 3u);
+  let smallSignificand = fp64_u64_shift_right_sticky(
+    fp64_u64_shift_left(smaller.significand, 3u),
+    u32(larger.exponent - smaller.exponent)
+  );
+  let resultSignificand = fp64_u64_add(largeSignificand, smallSignificand);
+  return fp64_make_f32_bits_from_u64(sign, resultSignificand, larger.exponent - 55);
+}
+
+fn fp64_sub_aligned_magnitudes_to_f32_bits(sign: u32, larger: Fp64Bits, smaller: Fp64Bits) -> u32 {
+  let largeSignificand = fp64_u64_shift_left(larger.significand, 3u);
+  let smallSignificand = fp64_u64_shift_right_sticky(
+    fp64_u64_shift_left(smaller.significand, 3u),
+    u32(larger.exponent - smaller.exponent)
+  );
+  let resultSignificand = fp64_u64_sub(largeSignificand, smallSignificand);
+  return fp64_make_f32_bits_from_u64(sign, resultSignificand, larger.exponent - 55);
+}
+
+// Subtract two raw binary64 values and round the exact result once to f32.
+// The input words are canonical high/low words: .x contains sign/exponent/high
+// fraction bits, and .y contains the low 32 fraction bits.
+fn sub_fp64u32_to_f32_bits(aBits: vec2u, bBits: vec2u) -> u32 {
+  let a = fp64_decode_bits(aBits);
+  let b = fp64_decode_bits(bBits);
+  let bSubtractionSign = b.sign ^ 1u;
+
+  if (a.isNan || b.isNan) {
+    return 0x7fc00000u;
+  }
+  if (a.isInf && b.isInf) {
+    if (a.sign == bSubtractionSign) {
+      return (a.sign << 31u) | 0x7f800000u;
+    }
+    return 0x7fc00000u;
+  }
+  if (a.isInf) {
+    return (a.sign << 31u) | 0x7f800000u;
+  }
+  if (b.isInf) {
+    return (bSubtractionSign << 31u) | 0x7f800000u;
+  }
+  if (a.isZero && b.isZero) {
+    return select(0u, 0x80000000u, a.sign == 1u && b.sign == 0u);
+  }
+
+  let magnitudeComparison = fp64_finite_magnitude_compare(a, b);
+  if (a.sign == bSubtractionSign) {
+    if (magnitudeComparison >= 0) {
+      return fp64_add_aligned_magnitudes_to_f32_bits(a.sign, a, b);
+    }
+    return fp64_add_aligned_magnitudes_to_f32_bits(a.sign, b, a);
+  }
+
+  if (magnitudeComparison == 0) {
+    return 0u;
+  }
+  if (magnitudeComparison > 0) {
+    return fp64_sub_aligned_magnitudes_to_f32_bits(a.sign, a, b);
+  }
+  return fp64_sub_aligned_magnitudes_to_f32_bits(bSubtractionSign, b, a);
+}
+
+fn sub_fp64u32_to_f32(aBits: vec2u, bBits: vec2u) -> f32 {
+  return bitcast<f32>(sub_fp64u32_to_f32_bits(aBits, bBits));
+}
+
 fn fp64_runtime_zero() -> f32 {
   return fp64arithmetic.ONE * 0.0;
 }

package/dist/modules/math/fp64/fp64-arithmetic-wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"fp64-arithmetic-wgsl.js","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64-arithmetic-wgsl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+M5C,CAAC"}
+{"version":3,"file":"fp64-arithmetic-wgsl.js","sourceRoot":"","sources":["../../../../src/modules/math/fp64/fp64-arithmetic-wgsl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC,uFAAuF;AACvF,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0d5C,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luma.gl/shadertools",
-  "version": "9.3.6",
+  "version": "9.4.0-alpha.1",
   "description": "Shader module system for luma.gl",
   "type": "module",
   "license": "MIT",
@@ -52,5 +52,5 @@
     "@math.gl/core": "^4.1.0",
     "@math.gl/types": "^4.1.0"
   },
-  "gitHead": "725fed5e23fd39ca65229da1e8f048235fe3d4e9"
+  "gitHead": "360b5ac37102a9ab1ae6470d2c70dfa473aba70d"
 }