@luma.gl/shadertools 9.3.0-alpha.4 → 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

@@ -15,6 +15,17 @@ uniform pbrProjectionUniforms {
 } pbrProjection;
 `;
 
+const wgslUniformBlock = /* wgsl */ `\
+struct pbrProjectionUniforms {
+  modelViewProjectionMatrix: mat4x4<f32>,
+  modelMatrix: mat4x4<f32>,
+  normalMatrix: mat4x4<f32>,
+  camera: vec3<f32>
+};
+
+@group(0) @binding(auto) var<uniform> pbrProjection: pbrProjectionUniforms;
+`;
+
 export type PBRProjectionProps = {
   modelViewProjectionMatrix: NumberArray16;
   modelMatrix: NumberArray16;
@@ -24,6 +35,8 @@ export type PBRProjectionProps = {
 
 export const pbrProjection: ShaderModule<PBRProjectionProps> = {
   name: 'pbrProjection',
+  bindingLayout: [{name: 'pbrProjection', group: 0}],
+  source: wgslUniformBlock,
   vs: uniformBlock,
   fs: uniformBlock,
   // TODO why is this needed?
@@ -32,6 +45,6 @@ export const pbrProjection: ShaderModule<PBRProjectionProps> = {
     modelViewProjectionMatrix: 'mat4x4<f32>',
     modelMatrix: 'mat4x4<f32>',
     normalMatrix: 'mat4x4<f32>',
-    camera: 'vec3<i32>'
+    camera: 'vec3<f32>'
   }
 };

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;
   }
@@ -34,99 +39,88 @@ fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, p
   let view_direction: vec3<f32> = normalize(cameraPosition - position_worldspace);
   lightColor = phongMaterial.ambient * surfaceColor * lighting.ambientColor;
 
-  if (lighting.lightType == 0) {
-    let pointLight: PointLight  = lighting_getPointLight(0);
+  for (var i: i32 = 0; i < lighting.pointLightCount; i++) {
+    let pointLight: PointLight = lighting_getPointLight(i);
     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);
+    let light_attenuation = getPointLightAttenuation(
+      pointLight,
+      distance(light_position_worldspace, position_worldspace)
+    );
+    lightColor += lighting_getLightColor(
+      surfaceColor,
+      light_direction,
+      view_direction,
+      normal_worldspace,
+      pointLight.color / light_attenuation
+    );
   }
-  
-  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 (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 (int i = 0; i < MAX_LIGHTS; i++) {
-    if (i >= lighting.directionalLightCount) {
-      break;
-    }
-    DirectionalLight directionalLight = lighting.directionalLight[i];
+  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);
-  }
-  */
+  }  
+  
+  return lightColor;
 }
 
 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) {
+  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);
-      }
+    for (var i: i32 = 0; i < lighting.pointLightCount; i++) {
+      let pointLight: PointLight = lighting_getPointLight(i);
+      let light_position_worldspace: vec3<f32> = pointLight.position;
+      let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+      let light_attenuation = getPointLightAttenuation(
+        pointLight,
+        distance(light_position_worldspace, position_worldspace)
+      );
+      lightColor += lighting_getLightColor(
+        surfaceColor,
+        light_direction,
+        view_direction,
+        normal_worldspace,
+        pointLight.color / light_attenuation
+      );
     }
-  }
-  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 (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 (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);
+    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);
     }
   }
-  */
+  return lightColor;
+}
+`;

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);
 }