@luma.gl/shadertools 9.3.0-alpha.6 → 9.3.0-alpha.8

package/src/modules/lighting/pbr-material/pbr-material.ts

@@ -16,6 +16,7 @@ import type {
 
 import {ShaderModule} from '../../../lib/shader-module/shader-module';
 import {lighting} from '../lights/lighting';
+import {ibl} from '../ibl/ibl';
 
 import {vs, fs} from './pbr-material-glsl';
 import {source} from './pbr-material-wgsl';
@@ -33,18 +34,16 @@ export type PBRMaterialBindings = {
   pbr_specularColorSampler?: Texture | null; // #ifdef HAS_SPECULARCOLORMAP
   pbr_specularIntensitySampler?: Texture | null; // #ifdef HAS_SPECULARINTENSITYMAP
   pbr_transmissionSampler?: Texture | null; // #ifdef HAS_TRANSMISSIONMAP
+  pbr_thicknessSampler?: Texture | null; // #ifdef HAS_THICKNESSMAP
 
   pbr_clearcoatSampler?: Texture | null; // #ifdef HAS_CLEARCOATMAP
-  pbr_clearcoatRoughnessSampler?: Texture | null; // #ifdef HAS_CLEARCOATMAP
+  pbr_clearcoatRoughnessSampler?: Texture | null; // #ifdef HAS_CLEARCOATROUGHNESSMAP
+  pbr_clearcoatNormalSampler?: Texture | null; // #ifdef HAS_CLEARCOATNORMALMAP
   pbr_sheenColorSampler?: Texture | null; // #ifdef HAS_SHEENCOLORMAP
-  pbr_sheenRoughnessSampler?: Texture | null; // #ifdef HAS_SHEENCOLORMAP
+  pbr_sheenRoughnessSampler?: Texture | null; // #ifdef HAS_SHEENROUGHNESSMAP
   pbr_iridescenceSampler?: Texture | null; // #ifdef HAS_IRIDESCENCEMAP
+  pbr_iridescenceThicknessSampler?: Texture | null; // #ifdef HAS_IRIDESCENCETHICKNESSMAP
   pbr_anisotropySampler?: Texture | null; // #ifdef HAS_ANISOTROPYMAP
-
-  // IBL Samplers
-  pbr_diffuseEnvSampler?: Texture | null; // #ifdef USE_IBL (samplerCube)
-  pbr_specularEnvSampler?: Texture | null; // #ifdef USE_IBL (samplerCube)
-  pbr_BrdfLUT?: Texture | null; // #ifdef USE_IBL
 };
 
 export type PBRMaterialUniforms = {
@@ -96,10 +95,12 @@ export type PBRMaterialUniforms = {
   clearcoatFactor?: number;
   clearcoatRoughnessFactor?: number;
   clearcoatMapEnabled?: boolean;
+  clearcoatRoughnessMapEnabled?: boolean;
 
   sheenColorFactor?: Readonly<Vector3 | NumberArray3>;
   sheenRoughnessFactor?: number;
   sheenColorMapEnabled?: boolean;
+  sheenRoughnessMapEnabled?: boolean;
 
   iridescenceFactor?: number;
   iridescenceIor?: number;
@@ -123,9 +124,93 @@ export type PBRMaterialProps = PBRMaterialBindings & PBRMaterialUniforms;
 export const pbrMaterial = {
   props: {} as PBRMaterialProps,
   uniforms: {} as PBRMaterialUniforms,
+  defaultUniforms: {
+    unlit: false,
+
+    baseColorMapEnabled: false,
+    baseColorFactor: [1, 1, 1, 1],
+
+    normalMapEnabled: false,
+    normalScale: 1,
+
+    emissiveMapEnabled: false,
+    emissiveFactor: [0, 0, 0],
+
+    metallicRoughnessValues: [1, 1],
+    metallicRoughnessMapEnabled: false,
+
+    occlusionMapEnabled: false,
+    occlusionStrength: 1,
+
+    alphaCutoffEnabled: false,
+    alphaCutoff: 0.5,
+
+    IBLenabled: false,
+    scaleIBLAmbient: [1, 1],
+
+    scaleDiffBaseMR: [0, 0, 0, 0],
+    scaleFGDSpec: [0, 0, 0, 0],
+
+    specularColorFactor: [1, 1, 1],
+    specularIntensityFactor: 1,
+    specularColorMapEnabled: false,
+    specularIntensityMapEnabled: false,
+
+    ior: 1.5,
+
+    transmissionFactor: 0,
+    transmissionMapEnabled: false,
+
+    thicknessFactor: 0,
+    attenuationDistance: 1e9,
+    attenuationColor: [1, 1, 1],
+
+    clearcoatFactor: 0,
+    clearcoatRoughnessFactor: 0,
+    clearcoatMapEnabled: false,
+    clearcoatRoughnessMapEnabled: false,
+
+    sheenColorFactor: [0, 0, 0],
+    sheenRoughnessFactor: 0,
+    sheenColorMapEnabled: false,
+    sheenRoughnessMapEnabled: false,
+
+    iridescenceFactor: 0,
+    iridescenceIor: 1.3,
+    iridescenceThicknessRange: [100, 400],
+    iridescenceMapEnabled: false,
+
+    anisotropyStrength: 0,
+    anisotropyRotation: 0,
+    anisotropyDirection: [1, 0],
+    anisotropyMapEnabled: false,
+
+    emissiveStrength: 1
+  } as Required<PBRMaterialUniforms>,
 
   name: 'pbrMaterial',
-  dependencies: [lighting, pbrProjection],
+  firstBindingSlot: 0,
+  bindingLayout: [
+    {name: 'pbrMaterial', group: 3},
+    {name: 'pbr_baseColorSampler', group: 3},
+    {name: 'pbr_normalSampler', group: 3},
+    {name: 'pbr_emissiveSampler', group: 3},
+    {name: 'pbr_metallicRoughnessSampler', group: 3},
+    {name: 'pbr_occlusionSampler', group: 3},
+    {name: 'pbr_specularColorSampler', group: 3},
+    {name: 'pbr_specularIntensitySampler', group: 3},
+    {name: 'pbr_transmissionSampler', group: 3},
+    {name: 'pbr_thicknessSampler', group: 3},
+    {name: 'pbr_clearcoatSampler', group: 3},
+    {name: 'pbr_clearcoatRoughnessSampler', group: 3},
+    {name: 'pbr_clearcoatNormalSampler', group: 3},
+    {name: 'pbr_sheenColorSampler', group: 3},
+    {name: 'pbr_sheenRoughnessSampler', group: 3},
+    {name: 'pbr_iridescenceSampler', group: 3},
+    {name: 'pbr_iridescenceThicknessSampler', group: 3},
+    {name: 'pbr_anisotropySampler', group: 3}
+  ],
+  dependencies: [lighting, ibl, pbrProjection],
   source,
   vs,
   fs,
@@ -140,10 +225,16 @@ export const pbrMaterial = {
     HAS_SPECULARCOLORMAP: false,
     HAS_SPECULARINTENSITYMAP: false,
     HAS_TRANSMISSIONMAP: false,
+    HAS_THICKNESSMAP: false,
     HAS_CLEARCOATMAP: false,
+    HAS_CLEARCOATROUGHNESSMAP: false,
+    HAS_CLEARCOATNORMALMAP: false,
     HAS_SHEENCOLORMAP: false,
+    HAS_SHEENROUGHNESSMAP: false,
     HAS_IRIDESCENCEMAP: false,
+    HAS_IRIDESCENCETHICKNESSMAP: false,
     HAS_ANISOTROPYMAP: false,
+    USE_MATERIAL_EXTENSIONS: false,
     ALPHA_CUTOFF: false,
     USE_IBL: false,
     PBR_DEBUG: false
@@ -172,15 +263,6 @@ export const pbrMaterial = {
     alphaCutoffEnabled: 'i32',
     alphaCutoff: 'f32', // #ifdef ALPHA_CUTOFF
 
-    // IBL
-    IBLenabled: 'i32',
-    scaleIBLAmbient: 'vec2<f32>', // #ifdef USE_IBL
-
-    // debugging flags used for shader output of intermediate PBR variables
-    // #ifdef PBR_DEBUG
-    scaleDiffBaseMR: 'vec4<f32>',
-    scaleFGDSpec: 'vec4<f32>',
-
     specularColorFactor: 'vec3<f32>',
     specularIntensityFactor: 'f32',
     specularColorMapEnabled: 'i32',
@@ -198,10 +280,12 @@ export const pbrMaterial = {
     clearcoatFactor: 'f32',
     clearcoatRoughnessFactor: 'f32',
     clearcoatMapEnabled: 'i32',
+    clearcoatRoughnessMapEnabled: 'i32',
 
     sheenColorFactor: 'vec3<f32>',
     sheenRoughnessFactor: 'f32',
     sheenColorMapEnabled: 'i32',
+    sheenRoughnessMapEnabled: 'i32',
 
     iridescenceFactor: 'f32',
     iridescenceIor: 'f32',
@@ -213,6 +297,15 @@ export const pbrMaterial = {
     anisotropyDirection: 'vec2<f32>',
     anisotropyMapEnabled: 'i32',
 
-    emissiveStrength: 'f32'
+    emissiveStrength: 'f32',
+
+    // IBL
+    IBLenabled: 'i32',
+    scaleIBLAmbient: 'vec2<f32>', // #ifdef USE_IBL
+
+    // debugging flags used for shader output of intermediate PBR variables
+    // #ifdef PBR_DEBUG
+    scaleDiffBaseMR: 'vec4<f32>',
+    scaleFGDSpec: 'vec4<f32>'
   }
 } as const satisfies ShaderModule<PBRMaterialProps, PBRMaterialUniforms, PBRMaterialBindings>;

package/src/modules/lighting/pbr-material/pbr-projection.ts

@@ -23,7 +23,7 @@ struct pbrProjectionUniforms {
   camera: vec3<f32>
 };
 
-@binding(0) @group(0) var<uniform> pbrProjection: pbrProjectionUniforms;
+@group(0) @binding(auto) var<uniform> pbrProjection: pbrProjectionUniforms;
 `;
 
 export type PBRProjectionProps = {
@@ -35,6 +35,7 @@ export type PBRProjectionProps = {
 
 export const pbrProjection: ShaderModule<PBRProjectionProps> = {
   name: 'pbrProjection',
+  bindingLayout: [{name: 'pbrProjection', group: 0}],
   source: wgslUniformBlock,
   vs: uniformBlock,
   fs: uniformBlock,

package/src/modules/lighting/phong-material/phong-material.ts

@@ -9,6 +9,7 @@ import {PHONG_WGSL} from './phong-shaders-wgsl';
 import {PHONG_VS, PHONG_FS} from './phong-shaders-glsl';
 
 export type PhongMaterialProps = {
+  unlit?: boolean;
   ambient?: number;
   diffuse?: number;
   /** Specularity exponent */
@@ -19,6 +20,8 @@ export type PhongMaterialProps = {
 /** In Phong shading, the normal vector is linearly interpolated across the surface of the polygon from the polygon's vertex normals. */
 export const phongMaterial: ShaderModule<PhongMaterialProps> = {
   name: 'phongMaterial',
+  firstBindingSlot: 0,
+  bindingLayout: [{name: 'phongMaterial', group: 3}],
   dependencies: [lighting],
   // Note these are switched between phong and gouraud
   source: PHONG_WGSL,
@@ -28,12 +31,14 @@ export const phongMaterial: ShaderModule<PhongMaterialProps> = {
     LIGHTING_FRAGMENT: true
   },
   uniformTypes: {
+    unlit: 'i32',
     ambient: 'f32',
     diffuse: 'f32',
     shininess: 'f32',
     specularColor: 'vec3<f32>'
   },
   defaultUniforms: {
+    unlit: false,
     ambient: 0.35,
     diffuse: 0.6,
     shininess: 32,

package/src/modules/lighting/phong-material/phong-shaders-glsl.ts

@@ -4,6 +4,7 @@
 
 export const PHONG_VS = /* glsl */ `\
 uniform phongMaterialUniforms {
+  uniform bool unlit;
   uniform float ambient;
   uniform float diffuse;
   uniform float shininess;
@@ -12,9 +13,8 @@ uniform phongMaterialUniforms {
 `;
 
 export const PHONG_FS = /* glsl */ `\
-#define MAX_LIGHTS 3
-
 uniform phongMaterialUniforms {
+  uniform bool unlit;
   uniform float ambient;
   uniform float diffuse;
   uniform float shininess;
@@ -36,6 +36,10 @@ vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_d
 vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
   vec3 lightColor = surfaceColor;
 
+  if (material.unlit) {
+    return surfaceColor;
+  }
+
   if (lighting.enabled == 0) {
     return lightColor;
   }
@@ -51,8 +55,15 @@ vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 positio
     lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color / light_attenuation);
   }
 
-  int totalLights = min(MAX_LIGHTS, lighting.pointLightCount + lighting.directionalLightCount);
-  for (int i = lighting.pointLightCount; i < totalLights; i++) {
+  for (int i = 0; i < lighting.spotLightCount; i++) {
+    SpotLight spotLight = lighting_getSpotLight(i);
+    vec3 light_position_worldspace = spotLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    float light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, spotLight.color / light_attenuation);
+  }
+
+  for (int i = 0; i < lighting.directionalLightCount; i++) {
     DirectionalLight directionalLight = lighting_getDirectionalLight(i);
     lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
   }

package/src/modules/lighting/phong-material/phong-shaders-wgsl.ts

@@ -4,13 +4,14 @@
 
 export const PHONG_WGSL = /* wgsl */ `\
 struct phongMaterialUniforms {
+  unlit: u32,
   ambient: f32,
   diffuse: f32,
   shininess: f32,
   specularColor: vec3<f32>,
 };
 
-@binding(2) @group(0) var<uniform> phongMaterial : phongMaterialUniforms;
+@group(3) @binding(auto) var<uniform> phongMaterial : 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);
@@ -27,6 +28,10 @@ fn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, v
 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 (phongMaterial.unlit != 0u) {
+    return surfaceColor;
+  }
+
   if (lighting.enabled == 0) {
     return lightColor;
   }
@@ -51,8 +56,21 @@ fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, p
     );
   }
 
-  let totalLights = min(MAX_LIGHTS, lighting.pointLightCount + lighting.directionalLightCount);
-  for (var i: i32 = lighting.pointLightCount; i < totalLights; i++) {
+  for (var i: i32 = 0; i < lighting.spotLightCount; i++) {
+    let spotLight: SpotLight = lighting_getSpotLight(i);
+    let light_position_worldspace: vec3<f32> = spotLight.position;
+    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+    let light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+    lightColor += lighting_getLightColor(
+      surfaceColor,
+      light_direction,
+      view_direction,
+      normal_worldspace,
+      spotLight.color / light_attenuation
+    );
+  }
+
+  for (var i: i32 = 0; i < lighting.directionalLightCount; i++) {
     let directionalLight: DirectionalLight = lighting_getDirectionalLight(i);
     lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
   }  
@@ -84,8 +102,21 @@ fn lighting_getSpecularLightColor(cameraPosition: vec3<f32>, position_worldspace
       );
     }
 
-    let totalLights = min(MAX_LIGHTS, lighting.pointLightCount + lighting.directionalLightCount);
-    for (var i: i32 = lighting.pointLightCount; i < totalLights; i++) {
+    for (var i: i32 = 0; i < lighting.spotLightCount; i++) {
+      let spotLight: SpotLight = lighting_getSpotLight(i);
+      let light_position_worldspace: vec3<f32> = spotLight.position;
+      let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+      let light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+      lightColor += lighting_getLightColor(
+        surfaceColor,
+        light_direction,
+        view_direction,
+        normal_worldspace,
+        spotLight.color / light_attenuation
+      );
+    }
+
+    for (var i: i32 = 0; i < lighting.directionalLightCount; i++) {
         let directionalLight: DirectionalLight = lighting_getDirectionalLight(i);
         lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
     }

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

@@ -6,6 +6,7 @@ export const fp64arithmeticShader = /* glsl */ `\
 
 uniform fp64arithmeticUniforms {
   uniform float ONE;
+  uniform float SPLIT;
 } fp64;
 
 /*
@@ -15,6 +16,12 @@ The purpose of this workaround is to prevent shader compilers from
 optimizing away necessary arithmetic operations by swapping their sequences
 or transform the equation to some 'equivalent' form.
 
+These helpers implement Dekker/Veltkamp-style error tracking. If the compiler
+folds constants or reassociates the arithmetic, the high/low split can stop
+tracking the rounding error correctly. That failure mode tends to look fine in
+simple coordinate setup, but then breaks down inside iterative arithmetic such
+as fp64 Mandelbrot loops.
+
 The method is to multiply an artifical variable, ONE, which will be known to
 the compiler to be 1 only at runtime. The whole expression is then represented
 as a polynomial with respective to ONE. In the coefficients of all terms, only one a
@@ -23,17 +30,23 @@ and one b should appear
 err = (a + b) * ONE^6 - a * ONE^5 - (a + b) * ONE^4 + a * ONE^3 - b - (a + b) * ONE^2 + a * ONE
 */
 
-// Divide float number to high and low floats to extend fraction bits
-vec2 split(float a) {
-  const float SPLIT = 4097.0;
-  float t = a * SPLIT;
+float prevent_fp64_optimization(float value) {
 #if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float a_hi = t * fp64.ONE - (t - a);
-  float a_lo = a * fp64.ONE - a_hi;
+  return value + fp64.ONE * 0.0;
 #else
-  float a_hi = t - (t - a);
-  float a_lo = a - a_hi;
+  return value;
 #endif
+}
+
+// Divide float number to high and low floats to extend fraction bits
+vec2 split(float a) {
+  // Keep SPLIT as a runtime uniform so the compiler cannot fold the Dekker
+  // split into a constant expression and reassociate the recovery steps.
+  float split = prevent_fp64_optimization(fp64.SPLIT);
+  float t = prevent_fp64_optimization(a * split);
+  float temp = t - a;
+  float a_hi = t - temp;
+  float a_lo = a - a_hi;
   return vec2(a_hi, a_lo);
 }
 
@@ -97,8 +110,26 @@ vec2 twoProd(float a, float b) {
   float prod = a * b;
   vec2 a_fp64 = split(a);
   vec2 b_fp64 = split(b);
-  float err = ((a_fp64.x * b_fp64.x - prod) + a_fp64.x * b_fp64.y +
-    a_fp64.y * b_fp64.x) + a_fp64.y * b_fp64.y;
+  // twoProd is especially sensitive because mul_fp64 and div_fp64 both depend
+  // on the split terms and cross terms staying in the original evaluation
+  // order. If the compiler folds or reassociates them, the low part tends to
+  // collapse to zero or NaN on some drivers.
+  float highProduct = prevent_fp64_optimization(a_fp64.x * b_fp64.x);
+  float crossProduct1 = prevent_fp64_optimization(a_fp64.x * b_fp64.y);
+  float crossProduct2 = prevent_fp64_optimization(a_fp64.y * b_fp64.x);
+  float lowProduct = prevent_fp64_optimization(a_fp64.y * b_fp64.y);
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float err1 = (highProduct - prod) * fp64.ONE;
+  float err2 = crossProduct1 * fp64.ONE * fp64.ONE;
+  float err3 = crossProduct2 * fp64.ONE * fp64.ONE * fp64.ONE;
+  float err4 = lowProduct * fp64.ONE * fp64.ONE * fp64.ONE * fp64.ONE;
+#else
+  float err1 = highProduct - prod;
+  float err2 = crossProduct1;
+  float err3 = crossProduct2;
+  float err4 = lowProduct;
+#endif
+  float err = ((err1 + err2) + err3) + err4;
   return vec2(prod, err);
 }
 

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

@@ -0,0 +1,212 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+export const fp64arithmeticWGSL = /* wgsl */ `\
+struct Fp64ArithmeticUniforms {
+  ONE: f32,
+  SPLIT: f32,
+};
+
+@group(0) @binding(auto) var<uniform> fp64arithmetic : Fp64ArithmeticUniforms;
+
+fn fp64_nan(seed: f32) -> f32 {
+  let nanBits = 0x7fc00000u | select(0u, 1u, seed < 0.0);
+  return bitcast<f32>(nanBits);
+}
+
+fn fp64_runtime_zero() -> f32 {
+  return fp64arithmetic.ONE * 0.0;
+}
+
+fn prevent_fp64_optimization(value: f32) -> f32 {
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  return value + fp64_runtime_zero();
+#else
+  return value;
+#endif
+}
+
+fn split(a: f32) -> vec2f {
+  let splitValue = prevent_fp64_optimization(fp64arithmetic.SPLIT + fp64_runtime_zero());
+  let t = prevent_fp64_optimization(a * splitValue);
+  let temp = prevent_fp64_optimization(t - a);
+  let aHi = prevent_fp64_optimization(t - temp);
+  let aLo = prevent_fp64_optimization(a - aHi);
+  return vec2f(aHi, aLo);
+}
+
+fn split2(a: vec2f) -> vec2f {
+  var b = split(a.x);
+  b.y = b.y + a.y;
+  return b;
+}
+
+fn quickTwoSum(a: f32, b: f32) -> vec2f {
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  let sum = prevent_fp64_optimization((a + b) * fp64arithmetic.ONE);
+  let err = prevent_fp64_optimization(b - (sum - a) * fp64arithmetic.ONE);
+#else
+  let sum = prevent_fp64_optimization(a + b);
+  let err = prevent_fp64_optimization(b - (sum - a));
+#endif
+  return vec2f(sum, err);
+}
+
+fn twoSum(a: f32, b: f32) -> vec2f {
+  let s = prevent_fp64_optimization(a + b);
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  let v = prevent_fp64_optimization((s * fp64arithmetic.ONE - a) * fp64arithmetic.ONE);
+  let err =
+    prevent_fp64_optimization((a - (s - v) * fp64arithmetic.ONE) *
+      fp64arithmetic.ONE *
+      fp64arithmetic.ONE *
+      fp64arithmetic.ONE) +
+    prevent_fp64_optimization(b - v);
+#else
+  let v = prevent_fp64_optimization(s - a);
+  let err = prevent_fp64_optimization(a - (s - v)) + prevent_fp64_optimization(b - v);
+#endif
+  return vec2f(s, err);
+}
+
+fn twoSub(a: f32, b: f32) -> vec2f {
+  let s = prevent_fp64_optimization(a - b);
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  let v = prevent_fp64_optimization((s * fp64arithmetic.ONE - a) * fp64arithmetic.ONE);
+  let err =
+    prevent_fp64_optimization((a - (s - v) * fp64arithmetic.ONE) *
+      fp64arithmetic.ONE *
+      fp64arithmetic.ONE *
+      fp64arithmetic.ONE) -
+    prevent_fp64_optimization(b + v);
+#else
+  let v = prevent_fp64_optimization(s - a);
+  let err = prevent_fp64_optimization(a - (s - v)) - prevent_fp64_optimization(b + v);
+#endif
+  return vec2f(s, err);
+}
+
+fn twoSqr(a: f32) -> vec2f {
+  let prod = prevent_fp64_optimization(a * a);
+  let aFp64 = split(a);
+  let highProduct = prevent_fp64_optimization(aFp64.x * aFp64.x);
+  let crossProduct = prevent_fp64_optimization(2.0 * aFp64.x * aFp64.y);
+  let lowProduct = prevent_fp64_optimization(aFp64.y * aFp64.y);
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  let err =
+    (prevent_fp64_optimization(highProduct - prod) * fp64arithmetic.ONE +
+      crossProduct * fp64arithmetic.ONE * fp64arithmetic.ONE) +
+    lowProduct * fp64arithmetic.ONE * fp64arithmetic.ONE * fp64arithmetic.ONE;
+#else
+  let err = ((prevent_fp64_optimization(highProduct - prod) + crossProduct) + lowProduct);
+#endif
+  return vec2f(prod, err);
+}
+
+fn twoProd(a: f32, b: f32) -> vec2f {
+  let prod = prevent_fp64_optimization(a * b);
+  let aFp64 = split(a);
+  let bFp64 = split(b);
+  let highProduct = prevent_fp64_optimization(aFp64.x * bFp64.x);
+  let crossProduct1 = prevent_fp64_optimization(aFp64.x * bFp64.y);
+  let crossProduct2 = prevent_fp64_optimization(aFp64.y * bFp64.x);
+  let lowProduct = prevent_fp64_optimization(aFp64.y * bFp64.y);
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  let err1 = (highProduct - prod) * fp64arithmetic.ONE;
+  let err2 = crossProduct1 * fp64arithmetic.ONE * fp64arithmetic.ONE;
+  let err3 = crossProduct2 * fp64arithmetic.ONE * fp64arithmetic.ONE * fp64arithmetic.ONE;
+  let err4 =
+    lowProduct *
+    fp64arithmetic.ONE *
+    fp64arithmetic.ONE *
+    fp64arithmetic.ONE *
+    fp64arithmetic.ONE;
+#else
+  let err1 = highProduct - prod;
+  let err2 = crossProduct1;
+  let err3 = crossProduct2;
+  let err4 = lowProduct;
+#endif
+  let err12InputA = prevent_fp64_optimization(err1);
+  let err12InputB = prevent_fp64_optimization(err2);
+  let err12 = prevent_fp64_optimization(err12InputA + err12InputB);
+  let err123InputA = prevent_fp64_optimization(err12);
+  let err123InputB = prevent_fp64_optimization(err3);
+  let err123 = prevent_fp64_optimization(err123InputA + err123InputB);
+  let err1234InputA = prevent_fp64_optimization(err123);
+  let err1234InputB = prevent_fp64_optimization(err4);
+  let err = prevent_fp64_optimization(err1234InputA + err1234InputB);
+  return vec2f(prod, err);
+}
+
+fn sum_fp64(a: vec2f, b: vec2f) -> vec2f {
+  var s = twoSum(a.x, b.x);
+  let t = twoSum(a.y, b.y);
+  s.y = prevent_fp64_optimization(s.y + t.x);
+  s = quickTwoSum(s.x, s.y);
+  s.y = prevent_fp64_optimization(s.y + t.y);
+  s = quickTwoSum(s.x, s.y);
+  return s;
+}
+
+fn sub_fp64(a: vec2f, b: vec2f) -> vec2f {
+  var s = twoSub(a.x, b.x);
+  let t = twoSub(a.y, b.y);
+  s.y = prevent_fp64_optimization(s.y + t.x);
+  s = quickTwoSum(s.x, s.y);
+  s.y = prevent_fp64_optimization(s.y + t.y);
+  s = quickTwoSum(s.x, s.y);
+  return s;
+}
+
+fn mul_fp64(a: vec2f, b: vec2f) -> vec2f {
+  var prod = twoProd(a.x, b.x);
+  let crossProduct1 = prevent_fp64_optimization(a.x * b.y);
+  prod.y = prevent_fp64_optimization(prod.y + crossProduct1);
+#ifdef LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND
+  prod = split2(prod);
+#endif
+  prod = quickTwoSum(prod.x, prod.y);
+  let crossProduct2 = prevent_fp64_optimization(a.y * b.x);
+  prod.y = prevent_fp64_optimization(prod.y + crossProduct2);
+#ifdef LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND
+  prod = split2(prod);
+#endif
+  prod = quickTwoSum(prod.x, prod.y);
+  return prod;
+}
+
+fn div_fp64(a: vec2f, b: vec2f) -> vec2f {
+  let xn = prevent_fp64_optimization(1.0 / b.x);
+  let yn = mul_fp64(a, vec2f(xn, fp64_runtime_zero()));
+  let diff = prevent_fp64_optimization(sub_fp64(a, mul_fp64(b, yn)).x);
+  let prod = twoProd(xn, diff);
+  return sum_fp64(yn, prod);
+}
+
+fn sqrt_fp64(a: vec2f) -> vec2f {
+  if (a.x == 0.0 && a.y == 0.0) {
+    return vec2f(0.0, 0.0);
+  }
+  if (a.x < 0.0) {
+    let nanValue = fp64_nan(a.x);
+    return vec2f(nanValue, nanValue);
+  }
+
+  let x = prevent_fp64_optimization(1.0 / sqrt(a.x));
+  let yn = prevent_fp64_optimization(a.x * x);
+#ifdef LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+  let ynSqr = twoSqr(yn) * fp64arithmetic.ONE;
+#else
+  let ynSqr = twoSqr(yn);
+#endif
+  let diff = prevent_fp64_optimization(sub_fp64(a, ynSqr).x);
+  let prod = twoProd(prevent_fp64_optimization(x * 0.5), diff);
+#ifdef LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND
+  return sum_fp64(split(yn), prod);
+#else
+  return sum_fp64(vec2f(yn, 0.0), prod);
+#endif
+}
+`;