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

package/dist/dist.dev.js

@@ -707,6 +707,7 @@ ${DECLARATION_INJECT_MARKER}
   }
   function assembleShaderGLSL(platformInfo, options) {
     const {
+      id,
       source,
       stage,
       language = "glsl",
@@ -736,6 +737,7 @@ ${DECLARATION_INJECT_MARKER}
         assembledSource = prologue ? `${sourceVersionDirective}
 
 // ----- PROLOGUE -------------------------
+${getShaderNameDefine({ id, source, stage })}
 ${`#define SHADER_TYPE_${stage.toUpperCase()}`}
 
 ${getPlatformShaderDefines(platformInfo)}
@@ -804,7 +806,7 @@ ${getApplicationDefines(allDefines)}
     return assembledSource.trim();
   }
   function assembleGetUniforms(modules) {
-    return function getUniforms9(opts) {
+    return function getUniforms8(opts) {
       const uniforms = {};
       for (const module of modules) {
         const moduleUniforms = module.getUniforms?.(opts, uniforms);
@@ -813,6 +815,12 @@ ${getApplicationDefines(allDefines)}
       return uniforms;
     };
   }
+  function getShaderNameDefine(options) {
+    const { id, source, stage } = options;
+    const injectShaderName = id && source.indexOf("SHADER_NAME") === -1;
+    return injectShaderName ? `
+#define SHADER_NAME ${id}_${stage}` : "";
+  }
   function getApplicationDefines(defines = {}) {
     let sourceText = "";
     for (const define in defines) {
@@ -929,7 +937,7 @@ ${getApplicationDefines(allDefines)}
     assembleWGSLShader(props) {
       const modules = this._getModuleList(props.modules);
       const hookFunctions = this._hookFunctions;
-      const { source, getUniforms: getUniforms9 } = assembleWGSLShader({
+      const { source, getUniforms: getUniforms8 } = assembleWGSLShader({
         ...props,
         // @ts-expect-error
         source: props.source,
@@ -937,7 +945,7 @@ ${getApplicationDefines(allDefines)}
         hookFunctions
       });
       const preprocessedSource = props.platformInfo.shaderLanguage === "wgsl" ? preprocess(source) : source;
-      return { source: preprocessedSource, getUniforms: getUniforms9, modules };
+      return { source: preprocessedSource, getUniforms: getUniforms8, modules };
     }
     /**
      * Assemble a pair of shaders into a single shader program
@@ -6662,2160 +6670,2162 @@ float tan_fp32(float a) {
     vs: fp32shader
   };
 
-  // src/modules/engine/picking/picking.ts
-  var DEFAULT_HIGHLIGHT_COLOR = [0, 1, 1, 1];
-  var vs = (
+  // src/modules/math/fp64/fp64-arithmetic-glsl.ts
+  var fp64arithmeticShader = (
     /* glsl */
-    `uniform pickingUniforms {
-  float isActive;
-  float isAttribute;
-  float isHighlightActive;
-  float useFloatColors;
-  vec3 highlightedObjectColor;
-  vec4 highlightColor;
-} picking;
+    `
+uniform fp64arithmeticUniforms {
+  uniform float ONE;
+} fp64;
 
-out vec4 picking_vRGBcolor_Avalid;
+/*
+About LUMA_FP64_CODE_ELIMINATION_WORKAROUND
 
-// Normalize unsigned byte color to 0-1 range
-vec3 picking_normalizeColor(vec3 color) {
-  return picking.useFloatColors > 0.5 ? color : color / 255.0;
+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.
+
+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
+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;
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float a_hi = t * fp64.ONE - (t - a);
+  float a_lo = a * fp64.ONE - a_hi;
+#else
+  float a_hi = t - (t - a);
+  float a_lo = a - a_hi;
+#endif
+  return vec2(a_hi, a_lo);
 }
 
-// Normalize unsigned byte color to 0-1 range
-vec4 picking_normalizeColor(vec4 color) {
-  return picking.useFloatColors > 0.5 ? color : color / 255.0;
+// Divide float number again when high float uses too many fraction bits
+vec2 split2(vec2 a) {
+  vec2 b = split(a.x);
+  b.y += a.y;
+  return b;
 }
 
-bool picking_isColorZero(vec3 color) {
-  return dot(color, vec3(1.0)) < 0.00001;
+// Special sum operation when a > b
+vec2 quickTwoSum(float a, float b) {
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float sum = (a + b) * fp64.ONE;
+  float err = b - (sum - a) * fp64.ONE;
+#else
+  float sum = a + b;
+  float err = b - (sum - a);
+#endif
+  return vec2(sum, err);
 }
 
-bool picking_isColorValid(vec3 color) {
-  return dot(color, vec3(1.0)) > 0.00001;
+// General sum operation
+vec2 twoSum(float a, float b) {
+  float s = (a + b);
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float v = (s * fp64.ONE - a) * fp64.ONE;
+  float err = (a - (s - v) * fp64.ONE) * fp64.ONE * fp64.ONE * fp64.ONE + (b - v);
+#else
+  float v = s - a;
+  float err = (a - (s - v)) + (b - v);
+#endif
+  return vec2(s, err);
 }
 
-// Check if this vertex is highlighted 
-bool isVertexHighlighted(vec3 vertexColor) {
-  vec3 highlightedObjectColor = picking_normalizeColor(picking.highlightedObjectColor);
-  return
-    bool(picking.isHighlightActive) && picking_isColorZero(abs(vertexColor - highlightedObjectColor));
+vec2 twoSub(float a, float b) {
+  float s = (a - b);
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float v = (s * fp64.ONE - a) * fp64.ONE;
+  float err = (a - (s - v) * fp64.ONE) * fp64.ONE * fp64.ONE * fp64.ONE - (b + v);
+#else
+  float v = s - a;
+  float err = (a - (s - v)) - (b + v);
+#endif
+  return vec2(s, err);
 }
 
-// Set the current picking color
-void picking_setPickingColor(vec3 pickingColor) {
-  pickingColor = picking_normalizeColor(pickingColor);
+vec2 twoSqr(float a) {
+  float prod = a * a;
+  vec2 a_fp64 = split(a);
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  float err = ((a_fp64.x * a_fp64.x - prod) * fp64.ONE + 2.0 * a_fp64.x *
+    a_fp64.y * fp64.ONE * fp64.ONE) + a_fp64.y * a_fp64.y * fp64.ONE * fp64.ONE * fp64.ONE;
+#else
+  float err = ((a_fp64.x * a_fp64.x - prod) + 2.0 * a_fp64.x * a_fp64.y) + a_fp64.y * a_fp64.y;
+#endif
+  return vec2(prod, err);
+}
 
-  if (bool(picking.isActive)) {
-    // Use alpha as the validity flag. If pickingColor is [0, 0, 0] fragment is non-pickable
-    picking_vRGBcolor_Avalid.a = float(picking_isColorValid(pickingColor));
+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;
+  return vec2(prod, err);
+}
 
-    if (!bool(picking.isAttribute)) {
-      // Stores the picking color so that the fragment shader can render it during picking
-      picking_vRGBcolor_Avalid.rgb = pickingColor;
-    }
-  } else {
-    // Do the comparison with selected item color in vertex shader as it should mean fewer compares
-    picking_vRGBcolor_Avalid.a = float(isVertexHighlighted(pickingColor));
-  }
+vec2 sum_fp64(vec2 a, vec2 b) {
+  vec2 s, t;
+  s = twoSum(a.x, b.x);
+  t = twoSum(a.y, b.y);
+  s.y += t.x;
+  s = quickTwoSum(s.x, s.y);
+  s.y += t.y;
+  s = quickTwoSum(s.x, s.y);
+  return s;
 }
 
-void picking_setPickingAttribute(float value) {
-  if (bool(picking.isAttribute)) {
-    picking_vRGBcolor_Avalid.r = value;
-  }
+vec2 sub_fp64(vec2 a, vec2 b) {
+  vec2 s, t;
+  s = twoSub(a.x, b.x);
+  t = twoSub(a.y, b.y);
+  s.y += t.x;
+  s = quickTwoSum(s.x, s.y);
+  s.y += t.y;
+  s = quickTwoSum(s.x, s.y);
+  return s;
 }
 
-void picking_setPickingAttribute(vec2 value) {
-  if (bool(picking.isAttribute)) {
-    picking_vRGBcolor_Avalid.rg = value;
-  }
+vec2 mul_fp64(vec2 a, vec2 b) {
+  vec2 prod = twoProd(a.x, b.x);
+  // y component is for the error
+  prod.y += a.x * b.y;
+#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
+  prod = split2(prod);
+#endif
+  prod = quickTwoSum(prod.x, prod.y);
+  prod.y += a.y * b.x;
+#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
+  prod = split2(prod);
+#endif
+  prod = quickTwoSum(prod.x, prod.y);
+  return prod;
 }
 
-void picking_setPickingAttribute(vec3 value) {
-  if (bool(picking.isAttribute)) {
-    picking_vRGBcolor_Avalid.rgb = value;
-  }
+vec2 div_fp64(vec2 a, vec2 b) {
+  float xn = 1.0 / b.x;
+#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
+  vec2 yn = mul_fp64(a, vec2(xn, 0));
+#else
+  vec2 yn = a * xn;
+#endif
+  float diff = (sub_fp64(a, mul_fp64(b, yn))).x;
+  vec2 prod = twoProd(xn, diff);
+  return sum_fp64(yn, prod);
+}
+
+vec2 sqrt_fp64(vec2 a) {
+  if (a.x == 0.0 && a.y == 0.0) return vec2(0.0, 0.0);
+  if (a.x < 0.0) return vec2(0.0 / 0.0, 0.0 / 0.0);
+
+  float x = 1.0 / sqrt(a.x);
+  float yn = a.x * x;
+#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
+  vec2 yn_sqr = twoSqr(yn) * fp64.ONE;
+#else
+  vec2 yn_sqr = twoSqr(yn);
+#endif
+  float diff = sub_fp64(a, yn_sqr).x;
+  vec2 prod = twoProd(x * 0.5, diff);
+#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
+  return sum_fp64(split(yn), prod);
+#else
+  return sum_fp64(vec2(yn, 0.0), prod);
+#endif
 }
 `
   );
-  var fs2 = (
-    /* glsl */
-    `uniform pickingUniforms {
-  float isActive;
-  float isAttribute;
-  float isHighlightActive;
-  float useFloatColors;
-  vec3 highlightedObjectColor;
-  vec4 highlightColor;
-} picking;
 
-in vec4 picking_vRGBcolor_Avalid;
+  // src/modules/math/fp64/fp64-functions-glsl.ts
+  var fp64functionShader = (
+    /* glsl */
+    `const vec2 E_FP64 = vec2(2.7182817459106445e+00, 8.254840366817007e-08);
+const vec2 LOG2_FP64 = vec2(0.6931471824645996e+00, -1.9046542121259336e-09);
+const vec2 PI_FP64 = vec2(3.1415927410125732, -8.742278012618954e-8);
+const vec2 TWO_PI_FP64 = vec2(6.2831854820251465, -1.7484556025237907e-7);
+const vec2 PI_2_FP64 = vec2(1.5707963705062866, -4.371139006309477e-8);
+const vec2 PI_4_FP64 = vec2(0.7853981852531433, -2.1855695031547384e-8);
+const vec2 PI_16_FP64 = vec2(0.19634954631328583, -5.463923757886846e-9);
+const vec2 PI_16_2_FP64 = vec2(0.39269909262657166, -1.0927847515773692e-8);
+const vec2 PI_16_3_FP64 = vec2(0.5890486240386963, -1.4906100798128818e-9);
+const vec2 PI_180_FP64 = vec2(0.01745329238474369, 1.3519960498364902e-10);
 
-/*
- * Returns highlight color if this item is selected.
- */
-vec4 picking_filterHighlightColor(vec4 color) {
-  // If we are still picking, we don't highlight
-  if (picking.isActive > 0.5) {
-    return color;
-  }
+const vec2 SIN_TABLE_0_FP64 = vec2(0.19509032368659973, -1.6704714833615242e-9);
+const vec2 SIN_TABLE_1_FP64 = vec2(0.3826834261417389, 6.22335089017767e-9);
+const vec2 SIN_TABLE_2_FP64 = vec2(0.5555702447891235, -1.1769521357507529e-8);
+const vec2 SIN_TABLE_3_FP64 = vec2(0.7071067690849304, 1.2101617041793133e-8);
 
-  bool selected = bool(picking_vRGBcolor_Avalid.a);
+const vec2 COS_TABLE_0_FP64 = vec2(0.9807852506637573, 2.9739473106360492e-8);
+const vec2 COS_TABLE_1_FP64 = vec2(0.9238795042037964, 2.8307490351764386e-8);
+const vec2 COS_TABLE_2_FP64 = vec2(0.8314695954322815, 1.6870263741530778e-8);
+const vec2 COS_TABLE_3_FP64 = vec2(0.7071067690849304, 1.2101617152815436e-8);
 
-  if (selected) {
-    // Blend in highlight color based on its alpha value
-    float highLightAlpha = picking.highlightColor.a;
-    float blendedAlpha = highLightAlpha + color.a * (1.0 - highLightAlpha);
-    float highLightRatio = highLightAlpha / blendedAlpha;
+const vec2 INVERSE_FACTORIAL_3_FP64 = vec2(1.666666716337204e-01, -4.967053879312289e-09); // 1/3!
+const vec2 INVERSE_FACTORIAL_4_FP64 = vec2(4.16666679084301e-02, -1.2417634698280722e-09); // 1/4!
+const vec2 INVERSE_FACTORIAL_5_FP64 = vec2(8.333333767950535e-03, -4.34617203337595e-10); // 1/5!
+const vec2 INVERSE_FACTORIAL_6_FP64 = vec2(1.3888889225199819e-03, -3.3631094437103215e-11); // 1/6!
+const vec2 INVERSE_FACTORIAL_7_FP64 = vec2(1.9841270113829523e-04,  -2.725596874933456e-12); // 1/7!
+const vec2 INVERSE_FACTORIAL_8_FP64 = vec2(2.4801587642286904e-05, -3.406996025904184e-13); // 1/8!
+const vec2 INVERSE_FACTORIAL_9_FP64 = vec2(2.75573188446287533e-06, 3.7935713937038186e-14); // 1/9!
+const vec2 INVERSE_FACTORIAL_10_FP64 = vec2(2.755731998149713e-07, -7.575112367869873e-15); // 1/10!
 
-    vec3 blendedRGB = mix(color.rgb, picking.highlightColor.rgb, highLightRatio);
-    return vec4(blendedRGB, blendedAlpha);
-  } else {
-    return color;
-  }
+float nint(float d) {
+    if (d == floor(d)) return d;
+    return floor(d + 0.5);
 }
 
-/*
- * Returns picking color if picking enabled else unmodified argument.
- */
-vec4 picking_filterPickingColor(vec4 color) {
-  if (bool(picking.isActive)) {
-    if (picking_vRGBcolor_Avalid.a == 0.0) {
-      discard;
+vec2 nint_fp64(vec2 a) {
+    float hi = nint(a.x);
+    float lo;
+    vec2 tmp;
+    if (hi == a.x) {
+        lo = nint(a.y);
+        tmp = quickTwoSum(hi, lo);
+    } else {
+        lo = 0.0;
+        if (abs(hi - a.x) == 0.5 && a.y < 0.0) {
+            hi -= 1.0;
+        }
+        tmp = vec2(hi, lo);
     }
-    return picking_vRGBcolor_Avalid;
-  }
-  return color;
+    return tmp;
 }
 
-/*
- * Returns picking color if picking is enabled if not
- * highlight color if this item is selected, otherwise unmodified argument.
- */
-vec4 picking_filterColor(vec4 color) {
-  vec4 highlightColor = picking_filterHighlightColor(color);
-  return picking_filterPickingColor(highlightColor);
-}
-`
-  );
-  var picking = {
-    props: {},
-    uniforms: {},
-    name: "picking",
-    uniformTypes: {
-      isActive: "f32",
-      isAttribute: "f32",
-      isHighlightActive: "f32",
-      useFloatColors: "f32",
-      highlightedObjectColor: "vec3<f32>",
-      highlightColor: "vec4<f32>"
-    },
-    defaultUniforms: {
-      isActive: false,
-      isAttribute: false,
-      isHighlightActive: false,
-      useFloatColors: true,
-      highlightedObjectColor: [0, 0, 0],
-      highlightColor: DEFAULT_HIGHLIGHT_COLOR
-    },
-    vs,
-    fs: fs2,
-    getUniforms
-  };
-  function getUniforms(opts = {}, prevUniforms) {
-    const uniforms = {};
-    if (opts.highlightedObjectColor === void 0) {
-    } else if (opts.highlightedObjectColor === null) {
-      uniforms.isHighlightActive = false;
-    } else {
-      uniforms.isHighlightActive = true;
-      const highlightedObjectColor = opts.highlightedObjectColor.slice(0, 3);
-      uniforms.highlightedObjectColor = highlightedObjectColor;
-    }
-    if (opts.highlightColor) {
-      const color = Array.from(opts.highlightColor, (x) => x / 255);
-      if (!Number.isFinite(color[3])) {
-        color[3] = 1;
-      }
-      uniforms.highlightColor = color;
-    }
-    if (opts.isActive !== void 0) {
-      uniforms.isActive = Boolean(opts.isActive);
-      uniforms.isAttribute = Boolean(opts.isAttribute);
-    }
-    if (opts.useFloatColors !== void 0) {
-      uniforms.useFloatColors = Boolean(opts.useFloatColors);
-    }
-    return uniforms;
-  }
+/* k_power controls how much range reduction we would like to have
+Range reduction uses the following method:
+assume a = k_power * r + m * log(2), k and m being integers.
+Set k_power = 4 (we can choose other k to trade accuracy with performance.
+we only need to calculate exp(r) and using exp(a) = 2^m * exp(r)^k_power;
+*/
 
-  // src/modules/lighting/lights/lighting.ts
-  var import_core3 = __toESM(require_core(), 1);
+vec2 exp_fp64(vec2 a) {
+  // We need to make sure these two numbers match
+  // as bit-wise shift is not available in GLSL 1.0
+  const int k_power = 4;
+  const float k = 16.0;
 
-  // src/modules/lighting/lights/lighting-uniforms-glsl.ts
-  var lightingUniformsGLSL = (
-    /* glsl */
-    `precision highp int;
+  const float inv_k = 1.0 / k;
 
-// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
-struct AmbientLight {
-  vec3 color;
-};
+  if (a.x <= -88.0) return vec2(0.0, 0.0);
+  if (a.x >= 88.0) return vec2(1.0 / 0.0, 1.0 / 0.0);
+  if (a.x == 0.0 && a.y == 0.0) return vec2(1.0, 0.0);
+  if (a.x == 1.0 && a.y == 0.0) return E_FP64;
 
-struct PointLight {
-  vec3 color;
-  vec3 position;
-  vec3 attenuation; // 2nd order x:Constant-y:Linear-z:Exponential
-};
+  float m = floor(a.x / LOG2_FP64.x + 0.5);
+  vec2 r = sub_fp64(a, mul_fp64(LOG2_FP64, vec2(m, 0.0))) * inv_k;
+  vec2 s, t, p;
 
-struct DirectionalLight {
-  vec3 color;
-  vec3 direction;
-};
+  p = mul_fp64(r, r);
+  s = sum_fp64(r, p * 0.5);
+  p = mul_fp64(p, r);
+  t = mul_fp64(p, INVERSE_FACTORIAL_3_FP64);
 
-uniform lightingUniforms {
-  int enabled;
-  int lightType;
+  s = sum_fp64(s, t);
+  p = mul_fp64(p, r);
+  t = mul_fp64(p, INVERSE_FACTORIAL_4_FP64);
 
-  int directionalLightCount;
-  int pointLightCount;
+  s = sum_fp64(s, t);
+  p = mul_fp64(p, r);
+  t = mul_fp64(p, INVERSE_FACTORIAL_5_FP64);
 
-  vec3 ambientColor;
+  // s = sum_fp64(s, t);
+  // p = mul_fp64(p, r);
+  // t = mul_fp64(p, INVERSE_FACTORIAL_6_FP64);
 
-  vec3 lightColor0;
-  vec3 lightPosition0;
-  vec3 lightDirection0;
-  vec3 lightAttenuation0;
+  // s = sum_fp64(s, t);
+  // p = mul_fp64(p, r);
+  // t = mul_fp64(p, INVERSE_FACTORIAL_7_FP64);
 
-  vec3 lightColor1;
-  vec3 lightPosition1;
-  vec3 lightDirection1;
-  vec3 lightAttenuation1;
+  s = sum_fp64(s, t);
 
-  vec3 lightColor2;
-  vec3 lightPosition2;
-  vec3 lightDirection2;
-  vec3 lightAttenuation2;
-} lighting;
 
-PointLight lighting_getPointLight(int index) {
-  switch (index) {
-    case 0:
-      return PointLight(lighting.lightColor0, lighting.lightPosition0, lighting.lightAttenuation0);
-    case 1:
-      return PointLight(lighting.lightColor1, lighting.lightPosition1, lighting.lightAttenuation1);
-    case 2:
-    default:  
-      return PointLight(lighting.lightColor2, lighting.lightPosition2, lighting.lightAttenuation2);
+  // At this point, s = exp(r) - 1; but after following 4 recursions, we will get exp(r) ^ 512 - 1.
+  for (int i = 0; i < k_power; i++) {
+    s = sum_fp64(s * 2.0, mul_fp64(s, s));
   }
-}
 
-DirectionalLight lighting_getDirectionalLight(int index) {
-  switch (index) {
-    case 0:
-      return DirectionalLight(lighting.lightColor0, lighting.lightDirection0);
-    case 1:
-      return DirectionalLight(lighting.lightColor1, lighting.lightDirection1);
-    case 2:
-    default:   
-      return DirectionalLight(lighting.lightColor2, lighting.lightDirection2);
-  }
-} 
+#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)
+  s = sum_fp64(s, vec2(fp64.ONE, 0.0));
+#else
+  s = sum_fp64(s, vec2(1.0, 0.0));
+#endif
 
-float getPointLightAttenuation(PointLight pointLight, float distance) {
-  return pointLight.attenuation.x
-       + pointLight.attenuation.y * distance
-       + pointLight.attenuation.z * distance * distance;
+  return s * pow(2.0, m);
+//   return r;
 }
 
-// #endif
-`
-  );
+vec2 log_fp64(vec2 a)
+{
+  if (a.x == 1.0 && a.y == 0.0) return vec2(0.0, 0.0);
+  if (a.x <= 0.0) return vec2(0.0 / 0.0, 0.0 / 0.0);
+  vec2 x = vec2(log(a.x), 0.0);
+  vec2 s;
+#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)
+  s = vec2(fp64.ONE, 0.0);
+#else
+  s = vec2(1.0, 0.0);
+#endif
 
-  // src/modules/lighting/lights/lighting-uniforms-wgsl.ts
-  var lightingUniformsWGSL = (
-    /* wgsl */
-    `// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
-struct AmbientLight {
-  color: vec3<f32>,
-};
+  x = sub_fp64(sum_fp64(x, mul_fp64(a, exp_fp64(-x))), s);
+  return x;
+}
 
-struct PointLight {
-  color: vec3<f32>,
-  position: vec3<f32>,
-  attenuation: vec3<f32>, // 2nd order x:Constant-y:Linear-z:Exponential
-};
+vec2 sin_taylor_fp64(vec2 a) {
+  vec2 r, s, t, x;
 
-struct DirectionalLight {
-  color: vec3<f32>,
-  direction: vec3<f32>,
-};
+  if (a.x == 0.0 && a.y == 0.0) {
+    return vec2(0.0, 0.0);
+  }
 
-struct lightingUniforms {
-  enabled: i32,
-  poightCount: i32,
-  directionalLightCount: i32,
+  x = -mul_fp64(a, a);
+  s = a;
+  r = a;
 
-  ambientColor: vec3<f32>,
+  r = mul_fp64(r, x);
+  t = mul_fp64(r, INVERSE_FACTORIAL_3_FP64);
+  s = sum_fp64(s, t);
 
-  // TODO - support multiple lights by uncommenting arrays below
-  lightType: i32,
-  lightColor: vec3<f32>,
-  lightDirection: vec3<f32>,
-  lightPosition: vec3<f32>,
-  lightAttenuation: vec3<f32>,
+  r = mul_fp64(r, x);
+  t = mul_fp64(r, INVERSE_FACTORIAL_5_FP64);
+  s = sum_fp64(s, t);
 
-  // AmbientLight ambientLight;
-  // PointLight pointLight[MAX_LIGHTS];
-  // DirectionalLight directionalLight[MAX_LIGHTS];
-};
+  /* keep the following commented code in case we need them
+  for extra accuracy from the Taylor expansion*/
 
-// Binding 0:1 is reserved for lighting (Note: could go into separate bind group as it is stable across draw calls)
-@binding(1) @group(0) var<uniform> lighting : lightingUniforms;
+  // r = mul_fp64(r, x);
+  // t = mul_fp64(r, INVERSE_FACTORIAL_7_FP64);
+  // s = sum_fp64(s, t);
 
-fn lighting_getPointLight(index: i32) -> PointLight {
-  return PointLight(lighting.lightColor, lighting.lightPosition, lighting.lightAttenuation);
-}
-
-fn lighting_getDirectionalLight(index: i32) -> DirectionalLight {
-  return DirectionalLight(lighting.lightColor, lighting.lightDirection);
-} 
+  // r = mul_fp64(r, x);
+  // t = mul_fp64(r, INVERSE_FACTORIAL_9_FP64);
+  // s = sum_fp64(s, t);
 
-fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
-  return pointLight.attenuation.x
-       + pointLight.attenuation.y * distance
-       + pointLight.attenuation.z * distance * distance;
+  return s;
 }
-`
-  );
 
-  // src/modules/lighting/lights/lighting.ts
-  var MAX_LIGHTS = 3;
-  var COLOR_FACTOR = 255;
-  var lighting = {
-    props: {},
-    uniforms: {},
-    name: "lighting",
-    defines: {
-      MAX_LIGHTS
-    },
-    uniformTypes: {
-      enabled: "i32",
-      lightType: "i32",
-      directionalLightCount: "i32",
-      pointLightCount: "i32",
-      ambientLightColor: "vec3<f32>",
-      // TODO define as arrays once we have appropriate uniformTypes
-      lightColor0: "vec3<f32>",
-      lightPosition0: "vec3<f32>",
-      // TODO - could combine direction and attenuation
-      lightDirection0: "vec3<f32>",
-      lightAttenuation0: "vec3<f32>",
-      lightColor1: "vec3<f32>",
-      lightPosition1: "vec3<f32>",
-      lightDirection1: "vec3<f32>",
-      lightAttenuation1: "vec3<f32>",
-      lightColor2: "vec3<f32>",
-      lightPosition2: "vec3<f32>",
-      lightDirection2: "vec3<f32>",
-      lightAttenuation2: "vec3<f32>"
-    },
-    defaultUniforms: {
-      enabled: 1,
-      lightType: 0 /* POINT */,
-      directionalLightCount: 0,
-      pointLightCount: 0,
-      ambientLightColor: [0.1, 0.1, 0.1],
-      lightColor0: [1, 1, 1],
-      lightPosition0: [1, 1, 2],
-      // TODO - could combine direction and attenuation
-      lightDirection0: [1, 1, 1],
-      lightAttenuation0: [1, 0, 0],
-      lightColor1: [1, 1, 1],
-      lightPosition1: [1, 1, 2],
-      lightDirection1: [1, 1, 1],
-      lightAttenuation1: [1, 0, 0],
-      lightColor2: [1, 1, 1],
-      lightPosition2: [1, 1, 2],
-      lightDirection2: [1, 1, 1],
-      lightAttenuation2: [1, 0, 0]
-    },
-    source: lightingUniformsWGSL,
-    vs: lightingUniformsGLSL,
-    fs: lightingUniformsGLSL,
-    getUniforms: getUniforms2
-  };
-  function getUniforms2(props, prevUniforms = {}) {
-    props = props ? { ...props } : props;
-    if (!props) {
-      return { ...lighting.defaultUniforms };
-    }
-    if (props.lights) {
-      props = { ...props, ...extractLightTypes(props.lights), lights: void 0 };
-    }
-    const { ambientLight, pointLights, directionalLights } = props || {};
-    const hasLights = ambientLight || pointLights && pointLights.length > 0 || directionalLights && directionalLights.length > 0;
-    if (!hasLights) {
-      return { ...lighting.defaultUniforms, enabled: 0 };
-    }
-    const uniforms = {
-      ...lighting.defaultUniforms,
-      ...prevUniforms,
-      ...getLightSourceUniforms({ ambientLight, pointLights, directionalLights })
-    };
-    if (props.enabled !== void 0) {
-      uniforms.enabled = props.enabled ? 1 : 0;
-    }
-    return uniforms;
-  }
-  function getLightSourceUniforms({
-    ambientLight,
-    pointLights = [],
-    directionalLights = []
-  }) {
-    const lightSourceUniforms = {};
-    lightSourceUniforms.ambientLightColor = convertColor(ambientLight);
-    let currentLight = 0;
-    for (const pointLight of pointLights) {
-      lightSourceUniforms.lightType = 0 /* POINT */;
-      const i = currentLight;
-      lightSourceUniforms[`lightColor${i}`] = convertColor(pointLight);
-      lightSourceUniforms[`lightPosition${i}`] = pointLight.position;
-      lightSourceUniforms[`lightAttenuation${i}`] = pointLight.attenuation || [1, 0, 0];
-      currentLight++;
-    }
-    for (const directionalLight of directionalLights) {
-      lightSourceUniforms.lightType = 1 /* DIRECTIONAL */;
-      const i = currentLight;
-      lightSourceUniforms[`lightColor${i}`] = convertColor(directionalLight);
-      lightSourceUniforms[`lightDirection${i}`] = directionalLight.direction;
-      currentLight++;
-    }
-    if (currentLight > MAX_LIGHTS) {
-      import_core3.log.warn("MAX_LIGHTS exceeded")();
-    }
-    lightSourceUniforms.directionalLightCount = directionalLights.length;
-    lightSourceUniforms.pointLightCount = pointLights.length;
-    return lightSourceUniforms;
-  }
-  function extractLightTypes(lights2) {
-    const lightSources = { pointLights: [], directionalLights: [] };
-    for (const light of lights2 || []) {
-      switch (light.type) {
-        case "ambient":
-          lightSources.ambientLight = light;
-          break;
-        case "directional":
-          lightSources.directionalLights?.push(light);
-          break;
-        case "point":
-          lightSources.pointLights?.push(light);
-          break;
-        default:
-      }
-    }
-    return lightSources;
-  }
-  function convertColor(colorDef = {}) {
-    const { color = [0, 0, 0], intensity = 1 } = colorDef;
-    return color.map((component) => component * intensity / COLOR_FACTOR);
+vec2 cos_taylor_fp64(vec2 a) {
+  vec2 r, s, t, x;
+
+  if (a.x == 0.0 && a.y == 0.0) {
+    return vec2(1.0, 0.0);
   }
 
-  // src/modules/lighting/no-material/dirlight.ts
-  var SOURCE_WGSL = (
-    /* WGSL */
-    `  
-struct dirlightUniforms {
-  lightDirection: vec3<f32>,
-};
+  x = -mul_fp64(a, a);
+  r = x;
+  s = sum_fp64(vec2(1.0, 0.0), r * 0.5);
 
-alias DirlightNormal = vec3<f32>;
+  r = mul_fp64(r, x);
+  t = mul_fp64(r, INVERSE_FACTORIAL_4_FP64);
+  s = sum_fp64(s, t);
 
-struct DirlightInputs {
-  normal: DirlightNormal,
-};
+  r = mul_fp64(r, x);
+  t = mul_fp64(r, INVERSE_FACTORIAL_6_FP64);
+  s = sum_fp64(s, t);
 
-@binding(1) @group(0) var<uniform> dirlight : dirlightUniforms;
+  /* keep the following commented code in case we need them
+  for extra accuracy from the Taylor expansion*/
 
-// For vertex
-fn dirlight_setNormal(normal: vec3<f32>) -> DirlightNormal {
-  return normalize(normal);
-}
+  // r = mul_fp64(r, x);
+  // t = mul_fp64(r, INVERSE_FACTORIAL_8_FP64);
+  // s = sum_fp64(s, t);
 
-// Returns color attenuated by angle from light source
-fn dirlight_filterColor(color: vec4<f32>, inputs: DirlightInputs) -> vec4<f32> {
-  // TODO - fix default light direction
-  // let lightDirection = dirlight.lightDirection;
-  let lightDirection = vec3<f32>(1, 1, 1);
-  let d: f32 = abs(dot(inputs.normal, normalize(lightDirection)));
-  return vec4<f32>(color.rgb * d, color.a);
-}
-`
-  );
-  var VS_GLSL = (
-    /* glsl */
-    `out vec3 dirlight_vNormal;
+  // r = mul_fp64(r, x);
+  // t = mul_fp64(r, INVERSE_FACTORIAL_10_FP64);
+  // s = sum_fp64(s, t);
 
-void dirlight_setNormal(vec3 normal) {
-  dirlight_vNormal = normalize(normal);
+  return s;
 }
-`
-  );
-  var FS_GLSL = (
-    /* glsl */
-    `uniform dirlightUniforms {
-  vec3 lightDirection;
-} dirlight;
 
-in vec3 dirlight_vNormal;
+void sincos_taylor_fp64(vec2 a, out vec2 sin_t, out vec2 cos_t) {
+  if (a.x == 0.0 && a.y == 0.0) {
+    sin_t = vec2(0.0, 0.0);
+    cos_t = vec2(1.0, 0.0);
+  }
 
-// Returns color attenuated by angle from light source
-vec4 dirlight_filterColor(vec4 color) {
-  float d = abs(dot(dirlight_vNormal, normalize(dirlight.lightDirection)));
-  return vec4(color.rgb * d, color.a);
+  sin_t = sin_taylor_fp64(a);
+  cos_t = sqrt_fp64(sub_fp64(vec2(1.0, 0.0), mul_fp64(sin_t, sin_t)));
 }
-`
-  );
-  var dirlight = {
-    props: {},
-    uniforms: {},
-    name: "dirlight",
-    dependencies: [],
-    source: SOURCE_WGSL,
-    vs: VS_GLSL,
-    fs: FS_GLSL,
-    // fragmentInputs: [
-    //   {
-    //     name: 'dirlight_vNormal',
-    //     type: 'vec3<f32>'
-    //   }
-    // ],
-    uniformTypes: {
-      lightDirection: "vec3<f32>"
-    },
-    defaultUniforms: {
-      lightDirection: [1, 1, 2]
-    },
-    getUniforms: getUniforms3
-  };
-  function getUniforms3(opts = dirlight.defaultUniforms) {
-    const uniforms = {};
-    if (opts.lightDirection) {
-      uniforms.dirlight_uLightDirection = opts.lightDirection;
+
+vec2 sin_fp64(vec2 a) {
+    if (a.x == 0.0 && a.y == 0.0) {
+        return vec2(0.0, 0.0);
     }
-    return uniforms;
-  }
 
-  // src/modules/lighting/phong-material/phong-shaders-glsl.ts
-  var PHONG_VS = (
-    /* glsl */
-    `uniform phongMaterialUniforms {
-  uniform float ambient;
-  uniform float diffuse;
-  uniform float shininess;
-  uniform vec3  specularColor;
-} material;
-`
-  );
-  var PHONG_FS = (
-    /* glsl */
-    `uniform phongMaterialUniforms {
-  uniform float ambient;
-  uniform float diffuse;
-  uniform float shininess;
-  uniform vec3  specularColor;
-} material;
+    // 2pi range reduction
+    vec2 z = nint_fp64(div_fp64(a, TWO_PI_FP64));
+    vec2 r = sub_fp64(a, mul_fp64(TWO_PI_FP64, z));
 
-vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {
-  vec3 halfway_direction = normalize(light_direction + view_direction);
-  float lambertian = dot(light_direction, normal_worldspace);
-  float specular = 0.0;
-  if (lambertian > 0.0) {
-    float specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);
-    specular = pow(specular_angle, material.shininess);
-  }
-  lambertian = max(lambertian, 0.0);
-  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;
-}
+    vec2 t;
+    float q = floor(r.x / PI_2_FP64.x + 0.5);
+    int j = int(q);
 
-vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
-  vec3 lightColor = surfaceColor;
+    if (j < -2 || j > 2) {
+        return vec2(0.0 / 0.0, 0.0 / 0.0);
+    }
 
-  if (lighting.enabled == 0) {
-    return lightColor;
-  }
+    t = sub_fp64(r, mul_fp64(PI_2_FP64, vec2(q, 0.0)));
 
-  vec3 view_direction = normalize(cameraPosition - position_worldspace);
-  lightColor = material.ambient * surfaceColor * lighting.ambientColor;
+    q = floor(t.x / PI_16_FP64.x + 0.5);
+    int k = int(q);
 
-  for (int i = 0; i < lighting.pointLightCount; i++) {
-    PointLight pointLight = lighting_getPointLight(i);
-    vec3 light_position_worldspace = pointLight.position;
-    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-    float light_attenuation = getPointLightAttenuation(pointLight, distance(light_position_worldspace, position_worldspace));
-    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color / light_attenuation);
-  }
+    if (k == 0) {
+        if (j == 0) {
+            return sin_taylor_fp64(t);
+        } else if (j == 1) {
+            return cos_taylor_fp64(t);
+        } else if (j == -1) {
+            return -cos_taylor_fp64(t);
+        } else {
+            return -sin_taylor_fp64(t);
+        }
+    }
 
-  int totalLights = min(MAX_LIGHTS, lighting.pointLightCount + lighting.directionalLightCount);
-  for (int i = lighting.pointLightCount; i < totalLights; i++) {
-    DirectionalLight directionalLight = lighting_getDirectionalLight(i);
-    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-  }
-  
-  return lightColor;
-}
-`
-  );
+    int abs_k = int(abs(float(k)));
 
-  // src/modules/lighting/gouraud-material/gouraud-material.ts
-  var gouraudMaterial = {
-    props: {},
-    name: "gouraudMaterial",
-    // Note these are switched between phong and gouraud
-    vs: PHONG_FS.replace("phongMaterial", "gouraudMaterial"),
-    fs: PHONG_VS.replace("phongMaterial", "gouraudMaterial"),
-    defines: {
-      LIGHTING_VERTEX: 1
-    },
-    dependencies: [lighting],
-    uniformTypes: {
-      ambient: "f32",
-      diffuse: "f32",
-      shininess: "f32",
-      specularColor: "vec3<f32>"
-    },
-    defaultUniforms: {
-      ambient: 0.35,
-      diffuse: 0.6,
-      shininess: 32,
-      specularColor: [0.15, 0.15, 0.15]
-    },
-    getUniforms(props) {
-      const uniforms = { ...props };
-      if (uniforms.specularColor) {
-        uniforms.specularColor = uniforms.specularColor.map((x) => x / 255);
-      }
-      return { ...gouraudMaterial.defaultUniforms, ...uniforms };
+    if (abs_k > 4) {
+        return vec2(0.0 / 0.0, 0.0 / 0.0);
+    } else {
+        t = sub_fp64(t, mul_fp64(PI_16_FP64, vec2(q, 0.0)));
     }
-  };
-
-  // src/modules/lighting/phong-material/phong-shaders-wgsl.ts
-  var PHONG_WGSL = (
-    /* wgsl */
-    `struct phongMaterialUniforms {
-  ambient: f32,
-  diffuse: f32,
-  shininess: f32,
-  specularColor: vec3<f32>,
-};
 
-@binding(2) @group(0) var<uniform> material : phongMaterialUniforms;
+    vec2 u = vec2(0.0, 0.0);
+    vec2 v = vec2(0.0, 0.0);
 
-fn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, view_direction: vec3<f32>, normal_worldspace: vec3<f32>, color: vec3<f32>) -> vec3<f32> {
-  let halfway_direction: vec3<f32> = normalize(light_direction + view_direction);
-  var lambertian: f32 = dot(light_direction, normal_worldspace);
-  var specular: f32 = 0.0;
-  if (lambertian > 0.0) {
-    let specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);
-    specular = pow(specular_angle, material.shininess);
-  }
-  lambertian = max(lambertian, 0.0);
-  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;
-}
+#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)
+    if (abs(float(abs_k) - 1.0) < 0.5) {
+        u = COS_TABLE_0_FP64;
+        v = SIN_TABLE_0_FP64;
+    } else if (abs(float(abs_k) - 2.0) < 0.5) {
+        u = COS_TABLE_1_FP64;
+        v = SIN_TABLE_1_FP64;
+    } else if (abs(float(abs_k) - 3.0) < 0.5) {
+        u = COS_TABLE_2_FP64;
+        v = SIN_TABLE_2_FP64;
+    } else if (abs(float(abs_k) - 4.0) < 0.5) {
+        u = COS_TABLE_3_FP64;
+        v = SIN_TABLE_3_FP64;
+    }
+#else
+    if (abs_k == 1) {
+        u = COS_TABLE_0_FP64;
+        v = SIN_TABLE_0_FP64;
+    } else if (abs_k == 2) {
+        u = COS_TABLE_1_FP64;
+        v = SIN_TABLE_1_FP64;
+    } else if (abs_k == 3) {
+        u = COS_TABLE_2_FP64;
+        v = SIN_TABLE_2_FP64;
+    } else if (abs_k == 4) {
+        u = COS_TABLE_3_FP64;
+        v = SIN_TABLE_3_FP64;
+    }
+#endif
 
-fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32> {
-  var lightColor: vec3<f32> = surfaceColor;
+    vec2 sin_t, cos_t;
+    sincos_taylor_fp64(t, sin_t, cos_t);
 
-  if (lighting.enabled == 0) {
-    return lightColor;
-  }
 
-  let view_direction: vec3<f32> = normalize(cameraPosition - position_worldspace);
-  lightColor = material.ambient * surfaceColor * lighting.ambientColor;
 
-  if (lighting.lightType == 0) {
-    let pointLight: PointLight  = lighting_getPointLight(0);
-    let light_position_worldspace: vec3<f32> = pointLight.position;
-    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
-    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-  } else if (lighting.lightType == 1) {
-    var directionalLight: DirectionalLight = lighting_getDirectionalLight(0);
-    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-  }
-  
-  return lightColor;
-  /*
-  for (int i = 0; i < MAX_LIGHTS; i++) {
-    if (i >= lighting.pointLightCount) {
-      break;
+    vec2 result = vec2(0.0, 0.0);
+    if (j == 0) {
+        if (k > 0) {
+            result = sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
+        } else {
+            result = sub_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
+        }
+    } else if (j == 1) {
+        if (k > 0) {
+            result = sub_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
+        } else {
+            result = sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
+        }
+    } else if (j == -1) {
+        if (k > 0) {
+            result = sub_fp64(mul_fp64(v, sin_t), mul_fp64(u, cos_t));
+        } else {
+            result = -sum_fp64(mul_fp64(v, sin_t), mul_fp64(u, cos_t));
+        }
+    } else {
+        if (k > 0) {
+            result = -sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
+        } else {
+            result = sub_fp64(mul_fp64(v, cos_t), mul_fp64(u, sin_t));
+        }
     }
-    PointLight pointLight = lighting.pointLight[i];
-    vec3 light_position_worldspace = pointLight.position;
-    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
-    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-  }
 
-  for (int i = 0; i < MAX_LIGHTS; i++) {
-    if (i >= lighting.directionalLightCount) {
-      break;
-    }
-    DirectionalLight directionalLight = lighting.directionalLight[i];
-    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-  }
-  */
+    return result;
 }
 
-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);
+vec2 cos_fp64(vec2 a) {
+    if (a.x == 0.0 && a.y == 0.0) {
+        return vec2(1.0, 0.0);
+    }
 
-  if (lighting.enabled == 0) {
-    let view_direction = normalize(cameraPosition - position_worldspace);
+    // 2pi range reduction
+    vec2 z = nint_fp64(div_fp64(a, TWO_PI_FP64));
+    vec2 r = sub_fp64(a, mul_fp64(TWO_PI_FP64, z));
 
-    switch (lighting.lightType) {
-      case 0, default: {
-        let pointLight: PointLight = lighting_getPointLight(0);
-        let light_position_worldspace: vec3<f32> = pointLight.position;
-        let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
-        lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
-      }
-      case 1: {
-        let directionalLight: DirectionalLight = lighting_getDirectionalLight(0);
-        lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
-      }
-    }
-  }
-  return lightColor;
-}
-`
-  );
+    vec2 t;
+    float q = floor(r.x / PI_2_FP64.x + 0.5);
+    int j = int(q);
 
-  // src/modules/lighting/phong-material/phong-material.ts
-  var phongMaterial = {
-    name: "phongMaterial",
-    dependencies: [lighting],
-    // Note these are switched between phong and gouraud
-    source: PHONG_WGSL,
-    vs: PHONG_VS,
-    fs: PHONG_FS,
-    defines: {
-      LIGHTING_FRAGMENT: 1
-    },
-    uniformTypes: {
-      ambient: "f32",
-      diffuse: "f32",
-      shininess: "f32",
-      specularColor: "vec3<f32>"
-    },
-    defaultUniforms: {
-      ambient: 0.35,
-      diffuse: 0.6,
-      shininess: 32,
-      specularColor: [0.15, 0.15, 0.15]
-    },
-    getUniforms(props) {
-      const uniforms = { ...props };
-      if (uniforms.specularColor) {
-        uniforms.specularColor = uniforms.specularColor.map((x) => x / 255);
-      }
-      return { ...phongMaterial.defaultUniforms, ...uniforms };
+    if (j < -2 || j > 2) {
+        return vec2(0.0 / 0.0, 0.0 / 0.0);
     }
-  };
 
-  // src/modules/lighting/pbr-material/pbr-vertex-glsl.ts
-  var vs2 = (
-    /* glsl */
-    `out vec3 pbr_vPosition;
-out vec2 pbr_vUV;
+    t = sub_fp64(r, mul_fp64(PI_2_FP64, vec2(q, 0.0)));
 
-#ifdef HAS_NORMALS
-# ifdef HAS_TANGENTS
-out mat3 pbr_vTBN;
-# else
-out vec3 pbr_vNormal;
-# endif
-#endif
+    q = floor(t.x / PI_16_FP64.x + 0.5);
+    int k = int(q);
 
-void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, vec2 uv)
-{
-  vec4 pos = pbrProjection.modelMatrix * position;
-  pbr_vPosition = vec3(pos.xyz) / pos.w;
+    if (k == 0) {
+        if (j == 0) {
+            return cos_taylor_fp64(t);
+        } else if (j == 1) {
+            return -sin_taylor_fp64(t);
+        } else if (j == -1) {
+            return sin_taylor_fp64(t);
+        } else {
+            return -cos_taylor_fp64(t);
+        }
+    }
 
-#ifdef HAS_NORMALS
-#ifdef HAS_TANGENTS
-  vec3 normalW = normalize(vec3(pbrProjection.normalMatrix * vec4(normal.xyz, 0.0)));
-  vec3 tangentW = normalize(vec3(pbrProjection.modelMatrix * vec4(tangent.xyz, 0.0)));
-  vec3 bitangentW = cross(normalW, tangentW) * tangent.w;
-  pbr_vTBN = mat3(tangentW, bitangentW, normalW);
-#else // HAS_TANGENTS != 1
-  pbr_vNormal = normalize(vec3(pbrProjection.modelMatrix * vec4(normal.xyz, 0.0)));
-#endif
-#endif
+    int abs_k = int(abs(float(k)));
 
-#ifdef HAS_UV
-  pbr_vUV = uv;
+    if (abs_k > 4) {
+        return vec2(0.0 / 0.0, 0.0 / 0.0);
+    } else {
+        t = sub_fp64(t, mul_fp64(PI_16_FP64, vec2(q, 0.0)));
+    }
+
+    vec2 u = vec2(0.0, 0.0);
+    vec2 v = vec2(0.0, 0.0);
+
+#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)
+    if (abs(float(abs_k) - 1.0) < 0.5) {
+        u = COS_TABLE_0_FP64;
+        v = SIN_TABLE_0_FP64;
+    } else if (abs(float(abs_k) - 2.0) < 0.5) {
+        u = COS_TABLE_1_FP64;
+        v = SIN_TABLE_1_FP64;
+    } else if (abs(float(abs_k) - 3.0) < 0.5) {
+        u = COS_TABLE_2_FP64;
+        v = SIN_TABLE_2_FP64;
+    } else if (abs(float(abs_k) - 4.0) < 0.5) {
+        u = COS_TABLE_3_FP64;
+        v = SIN_TABLE_3_FP64;
+    }
 #else
-  pbr_vUV = vec2(0.,0.);
+    if (abs_k == 1) {
+        u = COS_TABLE_0_FP64;
+        v = SIN_TABLE_0_FP64;
+    } else if (abs_k == 2) {
+        u = COS_TABLE_1_FP64;
+        v = SIN_TABLE_1_FP64;
+    } else if (abs_k == 3) {
+        u = COS_TABLE_2_FP64;
+        v = SIN_TABLE_2_FP64;
+    } else if (abs_k == 4) {
+        u = COS_TABLE_3_FP64;
+        v = SIN_TABLE_3_FP64;
+    }
 #endif
-}
-`
-  );
 
-  // src/modules/lighting/pbr-material/pbr-fragment-glsl.ts
-  var fs3 = (
-    /* glsl */
-    `precision highp float;
+    vec2 sin_t, cos_t;
+    sincos_taylor_fp64(t, sin_t, cos_t);
 
-uniform pbrMaterialUniforms {
-  // Material is unlit
-  bool unlit;
+    vec2 result = vec2(0.0, 0.0);
+    if (j == 0) {
+        if (k > 0) {
+            result = sub_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
+        } else {
+            result = sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
+        }
+    } else if (j == 1) {
+        if (k > 0) {
+            result = -sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
+        } else {
+            result = sub_fp64(mul_fp64(v, cos_t), mul_fp64(u, sin_t));
+        }
+    } else if (j == -1) {
+        if (k > 0) {
+            result = sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
+        } else {
+            result = sub_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
+        }
+    } else {
+        if (k > 0) {
+            result = sub_fp64(mul_fp64(v, sin_t), mul_fp64(u, cos_t));
+        } else {
+            result = -sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
+        }
+    }
 
-  // Base color map
-  bool baseColorMapEnabled;
-  vec4 baseColorFactor;
+    return result;
+}
 
-  bool normalMapEnabled;  
-  float normalScale; // #ifdef HAS_NORMALMAP
+vec2 tan_fp64(vec2 a) {
+    vec2 sin_a;
+    vec2 cos_a;
 
-  bool emissiveMapEnabled;
-  vec3 emissiveFactor; // #ifdef HAS_EMISSIVEMAP
+    if (a.x == 0.0 && a.y == 0.0) {
+        return vec2(0.0, 0.0);
+    }
 
-  vec2 metallicRoughnessValues;
-  bool metallicRoughnessMapEnabled;
+    // 2pi range reduction
+    vec2 z = nint_fp64(div_fp64(a, TWO_PI_FP64));
+    vec2 r = sub_fp64(a, mul_fp64(TWO_PI_FP64, z));
 
-  bool occlusionMapEnabled;
-  float occlusionStrength; // #ifdef HAS_OCCLUSIONMAP
-  
-  bool alphaCutoffEnabled;
-  float alphaCutoff; // #ifdef ALPHA_CUTOFF
-  
-  // IBL
-  bool IBLenabled;
-  vec2 scaleIBLAmbient; // #ifdef USE_IBL
-  
-  // debugging flags used for shader output of intermediate PBR variables
-  // #ifdef PBR_DEBUG
-  vec4 scaleDiffBaseMR;
-  vec4 scaleFGDSpec;
-  // #endif
-} pbrMaterial;
+    vec2 t;
+    float q = floor(r.x / PI_2_FP64.x + 0.5);
+    int j = int(q);
 
-// Samplers
-#ifdef HAS_BASECOLORMAP
-uniform sampler2D pbr_baseColorSampler;
-#endif
-#ifdef HAS_NORMALMAP
-uniform sampler2D pbr_normalSampler;
-#endif
-#ifdef HAS_EMISSIVEMAP
-uniform sampler2D pbr_emissiveSampler;
-#endif
-#ifdef HAS_METALROUGHNESSMAP
-uniform sampler2D pbr_metallicRoughnessSampler;
-#endif
-#ifdef HAS_OCCLUSIONMAP
-uniform sampler2D pbr_occlusionSampler;
-#endif
-#ifdef USE_IBL
-uniform samplerCube pbr_diffuseEnvSampler;
-uniform samplerCube pbr_specularEnvSampler;
-uniform sampler2D pbr_brdfLUT;
-#endif
 
-// Inputs from vertex shader
+    if (j < -2 || j > 2) {
+        return vec2(0.0 / 0.0, 0.0 / 0.0);
+    }
 
-in vec3 pbr_vPosition;
-in vec2 pbr_vUV;
+    t = sub_fp64(r, mul_fp64(PI_2_FP64, vec2(q, 0.0)));
 
-#ifdef HAS_NORMALS
-#ifdef HAS_TANGENTS
-in mat3 pbr_vTBN;
-#else
-in vec3 pbr_vNormal;
-#endif
-#endif
+    q = floor(t.x / PI_16_FP64.x + 0.5);
+    int k = int(q);
+    int abs_k = int(abs(float(k)));
 
-// Encapsulate the various inputs used by the various functions in the shading equation
-// We store values in this struct to simplify the integration of alternative implementations
-// of the shading terms, outlined in the Readme.MD Appendix.
-struct PBRInfo {
-  float NdotL;                  // cos angle between normal and light direction
-  float NdotV;                  // cos angle between normal and view direction
-  float NdotH;                  // cos angle between normal and half vector
-  float LdotH;                  // cos angle between light direction and half vector
-  float VdotH;                  // cos angle between view direction and half vector
-  float perceptualRoughness;    // roughness value, as authored by the model creator (input to shader)
-  float metalness;              // metallic value at the surface
-  vec3 reflectance0;            // full reflectance color (normal incidence angle)
-  vec3 reflectance90;           // reflectance color at grazing angle
-  float alphaRoughness;         // roughness mapped to a more linear change in the roughness (proposed by [2])
-  vec3 diffuseColor;            // color contribution from diffuse lighting
-  vec3 specularColor;           // color contribution from specular lighting
-  vec3 n;                       // normal at surface point
-  vec3 v;                       // vector from surface point to camera
-};
+    // We just can't get PI/16 * 3.0 very accurately.
+    // so let's just store it
+    if (abs_k > 4) {
+        return vec2(0.0 / 0.0, 0.0 / 0.0);
+    } else {
+        t = sub_fp64(t, mul_fp64(PI_16_FP64, vec2(q, 0.0)));
+    }
 
-const float M_PI = 3.141592653589793;
-const float c_MinRoughness = 0.04;
 
-vec4 SRGBtoLINEAR(vec4 srgbIn)
-{
-#ifdef MANUAL_SRGB
-#ifdef SRGB_FAST_APPROXIMATION
-  vec3 linOut = pow(srgbIn.xyz,vec3(2.2));
-#else // SRGB_FAST_APPROXIMATION
-  vec3 bLess = step(vec3(0.04045),srgbIn.xyz);
-  vec3 linOut = mix( srgbIn.xyz/vec3(12.92), pow((srgbIn.xyz+vec3(0.055))/vec3(1.055),vec3(2.4)), bLess );
-#endif //SRGB_FAST_APPROXIMATION
-  return vec4(linOut,srgbIn.w);;
-#else //MANUAL_SRGB
-  return srgbIn;
-#endif //MANUAL_SRGB
-}
+    vec2 u = vec2(0.0, 0.0);
+    vec2 v = vec2(0.0, 0.0);
 
-// Find the normal for this fragment, pulling either from a predefined normal map
-// or from the interpolated mesh normal and tangent attributes.
-vec3 getNormal()
-{
-  // Retrieve the tangent space matrix
-#ifndef HAS_TANGENTS
-  vec3 pos_dx = dFdx(pbr_vPosition);
-  vec3 pos_dy = dFdy(pbr_vPosition);
-  vec3 tex_dx = dFdx(vec3(pbr_vUV, 0.0));
-  vec3 tex_dy = dFdy(vec3(pbr_vUV, 0.0));
-  vec3 t = (tex_dy.t * pos_dx - tex_dx.t * pos_dy) / (tex_dx.s * tex_dy.t - tex_dy.s * tex_dx.t);
+    vec2 sin_t, cos_t;
+    vec2 s, c;
+    sincos_taylor_fp64(t, sin_t, cos_t);
 
-#ifdef HAS_NORMALS
-  vec3 ng = normalize(pbr_vNormal);
+    if (k == 0) {
+        s = sin_t;
+        c = cos_t;
+    } else {
+#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)
+        if (abs(float(abs_k) - 1.0) < 0.5) {
+            u = COS_TABLE_0_FP64;
+            v = SIN_TABLE_0_FP64;
+        } else if (abs(float(abs_k) - 2.0) < 0.5) {
+            u = COS_TABLE_1_FP64;
+            v = SIN_TABLE_1_FP64;
+        } else if (abs(float(abs_k) - 3.0) < 0.5) {
+            u = COS_TABLE_2_FP64;
+            v = SIN_TABLE_2_FP64;
+        } else if (abs(float(abs_k) - 4.0) < 0.5) {
+            u = COS_TABLE_3_FP64;
+            v = SIN_TABLE_3_FP64;
+        }
 #else
-  vec3 ng = cross(pos_dx, pos_dy);
-#endif
-
-  t = normalize(t - ng * dot(ng, t));
-  vec3 b = normalize(cross(ng, t));
-  mat3 tbn = mat3(t, b, ng);
-#else // HAS_TANGENTS
-  mat3 tbn = pbr_vTBN;
+        if (abs_k == 1) {
+            u = COS_TABLE_0_FP64;
+            v = SIN_TABLE_0_FP64;
+        } else if (abs_k == 2) {
+            u = COS_TABLE_1_FP64;
+            v = SIN_TABLE_1_FP64;
+        } else if (abs_k == 3) {
+            u = COS_TABLE_2_FP64;
+            v = SIN_TABLE_2_FP64;
+        } else if (abs_k == 4) {
+            u = COS_TABLE_3_FP64;
+            v = SIN_TABLE_3_FP64;
+        }
 #endif
+        if (k > 0) {
+            s = sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
+            c = sub_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
+        } else {
+            s = sub_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
+            c = sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
+        }
+    }
 
-#ifdef HAS_NORMALMAP
-  vec3 n = texture(pbr_normalSampler, pbr_vUV).rgb;
-  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(pbrMaterial.normalScale, pbrMaterial.normalScale, 1.0)));
-#else
-  // The tbn matrix is linearly interpolated, so we need to re-normalize
-  vec3 n = normalize(tbn[2].xyz);
-#endif
+    if (j == 0) {
+        sin_a = s;
+        cos_a = c;
+    } else if (j == 1) {
+        sin_a = c;
+        cos_a = -s;
+    } else if (j == -1) {
+        sin_a = -c;
+        cos_a = s;
+    } else {
+        sin_a = -s;
+        cos_a = -c;
+    }
+    return div_fp64(sin_a, cos_a);
+}
 
-  return n;
+vec2 radians_fp64(vec2 degree) {
+  return mul_fp64(degree, PI_180_FP64);
 }
 
-// Calculation of the lighting contribution from an optional Image Based Light source.
-// Precomputed Environment Maps are required uniform inputs and are computed as outlined in [1].
-// See our README.md on Environment Maps [3] for additional discussion.
-#ifdef USE_IBL
-vec3 getIBLContribution(PBRInfo pbrInfo, vec3 n, vec3 reflection)
-{
-  float mipCount = 9.0; // resolution of 512x512
-  float lod = (pbrInfo.perceptualRoughness * mipCount);
-  // retrieve a scale and bias to F0. See [1], Figure 3
-  vec3 brdf = SRGBtoLINEAR(texture(pbr_brdfLUT,
-    vec2(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness))).rgb;
-  vec3 diffuseLight = SRGBtoLINEAR(texture(pbr_diffuseEnvSampler, n)).rgb;
+vec2 mix_fp64(vec2 a, vec2 b, float x) {
+  vec2 range = sub_fp64(b, a);
+  return sum_fp64(a, mul_fp64(range, vec2(x, 0.0)));
+}
 
-#ifdef USE_TEX_LOD
-  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection, lod)).rgb;
-#else
-  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection)).rgb;
-#endif
+// Vector functions
+// vec2 functions
+void vec2_sum_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {
+    out_val[0] = sum_fp64(a[0], b[0]);
+    out_val[1] = sum_fp64(a[1], b[1]);
+}
 
-  vec3 diffuse = diffuseLight * pbrInfo.diffuseColor;
-  vec3 specular = specularLight * (pbrInfo.specularColor * brdf.x + brdf.y);
+void vec2_sub_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {
+    out_val[0] = sub_fp64(a[0], b[0]);
+    out_val[1] = sub_fp64(a[1], b[1]);
+}
 
-  // For presentation, this allows us to disable IBL terms
-  diffuse *= pbrMaterial.scaleIBLAmbient.x;
-  specular *= pbrMaterial.scaleIBLAmbient.y;
+void vec2_mul_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {
+    out_val[0] = mul_fp64(a[0], b[0]);
+    out_val[1] = mul_fp64(a[1], b[1]);
+}
 
-  return diffuse + specular;
+void vec2_div_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {
+    out_val[0] = div_fp64(a[0], b[0]);
+    out_val[1] = div_fp64(a[1], b[1]);
 }
-#endif
 
-// Basic Lambertian diffuse
-// Implementation from Lambert's Photometria https://archive.org/details/lambertsphotome00lambgoog
-// See also [1], Equation 1
-vec3 diffuse(PBRInfo pbrInfo)
-{
-  return pbrInfo.diffuseColor / M_PI;
+void vec2_mix_fp64(vec2 x[2], vec2 y[2], float a, out vec2 out_val[2]) {
+  vec2 range[2];
+  vec2_sub_fp64(y, x, range);
+  vec2 portion[2];
+  portion[0] = range[0] * a;
+  portion[1] = range[1] * a;
+  vec2_sum_fp64(x, portion, out_val);
 }
 
-// The following equation models the Fresnel reflectance term of the spec equation (aka F())
-// Implementation of fresnel from [4], Equation 15
-vec3 specularReflection(PBRInfo pbrInfo)
-{
-  return pbrInfo.reflectance0 +
-    (pbrInfo.reflectance90 - pbrInfo.reflectance0) *
-    pow(clamp(1.0 - pbrInfo.VdotH, 0.0, 1.0), 5.0);
+vec2 vec2_length_fp64(vec2 x[2]) {
+  return sqrt_fp64(sum_fp64(mul_fp64(x[0], x[0]), mul_fp64(x[1], x[1])));
 }
 
-// This calculates the specular geometric attenuation (aka G()),
-// where rougher material will reflect less light back to the viewer.
-// This implementation is based on [1] Equation 4, and we adopt their modifications to
-// alphaRoughness as input as originally proposed in [2].
-float geometricOcclusion(PBRInfo pbrInfo)
-{
-  float NdotL = pbrInfo.NdotL;
-  float NdotV = pbrInfo.NdotV;
-  float r = pbrInfo.alphaRoughness;
+void vec2_normalize_fp64(vec2 x[2], out vec2 out_val[2]) {
+  vec2 length = vec2_length_fp64(x);
+  vec2 length_vec2[2];
+  length_vec2[0] = length;
+  length_vec2[1] = length;
 
-  float attenuationL = 2.0 * NdotL / (NdotL + sqrt(r * r + (1.0 - r * r) * (NdotL * NdotL)));
-  float attenuationV = 2.0 * NdotV / (NdotV + sqrt(r * r + (1.0 - r * r) * (NdotV * NdotV)));
-  return attenuationL * attenuationV;
+  vec2_div_fp64(x, length_vec2, out_val);
 }
 
-// The following equation(s) model the distribution of microfacet normals across
-// the area being drawn (aka D())
-// Implementation from "Average Irregularity Representation of a Roughened Surface
-// for Ray Reflection" by T. S. Trowbridge, and K. P. Reitz
-// Follows the distribution function recommended in the SIGGRAPH 2013 course notes
-// from EPIC Games [1], Equation 3.
-float microfacetDistribution(PBRInfo pbrInfo)
-{
-  float roughnessSq = pbrInfo.alphaRoughness * pbrInfo.alphaRoughness;
-  float f = (pbrInfo.NdotH * roughnessSq - pbrInfo.NdotH) * pbrInfo.NdotH + 1.0;
-  return roughnessSq / (M_PI * f * f);
+vec2 vec2_distance_fp64(vec2 x[2], vec2 y[2]) {
+  vec2 diff[2];
+  vec2_sub_fp64(x, y, diff);
+  return vec2_length_fp64(diff);
 }
 
-void PBRInfo_setAmbientLight(inout PBRInfo pbrInfo) {
-  pbrInfo.NdotL = 1.0;
-  pbrInfo.NdotH = 0.0;
-  pbrInfo.LdotH = 0.0;
-  pbrInfo.VdotH = 1.0;
-}
+vec2 vec2_dot_fp64(vec2 a[2], vec2 b[2]) {
+  vec2 v[2];
 
-void PBRInfo_setDirectionalLight(inout PBRInfo pbrInfo, vec3 lightDirection) {
-  vec3 n = pbrInfo.n;
-  vec3 v = pbrInfo.v;
-  vec3 l = normalize(lightDirection);             // Vector from surface point to light
-  vec3 h = normalize(l+v);                        // Half vector between both l and v
+  v[0] = mul_fp64(a[0], b[0]);
+  v[1] = mul_fp64(a[1], b[1]);
 
-  pbrInfo.NdotL = clamp(dot(n, l), 0.001, 1.0);
-  pbrInfo.NdotH = clamp(dot(n, h), 0.0, 1.0);
-  pbrInfo.LdotH = clamp(dot(l, h), 0.0, 1.0);
-  pbrInfo.VdotH = clamp(dot(v, h), 0.0, 1.0);
+  return sum_fp64(v[0], v[1]);
 }
 
-void PBRInfo_setPointLight(inout PBRInfo pbrInfo, PointLight pointLight) {
-  vec3 light_direction = normalize(pointLight.position - pbr_vPosition);
-  PBRInfo_setDirectionalLight(pbrInfo, light_direction);
+// vec3 functions
+void vec3_sub_fp64(vec2 a[3], vec2 b[3], out vec2 out_val[3]) {
+  for (int i = 0; i < 3; i++) {
+    out_val[i] = sum_fp64(a[i], b[i]);
+  }
 }
 
-vec3 calculateFinalColor(PBRInfo pbrInfo, vec3 lightColor) {
-  // Calculate the shading terms for the microfacet specular shading model
-  vec3 F = specularReflection(pbrInfo);
-  float G = geometricOcclusion(pbrInfo);
-  float D = microfacetDistribution(pbrInfo);
+void vec3_sum_fp64(vec2 a[3], vec2 b[3], out vec2 out_val[3]) {
+  for (int i = 0; i < 3; i++) {
+    out_val[i] = sum_fp64(a[i], b[i]);
+  }
+}
 
-  // Calculation of analytical lighting contribution
-  vec3 diffuseContrib = (1.0 - F) * diffuse(pbrInfo);
-  vec3 specContrib = F * G * D / (4.0 * pbrInfo.NdotL * pbrInfo.NdotV);
-  // Obtain final intensity as reflectance (BRDF) scaled by the energy of the light (cosine law)
-  return pbrInfo.NdotL * lightColor * (diffuseContrib + specContrib);
+vec2 vec3_length_fp64(vec2 x[3]) {
+  return sqrt_fp64(sum_fp64(sum_fp64(mul_fp64(x[0], x[0]), mul_fp64(x[1], x[1])),
+    mul_fp64(x[2], x[2])));
 }
 
-vec4 pbr_filterColor(vec4 colorUnused)
-{
-  // The albedo may be defined from a base texture or a flat color
-#ifdef HAS_BASECOLORMAP
-  vec4 baseColor = SRGBtoLINEAR(texture(pbr_baseColorSampler, pbr_vUV)) * pbrMaterial.baseColorFactor;
-#else
-  vec4 baseColor = pbrMaterial.baseColorFactor;
-#endif
+vec2 vec3_distance_fp64(vec2 x[3], vec2 y[3]) {
+  vec2 diff[3];
+  vec3_sub_fp64(x, y, diff);
+  return vec3_length_fp64(diff);
+}
 
-#ifdef ALPHA_CUTOFF
-  if (baseColor.a < pbrMaterial.alphaCutoff) {
-    discard;
-  }
-#endif
+// vec4 functions
+void vec4_fp64(vec4 a, out vec2 out_val[4]) {
+  out_val[0].x = a[0];
+  out_val[0].y = 0.0;
 
-  vec3 color = vec3(0, 0, 0);
+  out_val[1].x = a[1];
+  out_val[1].y = 0.0;
 
-  if(pbrMaterial.unlit){
-    color.rgb = baseColor.rgb;
+  out_val[2].x = a[2];
+  out_val[2].y = 0.0;
+
+  out_val[3].x = a[3];
+  out_val[3].y = 0.0;
+}
+
+void vec4_scalar_mul_fp64(vec2 a[4], vec2 b, out vec2 out_val[4]) {
+  out_val[0] = mul_fp64(a[0], b);
+  out_val[1] = mul_fp64(a[1], b);
+  out_val[2] = mul_fp64(a[2], b);
+  out_val[3] = mul_fp64(a[3], b);
+}
+
+void vec4_sum_fp64(vec2 a[4], vec2 b[4], out vec2 out_val[4]) {
+  for (int i = 0; i < 4; i++) {
+    out_val[i] = sum_fp64(a[i], b[i]);
   }
-  else{
-    // Metallic and Roughness material properties are packed together
-    // In glTF, these factors can be specified by fixed scalar values
-    // or from a metallic-roughness map
-    float perceptualRoughness = pbrMaterial.metallicRoughnessValues.y;
-    float metallic = pbrMaterial.metallicRoughnessValues.x;
-#ifdef HAS_METALROUGHNESSMAP
-    // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.
-    // This layout intentionally reserves the 'r' channel for (optional) occlusion map data
-    vec4 mrSample = texture(pbr_metallicRoughnessSampler, pbr_vUV);
-    perceptualRoughness = mrSample.g * perceptualRoughness;
-    metallic = mrSample.b * metallic;
-#endif
-    perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);
-    metallic = clamp(metallic, 0.0, 1.0);
-    // Roughness is authored as perceptual roughness; as is convention,
-    // convert to material roughness by squaring the perceptual roughness [2].
-    float alphaRoughness = perceptualRoughness * perceptualRoughness;
+}
 
-    vec3 f0 = vec3(0.04);
-    vec3 diffuseColor = baseColor.rgb * (vec3(1.0) - f0);
-    diffuseColor *= 1.0 - metallic;
-    vec3 specularColor = mix(f0, baseColor.rgb, metallic);
+void vec4_dot_fp64(vec2 a[4], vec2 b[4], out vec2 out_val) {
+  vec2 v[4];
 
-    // Compute reflectance.
-    float reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);
+  v[0] = mul_fp64(a[0], b[0]);
+  v[1] = mul_fp64(a[1], b[1]);
+  v[2] = mul_fp64(a[2], b[2]);
+  v[3] = mul_fp64(a[3], b[3]);
 
-    // For typical incident reflectance range (between 4% to 100%) set the grazing
-    // reflectance to 100% for typical fresnel effect.
-    // For very low reflectance range on highly diffuse objects (below 4%),
-    // incrementally reduce grazing reflecance to 0%.
-    float reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);
-    vec3 specularEnvironmentR0 = specularColor.rgb;
-    vec3 specularEnvironmentR90 = vec3(1.0, 1.0, 1.0) * reflectance90;
+  out_val = sum_fp64(sum_fp64(v[0], v[1]), sum_fp64(v[2], v[3]));
+}
 
-    vec3 n = getNormal();                          // normal at surface point
-    vec3 v = normalize(pbrProjection.camera - pbr_vPosition);  // Vector from surface point to camera
+void mat4_vec4_mul_fp64(vec2 b[16], vec2 a[4], out vec2 out_val[4]) {
+  vec2 tmp[4];
 
-    float NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);
-    vec3 reflection = -normalize(reflect(v, n));
+  for (int i = 0; i < 4; i++)
+  {
+    for (int j = 0; j < 4; j++)
+    {
+      tmp[j] = b[j + i * 4];
+    }
+    vec4_dot_fp64(a, tmp, out_val[i]);
+  }
+}
+`
+  );
 
-    PBRInfo pbrInfo = PBRInfo(
-      0.0, // NdotL
-      NdotV,
-      0.0, // NdotH
-      0.0, // LdotH
-      0.0, // VdotH
-      perceptualRoughness,
-      metallic,
-      specularEnvironmentR0,
-      specularEnvironmentR90,
-      alphaRoughness,
-      diffuseColor,
-      specularColor,
-      n,
-      v
-    );
+  // src/modules/math/fp64/fp64.ts
+  var defaultUniforms = {
+    // Used in LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+    ONE: 1
+  };
+  var fp64arithmetic = {
+    name: "fp64arithmetic",
+    vs: fp64arithmeticShader,
+    defaultUniforms,
+    uniformTypes: { ONE: "f32" },
+    // Additional Functions
+    fp64ify,
+    fp64LowPart,
+    fp64ifyMatrix4
+  };
+  var fp64 = {
+    name: "fp64",
+    vs: fp64functionShader,
+    dependencies: [fp64arithmetic],
+    // Additional Functions
+    fp64ify,
+    fp64LowPart,
+    fp64ifyMatrix4
+  };
 
+  // src/modules/engine/picking/picking.ts
+  var DEFAULT_HIGHLIGHT_COLOR = [0, 1, 1, 1];
+  var vs = (
+    /* glsl */
+    `uniform pickingUniforms {
+  float isActive;
+  float isAttribute;
+  float isHighlightActive;
+  float useFloatColors;
+  vec3 highlightedObjectColor;
+  vec4 highlightColor;
+} picking;
 
-#ifdef USE_LIGHTS
-    // Apply ambient light
-    PBRInfo_setAmbientLight(pbrInfo);
-    color += calculateFinalColor(pbrInfo, lighting.ambientColor);
+out vec4 picking_vRGBcolor_Avalid;
 
-    // Apply directional light
-    for(int i = 0; i < lighting.directionalLightCount; i++) {
-      if (i < lighting.directionalLightCount) {
-        PBRInfo_setDirectionalLight(pbrInfo, lighting_getDirectionalLight(i).direction);
-        color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
-      }
-    }
+// Normalize unsigned byte color to 0-1 range
+vec3 picking_normalizeColor(vec3 color) {
+  return picking.useFloatColors > 0.5 ? color : color / 255.0;
+}
 
-    // Apply point light
-    for(int i = 0; i < lighting.pointLightCount; i++) {
-      if (i < lighting.pointLightCount) {
-        PBRInfo_setPointLight(pbrInfo, lighting_getPointLight(i));
-        float attenuation = getPointLightAttenuation(lighting_getPointLight(i), distance(lighting_getPointLight(i).position, pbr_vPosition));
-        color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
-      }
-    }
-#endif
+// Normalize unsigned byte color to 0-1 range
+vec4 picking_normalizeColor(vec4 color) {
+  return picking.useFloatColors > 0.5 ? color : color / 255.0;
+}
 
-    // Calculate lighting contribution from image based lighting source (IBL)
-#ifdef USE_IBL
-    if (pbrMaterial.IBLenabled) {
-      color += getIBLContribution(pbrInfo, n, reflection);
-    }
-#endif
+bool picking_isColorZero(vec3 color) {
+  return dot(color, vec3(1.0)) < 0.00001;
+}
 
- // Apply optional PBR terms for additional (optional) shading
-#ifdef HAS_OCCLUSIONMAP
-    if (pbrMaterial.occlusionMapEnabled) {
-      float ao = texture(pbr_occlusionSampler, pbr_vUV).r;
-      color = mix(color, color * ao, pbrMaterial.occlusionStrength);
-    }
-#endif
+bool picking_isColorValid(vec3 color) {
+  return dot(color, vec3(1.0)) > 0.00001;
+}
 
-#ifdef HAS_EMISSIVEMAP
-    if (pbrMaterial.emissiveMapEnabled) {
-      vec3 emissive = SRGBtoLINEAR(texture(pbr_emissiveSampler, pbr_vUV)).rgb * pbrMaterial.emissiveFactor;
-      color += emissive;
-    }
-#endif
+// Check if this vertex is highlighted 
+bool isVertexHighlighted(vec3 vertexColor) {
+  vec3 highlightedObjectColor = picking_normalizeColor(picking.highlightedObjectColor);
+  return
+    bool(picking.isHighlightActive) && picking_isColorZero(abs(vertexColor - highlightedObjectColor));
+}
 
-    // This section uses mix to override final color for reference app visualization
-    // of various parameters in the lighting equation.
-#ifdef PBR_DEBUG
-    // TODO: Figure out how to debug multiple lights
+// Set the current picking color
+void picking_setPickingColor(vec3 pickingColor) {
+  pickingColor = picking_normalizeColor(pickingColor);
 
-    // color = mix(color, F, pbr_scaleFGDSpec.x);
-    // color = mix(color, vec3(G), pbr_scaleFGDSpec.y);
-    // color = mix(color, vec3(D), pbr_scaleFGDSpec.z);
-    // color = mix(color, specContrib, pbr_scaleFGDSpec.w);
+  if (bool(picking.isActive)) {
+    // Use alpha as the validity flag. If pickingColor is [0, 0, 0] fragment is non-pickable
+    picking_vRGBcolor_Avalid.a = float(picking_isColorValid(pickingColor));
 
-    // color = mix(color, diffuseContrib, pbr_scaleDiffBaseMR.x);
-    color = mix(color, baseColor.rgb, pbrMaterial.scaleDiffBaseMR.y);
-    color = mix(color, vec3(metallic), pbrMaterial.scaleDiffBaseMR.z);
-    color = mix(color, vec3(perceptualRoughness), pbrMaterial.scaleDiffBaseMR.w);
-#endif
+    if (!bool(picking.isAttribute)) {
+      // Stores the picking color so that the fragment shader can render it during picking
+      picking_vRGBcolor_Avalid.rgb = pickingColor;
+    }
+  } else {
+    // Do the comparison with selected item color in vertex shader as it should mean fewer compares
+    picking_vRGBcolor_Avalid.a = float(isVertexHighlighted(pickingColor));
+  }
+}
 
+void picking_setPickingAttribute(float value) {
+  if (bool(picking.isAttribute)) {
+    picking_vRGBcolor_Avalid.r = value;
   }
+}
 
-  return vec4(pow(color,vec3(1.0/2.2)), baseColor.a);
+void picking_setPickingAttribute(vec2 value) {
+  if (bool(picking.isAttribute)) {
+    picking_vRGBcolor_Avalid.rg = value;
+  }
 }
-`
-  );
 
-  // src/modules/lighting/pbr-material/pbr-projection.ts
-  var uniformBlock = (
-    /* glsl */
-    `uniform pbrProjectionUniforms {
-  mat4 modelViewProjectionMatrix;
-  mat4 modelMatrix;
-  mat4 normalMatrix;
-  vec3 camera;
-} pbrProjection;
+void picking_setPickingAttribute(vec3 value) {
+  if (bool(picking.isAttribute)) {
+    picking_vRGBcolor_Avalid.rgb = value;
+  }
+}
 `
   );
-  var pbrProjection = {
-    name: "pbrProjection",
-    vs: uniformBlock,
-    fs: uniformBlock,
-    // TODO why is this needed?
-    getUniforms: (props) => props,
-    uniformTypes: {
-      modelViewProjectionMatrix: "mat4x4<f32>",
-      modelMatrix: "mat4x4<f32>",
-      normalMatrix: "mat4x4<f32>",
-      camera: "vec3<i32>"
+  var fs2 = (
+    /* glsl */
+    `uniform pickingUniforms {
+  float isActive;
+  float isAttribute;
+  float isHighlightActive;
+  float useFloatColors;
+  vec3 highlightedObjectColor;
+  vec4 highlightColor;
+} picking;
+
+in vec4 picking_vRGBcolor_Avalid;
+
+/*
+ * Returns highlight color if this item is selected.
+ */
+vec4 picking_filterHighlightColor(vec4 color) {
+  // If we are still picking, we don't highlight
+  if (picking.isActive > 0.5) {
+    return color;
+  }
+
+  bool selected = bool(picking_vRGBcolor_Avalid.a);
+
+  if (selected) {
+    // Blend in highlight color based on its alpha value
+    float highLightAlpha = picking.highlightColor.a;
+    float blendedAlpha = highLightAlpha + color.a * (1.0 - highLightAlpha);
+    float highLightRatio = highLightAlpha / blendedAlpha;
+
+    vec3 blendedRGB = mix(color.rgb, picking.highlightColor.rgb, highLightRatio);
+    return vec4(blendedRGB, blendedAlpha);
+  } else {
+    return color;
+  }
+}
+
+/*
+ * Returns picking color if picking enabled else unmodified argument.
+ */
+vec4 picking_filterPickingColor(vec4 color) {
+  if (bool(picking.isActive)) {
+    if (picking_vRGBcolor_Avalid.a == 0.0) {
+      discard;
     }
-  };
+    return picking_vRGBcolor_Avalid;
+  }
+  return color;
+}
 
-  // src/modules/lighting/pbr-material/pbr-material.ts
-  var pbrMaterial = {
+/*
+ * Returns picking color if picking is enabled if not
+ * highlight color if this item is selected, otherwise unmodified argument.
+ */
+vec4 picking_filterColor(vec4 color) {
+  vec4 highlightColor = picking_filterHighlightColor(color);
+  return picking_filterPickingColor(highlightColor);
+}
+`
+  );
+  var picking = {
     props: {},
     uniforms: {},
-    name: "pbrMaterial",
-    dependencies: [lighting, pbrProjection],
-    vs: vs2,
-    fs: fs3,
-    defines: {
-      LIGHTING_FRAGMENT: 1
-      // TODO defining these as 0 breaks shader
-      // HAS_NORMALMAP: 0
-      // HAS_EMISSIVEMAP: 0,
-      // HAS_OCCLUSIONMAP: 0,
-      // HAS_BASECOLORMAP: 0,
-      // HAS_METALROUGHNESSMAP: 0,
-      // ALPHA_CUTOFF: 0
-      // USE_IBL: 0
-      // PBR_DEBUG: 0
-    },
-    getUniforms: (props) => props,
+    name: "picking",
     uniformTypes: {
-      // Material is unlit
-      unlit: "i32",
-      // Base color map
-      baseColorMapEnabled: "i32",
-      baseColorFactor: "vec4<f32>",
-      normalMapEnabled: "i32",
-      normalScale: "f32",
-      // #ifdef HAS_NORMALMAP
-      emissiveMapEnabled: "i32",
-      emissiveFactor: "vec3<f32>",
-      // #ifdef HAS_EMISSIVEMAP
-      metallicRoughnessValues: "vec2<f32>",
-      metallicRoughnessMapEnabled: "i32",
-      occlusionMapEnabled: "i32",
-      occlusionStrength: "f32",
-      // #ifdef HAS_OCCLUSIONMAP
-      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>"
-    }
+      isActive: "f32",
+      isAttribute: "f32",
+      isHighlightActive: "f32",
+      useFloatColors: "f32",
+      highlightedObjectColor: "vec3<f32>",
+      highlightColor: "vec4<f32>"
+    },
+    defaultUniforms: {
+      isActive: false,
+      isAttribute: false,
+      isHighlightActive: false,
+      useFloatColors: true,
+      highlightedObjectColor: [0, 0, 0],
+      highlightColor: DEFAULT_HIGHLIGHT_COLOR
+    },
+    vs,
+    fs: fs2,
+    getUniforms
   };
+  function getUniforms(opts = {}, prevUniforms) {
+    const uniforms = {};
+    if (opts.highlightedObjectColor === void 0) {
+    } else if (opts.highlightedObjectColor === null) {
+      uniforms.isHighlightActive = false;
+    } else {
+      uniforms.isHighlightActive = true;
+      const highlightedObjectColor = opts.highlightedObjectColor.slice(0, 3);
+      uniforms.highlightedObjectColor = highlightedObjectColor;
+    }
+    if (opts.highlightColor) {
+      const color = Array.from(opts.highlightColor, (x) => x / 255);
+      if (!Number.isFinite(color[3])) {
+        color[3] = 1;
+      }
+      uniforms.highlightColor = color;
+    }
+    if (opts.isActive !== void 0) {
+      uniforms.isActive = Boolean(opts.isActive);
+      uniforms.isAttribute = Boolean(opts.isAttribute);
+    }
+    if (opts.useFloatColors !== void 0) {
+      uniforms.useFloatColors = Boolean(opts.useFloatColors);
+    }
+    return uniforms;
+  }
 
-  // src/modules-webgl1/math/fp64/fp64-arithmetic-glsl.ts
-  var fp64arithmeticShader = (
+  // src/modules/lighting/lights/lighting.ts
+  var import_core3 = __toESM(require_core(), 1);
+
+  // src/modules/lighting/lights/lighting-uniforms-glsl.ts
+  var lightingUniformsGLSL = (
     /* glsl */
-    `uniform float ONE;
+    `precision highp int;
 
-/*
-About LUMA_FP64_CODE_ELIMINATION_WORKAROUND
+// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
+struct AmbientLight {
+  vec3 color;
+};
 
-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.
+struct PointLight {
+  vec3 color;
+  vec3 position;
+  vec3 attenuation; // 2nd order x:Constant-y:Linear-z:Exponential
+};
 
-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
-and one b should appear
+struct DirectionalLight {
+  vec3 color;
+  vec3 direction;
+};
 
-err = (a + b) * ONE^6 - a * ONE^5 - (a + b) * ONE^4 + a * ONE^3 - b - (a + b) * ONE^2 + a * ONE
-*/
+uniform lightingUniforms {
+  int enabled;
+  int lightType;
 
-// 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;
-#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float a_hi = t * ONE - (t - a);
-  float a_lo = a * ONE - a_hi;
-#else
-  float a_hi = t - (t - a);
-  float a_lo = a - a_hi;
-#endif
-  return vec2(a_hi, a_lo);
-}
+  int directionalLightCount;
+  int pointLightCount;
 
-// Divide float number again when high float uses too many fraction bits
-vec2 split2(vec2 a) {
-  vec2 b = split(a.x);
-  b.y += a.y;
-  return b;
-}
+  vec3 ambientColor;
 
-// Special sum operation when a > b
-vec2 quickTwoSum(float a, float b) {
-#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float sum = (a + b) * ONE;
-  float err = b - (sum - a) * ONE;
-#else
-  float sum = a + b;
-  float err = b - (sum - a);
-#endif
-  return vec2(sum, err);
-}
+  vec3 lightColor0;
+  vec3 lightPosition0;
+  vec3 lightDirection0;
+  vec3 lightAttenuation0;
 
-// General sum operation
-vec2 twoSum(float a, float b) {
-  float s = (a + b);
-#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float v = (s * ONE - a) * ONE;
-  float err = (a - (s - v) * ONE) * ONE * ONE * ONE + (b - v);
-#else
-  float v = s - a;
-  float err = (a - (s - v)) + (b - v);
-#endif
-  return vec2(s, err);
-}
+  vec3 lightColor1;
+  vec3 lightPosition1;
+  vec3 lightDirection1;
+  vec3 lightAttenuation1;
 
-vec2 twoSub(float a, float b) {
-  float s = (a - b);
-#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float v = (s * ONE - a) * ONE;
-  float err = (a - (s - v) * ONE) * ONE * ONE * ONE - (b + v);
-#else
-  float v = s - a;
-  float err = (a - (s - v)) - (b + v);
-#endif
-  return vec2(s, err);
-}
+  vec3 lightColor2;
+  vec3 lightPosition2;
+  vec3 lightDirection2;
+  vec3 lightAttenuation2;
+} lighting;
 
-vec2 twoSqr(float a) {
-  float prod = a * a;
-  vec2 a_fp64 = split(a);
-#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  float err = ((a_fp64.x * a_fp64.x - prod) * ONE + 2.0 * a_fp64.x *
-    a_fp64.y * ONE * ONE) + a_fp64.y * a_fp64.y * ONE * ONE * ONE;
-#else
-  float err = ((a_fp64.x * a_fp64.x - prod) + 2.0 * a_fp64.x * a_fp64.y) + a_fp64.y * a_fp64.y;
-#endif
-  return vec2(prod, err);
-}
-
-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;
-  return vec2(prod, err);
-}
-
-vec2 sum_fp64(vec2 a, vec2 b) {
-  vec2 s, t;
-  s = twoSum(a.x, b.x);
-  t = twoSum(a.y, b.y);
-  s.y += t.x;
-  s = quickTwoSum(s.x, s.y);
-  s.y += t.y;
-  s = quickTwoSum(s.x, s.y);
-  return s;
-}
-
-vec2 sub_fp64(vec2 a, vec2 b) {
-  vec2 s, t;
-  s = twoSub(a.x, b.x);
-  t = twoSub(a.y, b.y);
-  s.y += t.x;
-  s = quickTwoSum(s.x, s.y);
-  s.y += t.y;
-  s = quickTwoSum(s.x, s.y);
-  return s;
+PointLight lighting_getPointLight(int index) {
+  switch (index) {
+    case 0:
+      return PointLight(lighting.lightColor0, lighting.lightPosition0, lighting.lightAttenuation0);
+    case 1:
+      return PointLight(lighting.lightColor1, lighting.lightPosition1, lighting.lightAttenuation1);
+    case 2:
+    default:  
+      return PointLight(lighting.lightColor2, lighting.lightPosition2, lighting.lightAttenuation2);
+  }
 }
 
-vec2 mul_fp64(vec2 a, vec2 b) {
-  vec2 prod = twoProd(a.x, b.x);
-  // y component is for the error
-  prod.y += a.x * b.y;
-#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
-  prod = split2(prod);
-#endif
-  prod = quickTwoSum(prod.x, prod.y);
-  prod.y += a.y * b.x;
-#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
-  prod = split2(prod);
-#endif
-  prod = quickTwoSum(prod.x, prod.y);
-  return prod;
-}
+DirectionalLight lighting_getDirectionalLight(int index) {
+  switch (index) {
+    case 0:
+      return DirectionalLight(lighting.lightColor0, lighting.lightDirection0);
+    case 1:
+      return DirectionalLight(lighting.lightColor1, lighting.lightDirection1);
+    case 2:
+    default:   
+      return DirectionalLight(lighting.lightColor2, lighting.lightDirection2);
+  }
+} 
 
-vec2 div_fp64(vec2 a, vec2 b) {
-  float xn = 1.0 / b.x;
-#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
-  vec2 yn = mul_fp64(a, vec2(xn, 0));
-#else
-  vec2 yn = a * xn;
-#endif
-  float diff = (sub_fp64(a, mul_fp64(b, yn))).x;
-  vec2 prod = twoProd(xn, diff);
-  return sum_fp64(yn, prod);
+float getPointLightAttenuation(PointLight pointLight, float distance) {
+  return pointLight.attenuation.x
+       + pointLight.attenuation.y * distance
+       + pointLight.attenuation.z * distance * distance;
 }
 
-vec2 sqrt_fp64(vec2 a) {
-  if (a.x == 0.0 && a.y == 0.0) return vec2(0.0, 0.0);
-  if (a.x < 0.0) return vec2(0.0 / 0.0, 0.0 / 0.0);
-
-  float x = 1.0 / sqrt(a.x);
-  float yn = a.x * x;
-#if defined(LUMA_FP64_CODE_ELIMINATION_WORKAROUND)
-  vec2 yn_sqr = twoSqr(yn) * ONE;
-#else
-  vec2 yn_sqr = twoSqr(yn);
-#endif
-  float diff = sub_fp64(a, yn_sqr).x;
-  vec2 prod = twoProd(x * 0.5, diff);
-#if defined(LUMA_FP64_HIGH_BITS_OVERFLOW_WORKAROUND)
-  return sum_fp64(split(yn), prod);
-#else
-  return sum_fp64(vec2(yn, 0.0), prod);
-#endif
-}
+// #endif
 `
   );
 
-  // src/modules-webgl1/math/fp64/fp64-functions-glsl.ts
-  var fp64functionShader = (
-    /* glsl */
-    `const vec2 E_FP64 = vec2(2.7182817459106445e+00, 8.254840366817007e-08);
-const vec2 LOG2_FP64 = vec2(0.6931471824645996e+00, -1.9046542121259336e-09);
-const vec2 PI_FP64 = vec2(3.1415927410125732, -8.742278012618954e-8);
-const vec2 TWO_PI_FP64 = vec2(6.2831854820251465, -1.7484556025237907e-7);
-const vec2 PI_2_FP64 = vec2(1.5707963705062866, -4.371139006309477e-8);
-const vec2 PI_4_FP64 = vec2(0.7853981852531433, -2.1855695031547384e-8);
-const vec2 PI_16_FP64 = vec2(0.19634954631328583, -5.463923757886846e-9);
-const vec2 PI_16_2_FP64 = vec2(0.39269909262657166, -1.0927847515773692e-8);
-const vec2 PI_16_3_FP64 = vec2(0.5890486240386963, -1.4906100798128818e-9);
-const vec2 PI_180_FP64 = vec2(0.01745329238474369, 1.3519960498364902e-10);
-
-const vec2 SIN_TABLE_0_FP64 = vec2(0.19509032368659973, -1.6704714833615242e-9);
-const vec2 SIN_TABLE_1_FP64 = vec2(0.3826834261417389, 6.22335089017767e-9);
-const vec2 SIN_TABLE_2_FP64 = vec2(0.5555702447891235, -1.1769521357507529e-8);
-const vec2 SIN_TABLE_3_FP64 = vec2(0.7071067690849304, 1.2101617041793133e-8);
-
-const vec2 COS_TABLE_0_FP64 = vec2(0.9807852506637573, 2.9739473106360492e-8);
-const vec2 COS_TABLE_1_FP64 = vec2(0.9238795042037964, 2.8307490351764386e-8);
-const vec2 COS_TABLE_2_FP64 = vec2(0.8314695954322815, 1.6870263741530778e-8);
-const vec2 COS_TABLE_3_FP64 = vec2(0.7071067690849304, 1.2101617152815436e-8);
-
-const vec2 INVERSE_FACTORIAL_3_FP64 = vec2(1.666666716337204e-01, -4.967053879312289e-09); // 1/3!
-const vec2 INVERSE_FACTORIAL_4_FP64 = vec2(4.16666679084301e-02, -1.2417634698280722e-09); // 1/4!
-const vec2 INVERSE_FACTORIAL_5_FP64 = vec2(8.333333767950535e-03, -4.34617203337595e-10); // 1/5!
-const vec2 INVERSE_FACTORIAL_6_FP64 = vec2(1.3888889225199819e-03, -3.3631094437103215e-11); // 1/6!
-const vec2 INVERSE_FACTORIAL_7_FP64 = vec2(1.9841270113829523e-04,  -2.725596874933456e-12); // 1/7!
-const vec2 INVERSE_FACTORIAL_8_FP64 = vec2(2.4801587642286904e-05, -3.406996025904184e-13); // 1/8!
-const vec2 INVERSE_FACTORIAL_9_FP64 = vec2(2.75573188446287533e-06, 3.7935713937038186e-14); // 1/9!
-const vec2 INVERSE_FACTORIAL_10_FP64 = vec2(2.755731998149713e-07, -7.575112367869873e-15); // 1/10!
-
-float nint(float d) {
-    if (d == floor(d)) return d;
-    return floor(d + 0.5);
-}
-
-vec2 nint_fp64(vec2 a) {
-    float hi = nint(a.x);
-    float lo;
-    vec2 tmp;
-    if (hi == a.x) {
-        lo = nint(a.y);
-        tmp = quickTwoSum(hi, lo);
-    } else {
-        lo = 0.0;
-        if (abs(hi - a.x) == 0.5 && a.y < 0.0) {
-            hi -= 1.0;
-        }
-        tmp = vec2(hi, lo);
-    }
-    return tmp;
-}
-
-/* k_power controls how much range reduction we would like to have
-Range reduction uses the following method:
-assume a = k_power * r + m * log(2), k and m being integers.
-Set k_power = 4 (we can choose other k to trade accuracy with performance.
-we only need to calculate exp(r) and using exp(a) = 2^m * exp(r)^k_power;
-*/
-
-vec2 exp_fp64(vec2 a) {
-  // We need to make sure these two numbers match
-  // as bit-wise shift is not available in GLSL 1.0
-  const int k_power = 4;
-  const float k = 16.0;
-
-  const float inv_k = 1.0 / k;
-
-  if (a.x <= -88.0) return vec2(0.0, 0.0);
-  if (a.x >= 88.0) return vec2(1.0 / 0.0, 1.0 / 0.0);
-  if (a.x == 0.0 && a.y == 0.0) return vec2(1.0, 0.0);
-  if (a.x == 1.0 && a.y == 0.0) return E_FP64;
-
-  float m = floor(a.x / LOG2_FP64.x + 0.5);
-  vec2 r = sub_fp64(a, mul_fp64(LOG2_FP64, vec2(m, 0.0))) * inv_k;
-  vec2 s, t, p;
+  // src/modules/lighting/lights/lighting-uniforms-wgsl.ts
+  var lightingUniformsWGSL = (
+    /* wgsl */
+    `// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
+struct AmbientLight {
+  color: vec3<f32>,
+};
 
-  p = mul_fp64(r, r);
-  s = sum_fp64(r, p * 0.5);
-  p = mul_fp64(p, r);
-  t = mul_fp64(p, INVERSE_FACTORIAL_3_FP64);
+struct PointLight {
+  color: vec3<f32>,
+  position: vec3<f32>,
+  attenuation: vec3<f32>, // 2nd order x:Constant-y:Linear-z:Exponential
+};
 
-  s = sum_fp64(s, t);
-  p = mul_fp64(p, r);
-  t = mul_fp64(p, INVERSE_FACTORIAL_4_FP64);
+struct DirectionalLight {
+  color: vec3<f32>,
+  direction: vec3<f32>,
+};
 
-  s = sum_fp64(s, t);
-  p = mul_fp64(p, r);
-  t = mul_fp64(p, INVERSE_FACTORIAL_5_FP64);
+struct lightingUniforms {
+  enabled: i32,
+  poightCount: i32,
+  directionalLightCount: i32,
 
-  // s = sum_fp64(s, t);
-  // p = mul_fp64(p, r);
-  // t = mul_fp64(p, INVERSE_FACTORIAL_6_FP64);
+  ambientColor: vec3<f32>,
 
-  // s = sum_fp64(s, t);
-  // p = mul_fp64(p, r);
-  // t = mul_fp64(p, INVERSE_FACTORIAL_7_FP64);
+  // TODO - support multiple lights by uncommenting arrays below
+  lightType: i32,
+  lightColor: vec3<f32>,
+  lightDirection: vec3<f32>,
+  lightPosition: vec3<f32>,
+  lightAttenuation: vec3<f32>,
 
-  s = sum_fp64(s, t);
+  // AmbientLight ambientLight;
+  // PointLight pointLight[MAX_LIGHTS];
+  // DirectionalLight directionalLight[MAX_LIGHTS];
+};
 
+// Binding 0:1 is reserved for lighting (Note: could go into separate bind group as it is stable across draw calls)
+@binding(1) @group(0) var<uniform> lighting : lightingUniforms;
 
-  // At this point, s = exp(r) - 1; but after following 4 recursions, we will get exp(r) ^ 512 - 1.
-  for (int i = 0; i < k_power; i++) {
-    s = sum_fp64(s * 2.0, mul_fp64(s, s));
-  }
+fn lighting_getPointLight(index: i32) -> PointLight {
+  return PointLight(lighting.lightColor, lighting.lightPosition, lighting.lightAttenuation);
+}
 
-#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)
-  s = sum_fp64(s, vec2(ONE, 0.0));
-#else
-  s = sum_fp64(s, vec2(1.0, 0.0));
-#endif
+fn lighting_getDirectionalLight(index: i32) -> DirectionalLight {
+  return DirectionalLight(lighting.lightColor, lighting.lightDirection);
+} 
 
-  return s * pow(2.0, m);
-//   return r;
+fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
+  return pointLight.attenuation.x
+       + pointLight.attenuation.y * distance
+       + pointLight.attenuation.z * distance * distance;
 }
+`
+  );
 
-vec2 log_fp64(vec2 a)
-{
-  if (a.x == 1.0 && a.y == 0.0) return vec2(0.0, 0.0);
-  if (a.x <= 0.0) return vec2(0.0 / 0.0, 0.0 / 0.0);
-  vec2 x = vec2(log(a.x), 0.0);
-  vec2 s;
-#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)
-  s = vec2(ONE, 0.0);
-#else
-  s = vec2(1.0, 0.0);
-#endif
-
-  x = sub_fp64(sum_fp64(x, mul_fp64(a, exp_fp64(-x))), s);
-  return x;
-}
-
-vec2 sin_taylor_fp64(vec2 a) {
-  vec2 r, s, t, x;
-
-  if (a.x == 0.0 && a.y == 0.0) {
-    return vec2(0.0, 0.0);
+  // src/modules/lighting/lights/lighting.ts
+  var MAX_LIGHTS = 3;
+  var COLOR_FACTOR = 255;
+  var lighting = {
+    props: {},
+    uniforms: {},
+    name: "lighting",
+    defines: {
+      MAX_LIGHTS
+    },
+    uniformTypes: {
+      enabled: "i32",
+      lightType: "i32",
+      directionalLightCount: "i32",
+      pointLightCount: "i32",
+      ambientLightColor: "vec3<f32>",
+      // TODO define as arrays once we have appropriate uniformTypes
+      lightColor0: "vec3<f32>",
+      lightPosition0: "vec3<f32>",
+      // TODO - could combine direction and attenuation
+      lightDirection0: "vec3<f32>",
+      lightAttenuation0: "vec3<f32>",
+      lightColor1: "vec3<f32>",
+      lightPosition1: "vec3<f32>",
+      lightDirection1: "vec3<f32>",
+      lightAttenuation1: "vec3<f32>",
+      lightColor2: "vec3<f32>",
+      lightPosition2: "vec3<f32>",
+      lightDirection2: "vec3<f32>",
+      lightAttenuation2: "vec3<f32>"
+    },
+    defaultUniforms: {
+      enabled: 1,
+      lightType: 0 /* POINT */,
+      directionalLightCount: 0,
+      pointLightCount: 0,
+      ambientLightColor: [0.1, 0.1, 0.1],
+      lightColor0: [1, 1, 1],
+      lightPosition0: [1, 1, 2],
+      // TODO - could combine direction and attenuation
+      lightDirection0: [1, 1, 1],
+      lightAttenuation0: [1, 0, 0],
+      lightColor1: [1, 1, 1],
+      lightPosition1: [1, 1, 2],
+      lightDirection1: [1, 1, 1],
+      lightAttenuation1: [1, 0, 0],
+      lightColor2: [1, 1, 1],
+      lightPosition2: [1, 1, 2],
+      lightDirection2: [1, 1, 1],
+      lightAttenuation2: [1, 0, 0]
+    },
+    source: lightingUniformsWGSL,
+    vs: lightingUniformsGLSL,
+    fs: lightingUniformsGLSL,
+    getUniforms: getUniforms2
+  };
+  function getUniforms2(props, prevUniforms = {}) {
+    props = props ? { ...props } : props;
+    if (!props) {
+      return { ...lighting.defaultUniforms };
+    }
+    if (props.lights) {
+      props = { ...props, ...extractLightTypes(props.lights), lights: void 0 };
+    }
+    const { ambientLight, pointLights, directionalLights } = props || {};
+    const hasLights = ambientLight || pointLights && pointLights.length > 0 || directionalLights && directionalLights.length > 0;
+    if (!hasLights) {
+      return { ...lighting.defaultUniforms, enabled: 0 };
+    }
+    const uniforms = {
+      ...lighting.defaultUniforms,
+      ...prevUniforms,
+      ...getLightSourceUniforms({ ambientLight, pointLights, directionalLights })
+    };
+    if (props.enabled !== void 0) {
+      uniforms.enabled = props.enabled ? 1 : 0;
+    }
+    return uniforms;
+  }
+  function getLightSourceUniforms({
+    ambientLight,
+    pointLights = [],
+    directionalLights = []
+  }) {
+    const lightSourceUniforms = {};
+    lightSourceUniforms.ambientLightColor = convertColor(ambientLight);
+    let currentLight = 0;
+    for (const pointLight of pointLights) {
+      lightSourceUniforms.lightType = 0 /* POINT */;
+      const i = currentLight;
+      lightSourceUniforms[`lightColor${i}`] = convertColor(pointLight);
+      lightSourceUniforms[`lightPosition${i}`] = pointLight.position;
+      lightSourceUniforms[`lightAttenuation${i}`] = pointLight.attenuation || [1, 0, 0];
+      currentLight++;
+    }
+    for (const directionalLight of directionalLights) {
+      lightSourceUniforms.lightType = 1 /* DIRECTIONAL */;
+      const i = currentLight;
+      lightSourceUniforms[`lightColor${i}`] = convertColor(directionalLight);
+      lightSourceUniforms[`lightDirection${i}`] = directionalLight.direction;
+      currentLight++;
+    }
+    if (currentLight > MAX_LIGHTS) {
+      import_core3.log.warn("MAX_LIGHTS exceeded")();
+    }
+    lightSourceUniforms.directionalLightCount = directionalLights.length;
+    lightSourceUniforms.pointLightCount = pointLights.length;
+    return lightSourceUniforms;
+  }
+  function extractLightTypes(lights2) {
+    const lightSources = { pointLights: [], directionalLights: [] };
+    for (const light of lights2 || []) {
+      switch (light.type) {
+        case "ambient":
+          lightSources.ambientLight = light;
+          break;
+        case "directional":
+          lightSources.directionalLights?.push(light);
+          break;
+        case "point":
+          lightSources.pointLights?.push(light);
+          break;
+        default:
+      }
+    }
+    return lightSources;
+  }
+  function convertColor(colorDef = {}) {
+    const { color = [0, 0, 0], intensity = 1 } = colorDef;
+    return color.map((component) => component * intensity / COLOR_FACTOR);
   }
 
-  x = -mul_fp64(a, a);
-  s = a;
-  r = a;
+  // src/modules/lighting/no-material/dirlight.ts
+  var SOURCE_WGSL = (
+    /* WGSL */
+    `  
+struct dirlightUniforms {
+  lightDirection: vec3<f32>,
+};
 
-  r = mul_fp64(r, x);
-  t = mul_fp64(r, INVERSE_FACTORIAL_3_FP64);
-  s = sum_fp64(s, t);
+alias DirlightNormal = vec3<f32>;
 
-  r = mul_fp64(r, x);
-  t = mul_fp64(r, INVERSE_FACTORIAL_5_FP64);
-  s = sum_fp64(s, t);
+struct DirlightInputs {
+  normal: DirlightNormal,
+};
 
-  /* keep the following commented code in case we need them
-  for extra accuracy from the Taylor expansion*/
+@binding(1) @group(0) var<uniform> dirlight : dirlightUniforms;
 
-  // r = mul_fp64(r, x);
-  // t = mul_fp64(r, INVERSE_FACTORIAL_7_FP64);
-  // s = sum_fp64(s, t);
+// For vertex
+fn dirlight_setNormal(normal: vec3<f32>) -> DirlightNormal {
+  return normalize(normal);
+}
 
-  // r = mul_fp64(r, x);
-  // t = mul_fp64(r, INVERSE_FACTORIAL_9_FP64);
-  // s = sum_fp64(s, t);
+// Returns color attenuated by angle from light source
+fn dirlight_filterColor(color: vec4<f32>, inputs: DirlightInputs) -> vec4<f32> {
+  // TODO - fix default light direction
+  // let lightDirection = dirlight.lightDirection;
+  let lightDirection = vec3<f32>(1, 1, 1);
+  let d: f32 = abs(dot(inputs.normal, normalize(lightDirection)));
+  return vec4<f32>(color.rgb * d, color.a);
+}
+`
+  );
+  var VS_GLSL = (
+    /* glsl */
+    `out vec3 dirlight_vNormal;
 
-  return s;
+void dirlight_setNormal(vec3 normal) {
+  dirlight_vNormal = normalize(normal);
 }
+`
+  );
+  var FS_GLSL = (
+    /* glsl */
+    `uniform dirlightUniforms {
+  vec3 lightDirection;
+} dirlight;
 
-vec2 cos_taylor_fp64(vec2 a) {
-  vec2 r, s, t, x;
+in vec3 dirlight_vNormal;
 
-  if (a.x == 0.0 && a.y == 0.0) {
-    return vec2(1.0, 0.0);
+// Returns color attenuated by angle from light source
+vec4 dirlight_filterColor(vec4 color) {
+  float d = abs(dot(dirlight_vNormal, normalize(dirlight.lightDirection)));
+  return vec4(color.rgb * d, color.a);
+}
+`
+  );
+  var dirlight = {
+    props: {},
+    uniforms: {},
+    name: "dirlight",
+    dependencies: [],
+    source: SOURCE_WGSL,
+    vs: VS_GLSL,
+    fs: FS_GLSL,
+    // fragmentInputs: [
+    //   {
+    //     name: 'dirlight_vNormal',
+    //     type: 'vec3<f32>'
+    //   }
+    // ],
+    uniformTypes: {
+      lightDirection: "vec3<f32>"
+    },
+    defaultUniforms: {
+      lightDirection: [1, 1, 2]
+    },
+    getUniforms: getUniforms3
+  };
+  function getUniforms3(opts = dirlight.defaultUniforms) {
+    const uniforms = {};
+    if (opts.lightDirection) {
+      uniforms.dirlight_uLightDirection = opts.lightDirection;
+    }
+    return uniforms;
   }
 
-  x = -mul_fp64(a, a);
-  r = x;
-  s = sum_fp64(vec2(1.0, 0.0), r * 0.5);
-
-  r = mul_fp64(r, x);
-  t = mul_fp64(r, INVERSE_FACTORIAL_4_FP64);
-  s = sum_fp64(s, t);
-
-  r = mul_fp64(r, x);
-  t = mul_fp64(r, INVERSE_FACTORIAL_6_FP64);
-  s = sum_fp64(s, t);
+  // src/modules/lighting/phong-material/phong-shaders-glsl.ts
+  var PHONG_VS = (
+    /* glsl */
+    `uniform phongMaterialUniforms {
+  uniform float ambient;
+  uniform float diffuse;
+  uniform float shininess;
+  uniform vec3  specularColor;
+} material;
+`
+  );
+  var PHONG_FS = (
+    /* glsl */
+    `uniform phongMaterialUniforms {
+  uniform float ambient;
+  uniform float diffuse;
+  uniform float shininess;
+  uniform vec3  specularColor;
+} material;
 
-  /* keep the following commented code in case we need them
-  for extra accuracy from the Taylor expansion*/
+vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 view_direction, vec3 normal_worldspace, vec3 color) {
+  vec3 halfway_direction = normalize(light_direction + view_direction);
+  float lambertian = dot(light_direction, normal_worldspace);
+  float specular = 0.0;
+  if (lambertian > 0.0) {
+    float specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);
+    specular = pow(specular_angle, material.shininess);
+  }
+  lambertian = max(lambertian, 0.0);
+  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;
+}
 
-  // r = mul_fp64(r, x);
-  // t = mul_fp64(r, INVERSE_FACTORIAL_8_FP64);
-  // s = sum_fp64(s, t);
+vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
+  vec3 lightColor = surfaceColor;
 
-  // r = mul_fp64(r, x);
-  // t = mul_fp64(r, INVERSE_FACTORIAL_10_FP64);
-  // s = sum_fp64(s, t);
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
 
-  return s;
-}
+  vec3 view_direction = normalize(cameraPosition - position_worldspace);
+  lightColor = material.ambient * surfaceColor * lighting.ambientColor;
 
-void sincos_taylor_fp64(vec2 a, out vec2 sin_t, out vec2 cos_t) {
-  if (a.x == 0.0 && a.y == 0.0) {
-    sin_t = vec2(0.0, 0.0);
-    cos_t = vec2(1.0, 0.0);
+  for (int i = 0; i < lighting.pointLightCount; i++) {
+    PointLight pointLight = lighting_getPointLight(i);
+    vec3 light_position_worldspace = pointLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    float light_attenuation = getPointLightAttenuation(pointLight, distance(light_position_worldspace, position_worldspace));
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color / light_attenuation);
   }
 
-  sin_t = sin_taylor_fp64(a);
-  cos_t = sqrt_fp64(sub_fp64(vec2(1.0, 0.0), mul_fp64(sin_t, sin_t)));
+  int totalLights = min(MAX_LIGHTS, lighting.pointLightCount + lighting.directionalLightCount);
+  for (int i = lighting.pointLightCount; i < totalLights; i++) {
+    DirectionalLight directionalLight = lighting_getDirectionalLight(i);
+    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+  }
+  
+  return lightColor;
 }
+`
+  );
 
-vec2 sin_fp64(vec2 a) {
-    if (a.x == 0.0 && a.y == 0.0) {
-        return vec2(0.0, 0.0);
+  // src/modules/lighting/gouraud-material/gouraud-material.ts
+  var gouraudMaterial = {
+    props: {},
+    name: "gouraudMaterial",
+    // Note these are switched between phong and gouraud
+    vs: PHONG_FS.replace("phongMaterial", "gouraudMaterial"),
+    fs: PHONG_VS.replace("phongMaterial", "gouraudMaterial"),
+    defines: {
+      LIGHTING_VERTEX: 1
+    },
+    dependencies: [lighting],
+    uniformTypes: {
+      ambient: "f32",
+      diffuse: "f32",
+      shininess: "f32",
+      specularColor: "vec3<f32>"
+    },
+    defaultUniforms: {
+      ambient: 0.35,
+      diffuse: 0.6,
+      shininess: 32,
+      specularColor: [0.15, 0.15, 0.15]
+    },
+    getUniforms(props) {
+      const uniforms = { ...props };
+      if (uniforms.specularColor) {
+        uniforms.specularColor = uniforms.specularColor.map((x) => x / 255);
+      }
+      return { ...gouraudMaterial.defaultUniforms, ...uniforms };
     }
+  };
 
-    // 2pi range reduction
-    vec2 z = nint_fp64(div_fp64(a, TWO_PI_FP64));
-    vec2 r = sub_fp64(a, mul_fp64(TWO_PI_FP64, z));
+  // src/modules/lighting/phong-material/phong-shaders-wgsl.ts
+  var PHONG_WGSL = (
+    /* wgsl */
+    `struct phongMaterialUniforms {
+  ambient: f32,
+  diffuse: f32,
+  shininess: f32,
+  specularColor: vec3<f32>,
+};
 
-    vec2 t;
-    float q = floor(r.x / PI_2_FP64.x + 0.5);
-    int j = int(q);
+@binding(2) @group(0) var<uniform> material : phongMaterialUniforms;
 
-    if (j < -2 || j > 2) {
-        return vec2(0.0 / 0.0, 0.0 / 0.0);
-    }
+fn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, view_direction: vec3<f32>, normal_worldspace: vec3<f32>, color: vec3<f32>) -> vec3<f32> {
+  let halfway_direction: vec3<f32> = normalize(light_direction + view_direction);
+  var lambertian: f32 = dot(light_direction, normal_worldspace);
+  var specular: f32 = 0.0;
+  if (lambertian > 0.0) {
+    let specular_angle = max(dot(normal_worldspace, halfway_direction), 0.0);
+    specular = pow(specular_angle, material.shininess);
+  }
+  lambertian = max(lambertian, 0.0);
+  return (lambertian * material.diffuse * surfaceColor + specular * material.specularColor) * color;
+}
 
-    t = sub_fp64(r, mul_fp64(PI_2_FP64, vec2(q, 0.0)));
+fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32> {
+  var lightColor: vec3<f32> = surfaceColor;
 
-    q = floor(t.x / PI_16_FP64.x + 0.5);
-    int k = int(q);
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
 
-    if (k == 0) {
-        if (j == 0) {
-            return sin_taylor_fp64(t);
-        } else if (j == 1) {
-            return cos_taylor_fp64(t);
-        } else if (j == -1) {
-            return -cos_taylor_fp64(t);
-        } else {
-            return -sin_taylor_fp64(t);
-        }
-    }
+  let view_direction: vec3<f32> = normalize(cameraPosition - position_worldspace);
+  lightColor = material.ambient * surfaceColor * lighting.ambientColor;
 
-    int abs_k = int(abs(float(k)));
+  if (lighting.lightType == 0) {
+    let pointLight: PointLight  = lighting_getPointLight(0);
+    let light_position_worldspace: vec3<f32> = pointLight.position;
+    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+  } else if (lighting.lightType == 1) {
+    var directionalLight: DirectionalLight = lighting_getDirectionalLight(0);
+    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+  }
+  
+  return lightColor;
+  /*
+  for (int i = 0; i < MAX_LIGHTS; i++) {
+    if (i >= lighting.pointLightCount) {
+      break;
+    }
+    PointLight pointLight = lighting.pointLight[i];
+    vec3 light_position_worldspace = pointLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, view_direction, normal_worldspace, pointLight.color);
+  }
 
-    if (abs_k > 4) {
-        return vec2(0.0 / 0.0, 0.0 / 0.0);
-    } else {
-        t = sub_fp64(t, mul_fp64(PI_16_FP64, vec2(q, 0.0)));
+  for (int i = 0; i < MAX_LIGHTS; i++) {
+    if (i >= lighting.directionalLightCount) {
+      break;
     }
+    DirectionalLight directionalLight = lighting.directionalLight[i];
+    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, view_direction, normal_worldspace, directionalLight.color);
+  }
+  */
+}
 
-    vec2 u = vec2(0.0, 0.0);
-    vec2 v = vec2(0.0, 0.0);
+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 defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)
-    if (abs(float(abs_k) - 1.0) < 0.5) {
-        u = COS_TABLE_0_FP64;
-        v = SIN_TABLE_0_FP64;
-    } else if (abs(float(abs_k) - 2.0) < 0.5) {
-        u = COS_TABLE_1_FP64;
-        v = SIN_TABLE_1_FP64;
-    } else if (abs(float(abs_k) - 3.0) < 0.5) {
-        u = COS_TABLE_2_FP64;
-        v = SIN_TABLE_2_FP64;
-    } else if (abs(float(abs_k) - 4.0) < 0.5) {
-        u = COS_TABLE_3_FP64;
-        v = SIN_TABLE_3_FP64;
+  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);
+      }
     }
-#else
-    if (abs_k == 1) {
-        u = COS_TABLE_0_FP64;
-        v = SIN_TABLE_0_FP64;
-    } else if (abs_k == 2) {
-        u = COS_TABLE_1_FP64;
-        v = SIN_TABLE_1_FP64;
-    } else if (abs_k == 3) {
-        u = COS_TABLE_2_FP64;
-        v = SIN_TABLE_2_FP64;
-    } else if (abs_k == 4) {
-        u = COS_TABLE_3_FP64;
-        v = SIN_TABLE_3_FP64;
+  }
+  return lightColor;
+}
+`
+  );
+
+  // src/modules/lighting/phong-material/phong-material.ts
+  var phongMaterial = {
+    name: "phongMaterial",
+    dependencies: [lighting],
+    // Note these are switched between phong and gouraud
+    source: PHONG_WGSL,
+    vs: PHONG_VS,
+    fs: PHONG_FS,
+    defines: {
+      LIGHTING_FRAGMENT: 1
+    },
+    uniformTypes: {
+      ambient: "f32",
+      diffuse: "f32",
+      shininess: "f32",
+      specularColor: "vec3<f32>"
+    },
+    defaultUniforms: {
+      ambient: 0.35,
+      diffuse: 0.6,
+      shininess: 32,
+      specularColor: [0.15, 0.15, 0.15]
+    },
+    getUniforms(props) {
+      const uniforms = { ...props };
+      if (uniforms.specularColor) {
+        uniforms.specularColor = uniforms.specularColor.map((x) => x / 255);
+      }
+      return { ...phongMaterial.defaultUniforms, ...uniforms };
     }
-#endif
+  };
 
-    vec2 sin_t, cos_t;
-    sincos_taylor_fp64(t, sin_t, cos_t);
+  // src/modules/lighting/pbr-material/pbr-vertex-glsl.ts
+  var vs2 = (
+    /* glsl */
+    `out vec3 pbr_vPosition;
+out vec2 pbr_vUV;
 
+#ifdef HAS_NORMALS
+# ifdef HAS_TANGENTS
+out mat3 pbr_vTBN;
+# else
+out vec3 pbr_vNormal;
+# endif
+#endif
 
+void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, vec2 uv)
+{
+  vec4 pos = pbrProjection.modelMatrix * position;
+  pbr_vPosition = vec3(pos.xyz) / pos.w;
 
-    vec2 result = vec2(0.0, 0.0);
-    if (j == 0) {
-        if (k > 0) {
-            result = sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
-        } else {
-            result = sub_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
-        }
-    } else if (j == 1) {
-        if (k > 0) {
-            result = sub_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
-        } else {
-            result = sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
-        }
-    } else if (j == -1) {
-        if (k > 0) {
-            result = sub_fp64(mul_fp64(v, sin_t), mul_fp64(u, cos_t));
-        } else {
-            result = -sum_fp64(mul_fp64(v, sin_t), mul_fp64(u, cos_t));
-        }
-    } else {
-        if (k > 0) {
-            result = -sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
-        } else {
-            result = sub_fp64(mul_fp64(v, cos_t), mul_fp64(u, sin_t));
-        }
-    }
+#ifdef HAS_NORMALS
+#ifdef HAS_TANGENTS
+  vec3 normalW = normalize(vec3(pbrProjection.normalMatrix * vec4(normal.xyz, 0.0)));
+  vec3 tangentW = normalize(vec3(pbrProjection.modelMatrix * vec4(tangent.xyz, 0.0)));
+  vec3 bitangentW = cross(normalW, tangentW) * tangent.w;
+  pbr_vTBN = mat3(tangentW, bitangentW, normalW);
+#else // HAS_TANGENTS != 1
+  pbr_vNormal = normalize(vec3(pbrProjection.modelMatrix * vec4(normal.xyz, 0.0)));
+#endif
+#endif
 
-    return result;
+#ifdef HAS_UV
+  pbr_vUV = uv;
+#else
+  pbr_vUV = vec2(0.,0.);
+#endif
 }
+`
+  );
 
-vec2 cos_fp64(vec2 a) {
-    if (a.x == 0.0 && a.y == 0.0) {
-        return vec2(1.0, 0.0);
-    }
+  // src/modules/lighting/pbr-material/pbr-fragment-glsl.ts
+  var fs3 = (
+    /* glsl */
+    `precision highp float;
 
-    // 2pi range reduction
-    vec2 z = nint_fp64(div_fp64(a, TWO_PI_FP64));
-    vec2 r = sub_fp64(a, mul_fp64(TWO_PI_FP64, z));
+uniform pbrMaterialUniforms {
+  // Material is unlit
+  bool unlit;
 
-    vec2 t;
-    float q = floor(r.x / PI_2_FP64.x + 0.5);
-    int j = int(q);
+  // Base color map
+  bool baseColorMapEnabled;
+  vec4 baseColorFactor;
 
-    if (j < -2 || j > 2) {
-        return vec2(0.0 / 0.0, 0.0 / 0.0);
-    }
+  bool normalMapEnabled;  
+  float normalScale; // #ifdef HAS_NORMALMAP
 
-    t = sub_fp64(r, mul_fp64(PI_2_FP64, vec2(q, 0.0)));
+  bool emissiveMapEnabled;
+  vec3 emissiveFactor; // #ifdef HAS_EMISSIVEMAP
 
-    q = floor(t.x / PI_16_FP64.x + 0.5);
-    int k = int(q);
+  vec2 metallicRoughnessValues;
+  bool metallicRoughnessMapEnabled;
 
-    if (k == 0) {
-        if (j == 0) {
-            return cos_taylor_fp64(t);
-        } else if (j == 1) {
-            return -sin_taylor_fp64(t);
-        } else if (j == -1) {
-            return sin_taylor_fp64(t);
-        } else {
-            return -cos_taylor_fp64(t);
-        }
-    }
+  bool occlusionMapEnabled;
+  float occlusionStrength; // #ifdef HAS_OCCLUSIONMAP
+  
+  bool alphaCutoffEnabled;
+  float alphaCutoff; // #ifdef ALPHA_CUTOFF
+  
+  // IBL
+  bool IBLenabled;
+  vec2 scaleIBLAmbient; // #ifdef USE_IBL
+  
+  // debugging flags used for shader output of intermediate PBR variables
+  // #ifdef PBR_DEBUG
+  vec4 scaleDiffBaseMR;
+  vec4 scaleFGDSpec;
+  // #endif
+} pbrMaterial;
 
-    int abs_k = int(abs(float(k)));
+// Samplers
+#ifdef HAS_BASECOLORMAP
+uniform sampler2D pbr_baseColorSampler;
+#endif
+#ifdef HAS_NORMALMAP
+uniform sampler2D pbr_normalSampler;
+#endif
+#ifdef HAS_EMISSIVEMAP
+uniform sampler2D pbr_emissiveSampler;
+#endif
+#ifdef HAS_METALROUGHNESSMAP
+uniform sampler2D pbr_metallicRoughnessSampler;
+#endif
+#ifdef HAS_OCCLUSIONMAP
+uniform sampler2D pbr_occlusionSampler;
+#endif
+#ifdef USE_IBL
+uniform samplerCube pbr_diffuseEnvSampler;
+uniform samplerCube pbr_specularEnvSampler;
+uniform sampler2D pbr_brdfLUT;
+#endif
 
-    if (abs_k > 4) {
-        return vec2(0.0 / 0.0, 0.0 / 0.0);
-    } else {
-        t = sub_fp64(t, mul_fp64(PI_16_FP64, vec2(q, 0.0)));
-    }
+// Inputs from vertex shader
 
-    vec2 u = vec2(0.0, 0.0);
-    vec2 v = vec2(0.0, 0.0);
+in vec3 pbr_vPosition;
+in vec2 pbr_vUV;
 
-#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)
-    if (abs(float(abs_k) - 1.0) < 0.5) {
-        u = COS_TABLE_0_FP64;
-        v = SIN_TABLE_0_FP64;
-    } else if (abs(float(abs_k) - 2.0) < 0.5) {
-        u = COS_TABLE_1_FP64;
-        v = SIN_TABLE_1_FP64;
-    } else if (abs(float(abs_k) - 3.0) < 0.5) {
-        u = COS_TABLE_2_FP64;
-        v = SIN_TABLE_2_FP64;
-    } else if (abs(float(abs_k) - 4.0) < 0.5) {
-        u = COS_TABLE_3_FP64;
-        v = SIN_TABLE_3_FP64;
-    }
+#ifdef HAS_NORMALS
+#ifdef HAS_TANGENTS
+in mat3 pbr_vTBN;
 #else
-    if (abs_k == 1) {
-        u = COS_TABLE_0_FP64;
-        v = SIN_TABLE_0_FP64;
-    } else if (abs_k == 2) {
-        u = COS_TABLE_1_FP64;
-        v = SIN_TABLE_1_FP64;
-    } else if (abs_k == 3) {
-        u = COS_TABLE_2_FP64;
-        v = SIN_TABLE_2_FP64;
-    } else if (abs_k == 4) {
-        u = COS_TABLE_3_FP64;
-        v = SIN_TABLE_3_FP64;
-    }
+in vec3 pbr_vNormal;
+#endif
 #endif
 
-    vec2 sin_t, cos_t;
-    sincos_taylor_fp64(t, sin_t, cos_t);
+// Encapsulate the various inputs used by the various functions in the shading equation
+// We store values in this struct to simplify the integration of alternative implementations
+// of the shading terms, outlined in the Readme.MD Appendix.
+struct PBRInfo {
+  float NdotL;                  // cos angle between normal and light direction
+  float NdotV;                  // cos angle between normal and view direction
+  float NdotH;                  // cos angle between normal and half vector
+  float LdotH;                  // cos angle between light direction and half vector
+  float VdotH;                  // cos angle between view direction and half vector
+  float perceptualRoughness;    // roughness value, as authored by the model creator (input to shader)
+  float metalness;              // metallic value at the surface
+  vec3 reflectance0;            // full reflectance color (normal incidence angle)
+  vec3 reflectance90;           // reflectance color at grazing angle
+  float alphaRoughness;         // roughness mapped to a more linear change in the roughness (proposed by [2])
+  vec3 diffuseColor;            // color contribution from diffuse lighting
+  vec3 specularColor;           // color contribution from specular lighting
+  vec3 n;                       // normal at surface point
+  vec3 v;                       // vector from surface point to camera
+};
 
-    vec2 result = vec2(0.0, 0.0);
-    if (j == 0) {
-        if (k > 0) {
-            result = sub_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
-        } else {
-            result = sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
-        }
-    } else if (j == 1) {
-        if (k > 0) {
-            result = -sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
-        } else {
-            result = sub_fp64(mul_fp64(v, cos_t), mul_fp64(u, sin_t));
-        }
-    } else if (j == -1) {
-        if (k > 0) {
-            result = sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
-        } else {
-            result = sub_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
-        }
-    } else {
-        if (k > 0) {
-            result = sub_fp64(mul_fp64(v, sin_t), mul_fp64(u, cos_t));
-        } else {
-            result = -sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
-        }
-    }
+const float M_PI = 3.141592653589793;
+const float c_MinRoughness = 0.04;
 
-    return result;
+vec4 SRGBtoLINEAR(vec4 srgbIn)
+{
+#ifdef MANUAL_SRGB
+#ifdef SRGB_FAST_APPROXIMATION
+  vec3 linOut = pow(srgbIn.xyz,vec3(2.2));
+#else // SRGB_FAST_APPROXIMATION
+  vec3 bLess = step(vec3(0.04045),srgbIn.xyz);
+  vec3 linOut = mix( srgbIn.xyz/vec3(12.92), pow((srgbIn.xyz+vec3(0.055))/vec3(1.055),vec3(2.4)), bLess );
+#endif //SRGB_FAST_APPROXIMATION
+  return vec4(linOut,srgbIn.w);;
+#else //MANUAL_SRGB
+  return srgbIn;
+#endif //MANUAL_SRGB
 }
 
-vec2 tan_fp64(vec2 a) {
-    vec2 sin_a;
-    vec2 cos_a;
-
-    if (a.x == 0.0 && a.y == 0.0) {
-        return vec2(0.0, 0.0);
-    }
-
-    // 2pi range reduction
-    vec2 z = nint_fp64(div_fp64(a, TWO_PI_FP64));
-    vec2 r = sub_fp64(a, mul_fp64(TWO_PI_FP64, z));
-
-    vec2 t;
-    float q = floor(r.x / PI_2_FP64.x + 0.5);
-    int j = int(q);
+// Find the normal for this fragment, pulling either from a predefined normal map
+// or from the interpolated mesh normal and tangent attributes.
+vec3 getNormal()
+{
+  // Retrieve the tangent space matrix
+#ifndef HAS_TANGENTS
+  vec3 pos_dx = dFdx(pbr_vPosition);
+  vec3 pos_dy = dFdy(pbr_vPosition);
+  vec3 tex_dx = dFdx(vec3(pbr_vUV, 0.0));
+  vec3 tex_dy = dFdy(vec3(pbr_vUV, 0.0));
+  vec3 t = (tex_dy.t * pos_dx - tex_dx.t * pos_dy) / (tex_dx.s * tex_dy.t - tex_dy.s * tex_dx.t);
 
+#ifdef HAS_NORMALS
+  vec3 ng = normalize(pbr_vNormal);
+#else
+  vec3 ng = cross(pos_dx, pos_dy);
+#endif
 
-    if (j < -2 || j > 2) {
-        return vec2(0.0 / 0.0, 0.0 / 0.0);
-    }
+  t = normalize(t - ng * dot(ng, t));
+  vec3 b = normalize(cross(ng, t));
+  mat3 tbn = mat3(t, b, ng);
+#else // HAS_TANGENTS
+  mat3 tbn = pbr_vTBN;
+#endif
 
-    t = sub_fp64(r, mul_fp64(PI_2_FP64, vec2(q, 0.0)));
+#ifdef HAS_NORMALMAP
+  vec3 n = texture(pbr_normalSampler, pbr_vUV).rgb;
+  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(pbrMaterial.normalScale, pbrMaterial.normalScale, 1.0)));
+#else
+  // The tbn matrix is linearly interpolated, so we need to re-normalize
+  vec3 n = normalize(tbn[2].xyz);
+#endif
 
-    q = floor(t.x / PI_16_FP64.x + 0.5);
-    int k = int(q);
-    int abs_k = int(abs(float(k)));
+  return n;
+}
 
-    // We just can't get PI/16 * 3.0 very accurately.
-    // so let's just store it
-    if (abs_k > 4) {
-        return vec2(0.0 / 0.0, 0.0 / 0.0);
-    } else {
-        t = sub_fp64(t, mul_fp64(PI_16_FP64, vec2(q, 0.0)));
-    }
+// Calculation of the lighting contribution from an optional Image Based Light source.
+// Precomputed Environment Maps are required uniform inputs and are computed as outlined in [1].
+// See our README.md on Environment Maps [3] for additional discussion.
+#ifdef USE_IBL
+vec3 getIBLContribution(PBRInfo pbrInfo, vec3 n, vec3 reflection)
+{
+  float mipCount = 9.0; // resolution of 512x512
+  float lod = (pbrInfo.perceptualRoughness * mipCount);
+  // retrieve a scale and bias to F0. See [1], Figure 3
+  vec3 brdf = SRGBtoLINEAR(texture(pbr_brdfLUT,
+    vec2(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness))).rgb;
+  vec3 diffuseLight = SRGBtoLINEAR(texture(pbr_diffuseEnvSampler, n)).rgb;
 
+#ifdef USE_TEX_LOD
+  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection, lod)).rgb;
+#else
+  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection)).rgb;
+#endif
 
-    vec2 u = vec2(0.0, 0.0);
-    vec2 v = vec2(0.0, 0.0);
+  vec3 diffuse = diffuseLight * pbrInfo.diffuseColor;
+  vec3 specular = specularLight * (pbrInfo.specularColor * brdf.x + brdf.y);
 
-    vec2 sin_t, cos_t;
-    vec2 s, c;
-    sincos_taylor_fp64(t, sin_t, cos_t);
+  // For presentation, this allows us to disable IBL terms
+  diffuse *= pbrMaterial.scaleIBLAmbient.x;
+  specular *= pbrMaterial.scaleIBLAmbient.y;
 
-    if (k == 0) {
-        s = sin_t;
-        c = cos_t;
-    } else {
-#if defined(NVIDIA_FP64_WORKAROUND) || defined(INTEL_FP64_WORKAROUND)
-        if (abs(float(abs_k) - 1.0) < 0.5) {
-            u = COS_TABLE_0_FP64;
-            v = SIN_TABLE_0_FP64;
-        } else if (abs(float(abs_k) - 2.0) < 0.5) {
-            u = COS_TABLE_1_FP64;
-            v = SIN_TABLE_1_FP64;
-        } else if (abs(float(abs_k) - 3.0) < 0.5) {
-            u = COS_TABLE_2_FP64;
-            v = SIN_TABLE_2_FP64;
-        } else if (abs(float(abs_k) - 4.0) < 0.5) {
-            u = COS_TABLE_3_FP64;
-            v = SIN_TABLE_3_FP64;
-        }
-#else
-        if (abs_k == 1) {
-            u = COS_TABLE_0_FP64;
-            v = SIN_TABLE_0_FP64;
-        } else if (abs_k == 2) {
-            u = COS_TABLE_1_FP64;
-            v = SIN_TABLE_1_FP64;
-        } else if (abs_k == 3) {
-            u = COS_TABLE_2_FP64;
-            v = SIN_TABLE_2_FP64;
-        } else if (abs_k == 4) {
-            u = COS_TABLE_3_FP64;
-            v = SIN_TABLE_3_FP64;
-        }
+  return diffuse + specular;
+}
 #endif
-        if (k > 0) {
-            s = sum_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
-            c = sub_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
-        } else {
-            s = sub_fp64(mul_fp64(u, sin_t), mul_fp64(v, cos_t));
-            c = sum_fp64(mul_fp64(u, cos_t), mul_fp64(v, sin_t));
-        }
-    }
 
-    if (j == 0) {
-        sin_a = s;
-        cos_a = c;
-    } else if (j == 1) {
-        sin_a = c;
-        cos_a = -s;
-    } else if (j == -1) {
-        sin_a = -c;
-        cos_a = s;
-    } else {
-        sin_a = -s;
-        cos_a = -c;
-    }
-    return div_fp64(sin_a, cos_a);
+// Basic Lambertian diffuse
+// Implementation from Lambert's Photometria https://archive.org/details/lambertsphotome00lambgoog
+// See also [1], Equation 1
+vec3 diffuse(PBRInfo pbrInfo)
+{
+  return pbrInfo.diffuseColor / M_PI;
 }
 
-vec2 radians_fp64(vec2 degree) {
-  return mul_fp64(degree, PI_180_FP64);
+// The following equation models the Fresnel reflectance term of the spec equation (aka F())
+// Implementation of fresnel from [4], Equation 15
+vec3 specularReflection(PBRInfo pbrInfo)
+{
+  return pbrInfo.reflectance0 +
+    (pbrInfo.reflectance90 - pbrInfo.reflectance0) *
+    pow(clamp(1.0 - pbrInfo.VdotH, 0.0, 1.0), 5.0);
 }
 
-vec2 mix_fp64(vec2 a, vec2 b, float x) {
-  vec2 range = sub_fp64(b, a);
-  return sum_fp64(a, mul_fp64(range, vec2(x, 0.0)));
-}
+// This calculates the specular geometric attenuation (aka G()),
+// where rougher material will reflect less light back to the viewer.
+// This implementation is based on [1] Equation 4, and we adopt their modifications to
+// alphaRoughness as input as originally proposed in [2].
+float geometricOcclusion(PBRInfo pbrInfo)
+{
+  float NdotL = pbrInfo.NdotL;
+  float NdotV = pbrInfo.NdotV;
+  float r = pbrInfo.alphaRoughness;
 
-// Vector functions
-// vec2 functions
-void vec2_sum_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {
-    out_val[0] = sum_fp64(a[0], b[0]);
-    out_val[1] = sum_fp64(a[1], b[1]);
+  float attenuationL = 2.0 * NdotL / (NdotL + sqrt(r * r + (1.0 - r * r) * (NdotL * NdotL)));
+  float attenuationV = 2.0 * NdotV / (NdotV + sqrt(r * r + (1.0 - r * r) * (NdotV * NdotV)));
+  return attenuationL * attenuationV;
 }
 
-void vec2_sub_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {
-    out_val[0] = sub_fp64(a[0], b[0]);
-    out_val[1] = sub_fp64(a[1], b[1]);
+// The following equation(s) model the distribution of microfacet normals across
+// the area being drawn (aka D())
+// Implementation from "Average Irregularity Representation of a Roughened Surface
+// for Ray Reflection" by T. S. Trowbridge, and K. P. Reitz
+// Follows the distribution function recommended in the SIGGRAPH 2013 course notes
+// from EPIC Games [1], Equation 3.
+float microfacetDistribution(PBRInfo pbrInfo)
+{
+  float roughnessSq = pbrInfo.alphaRoughness * pbrInfo.alphaRoughness;
+  float f = (pbrInfo.NdotH * roughnessSq - pbrInfo.NdotH) * pbrInfo.NdotH + 1.0;
+  return roughnessSq / (M_PI * f * f);
 }
 
-void vec2_mul_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {
-    out_val[0] = mul_fp64(a[0], b[0]);
-    out_val[1] = mul_fp64(a[1], b[1]);
+void PBRInfo_setAmbientLight(inout PBRInfo pbrInfo) {
+  pbrInfo.NdotL = 1.0;
+  pbrInfo.NdotH = 0.0;
+  pbrInfo.LdotH = 0.0;
+  pbrInfo.VdotH = 1.0;
 }
 
-void vec2_div_fp64(vec2 a[2], vec2 b[2], out vec2 out_val[2]) {
-    out_val[0] = div_fp64(a[0], b[0]);
-    out_val[1] = div_fp64(a[1], b[1]);
-}
+void PBRInfo_setDirectionalLight(inout PBRInfo pbrInfo, vec3 lightDirection) {
+  vec3 n = pbrInfo.n;
+  vec3 v = pbrInfo.v;
+  vec3 l = normalize(lightDirection);             // Vector from surface point to light
+  vec3 h = normalize(l+v);                        // Half vector between both l and v
 
-void vec2_mix_fp64(vec2 x[2], vec2 y[2], float a, out vec2 out_val[2]) {
-  vec2 range[2];
-  vec2_sub_fp64(y, x, range);
-  vec2 portion[2];
-  portion[0] = range[0] * a;
-  portion[1] = range[1] * a;
-  vec2_sum_fp64(x, portion, out_val);
+  pbrInfo.NdotL = clamp(dot(n, l), 0.001, 1.0);
+  pbrInfo.NdotH = clamp(dot(n, h), 0.0, 1.0);
+  pbrInfo.LdotH = clamp(dot(l, h), 0.0, 1.0);
+  pbrInfo.VdotH = clamp(dot(v, h), 0.0, 1.0);
 }
 
-vec2 vec2_length_fp64(vec2 x[2]) {
-  return sqrt_fp64(sum_fp64(mul_fp64(x[0], x[0]), mul_fp64(x[1], x[1])));
+void PBRInfo_setPointLight(inout PBRInfo pbrInfo, PointLight pointLight) {
+  vec3 light_direction = normalize(pointLight.position - pbr_vPosition);
+  PBRInfo_setDirectionalLight(pbrInfo, light_direction);
 }
 
-void vec2_normalize_fp64(vec2 x[2], out vec2 out_val[2]) {
-  vec2 length = vec2_length_fp64(x);
-  vec2 length_vec2[2];
-  length_vec2[0] = length;
-  length_vec2[1] = length;
+vec3 calculateFinalColor(PBRInfo pbrInfo, vec3 lightColor) {
+  // Calculate the shading terms for the microfacet specular shading model
+  vec3 F = specularReflection(pbrInfo);
+  float G = geometricOcclusion(pbrInfo);
+  float D = microfacetDistribution(pbrInfo);
 
-  vec2_div_fp64(x, length_vec2, out_val);
+  // Calculation of analytical lighting contribution
+  vec3 diffuseContrib = (1.0 - F) * diffuse(pbrInfo);
+  vec3 specContrib = F * G * D / (4.0 * pbrInfo.NdotL * pbrInfo.NdotV);
+  // Obtain final intensity as reflectance (BRDF) scaled by the energy of the light (cosine law)
+  return pbrInfo.NdotL * lightColor * (diffuseContrib + specContrib);
 }
 
-vec2 vec2_distance_fp64(vec2 x[2], vec2 y[2]) {
-  vec2 diff[2];
-  vec2_sub_fp64(x, y, diff);
-  return vec2_length_fp64(diff);
-}
+vec4 pbr_filterColor(vec4 colorUnused)
+{
+  // The albedo may be defined from a base texture or a flat color
+#ifdef HAS_BASECOLORMAP
+  vec4 baseColor = SRGBtoLINEAR(texture(pbr_baseColorSampler, pbr_vUV)) * pbrMaterial.baseColorFactor;
+#else
+  vec4 baseColor = pbrMaterial.baseColorFactor;
+#endif
 
-vec2 vec2_dot_fp64(vec2 a[2], vec2 b[2]) {
-  vec2 v[2];
+#ifdef ALPHA_CUTOFF
+  if (baseColor.a < pbrMaterial.alphaCutoff) {
+    discard;
+  }
+#endif
+
+  vec3 color = vec3(0, 0, 0);
+
+  if(pbrMaterial.unlit){
+    color.rgb = baseColor.rgb;
+  }
+  else{
+    // Metallic and Roughness material properties are packed together
+    // In glTF, these factors can be specified by fixed scalar values
+    // or from a metallic-roughness map
+    float perceptualRoughness = pbrMaterial.metallicRoughnessValues.y;
+    float metallic = pbrMaterial.metallicRoughnessValues.x;
+#ifdef HAS_METALROUGHNESSMAP
+    // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.
+    // This layout intentionally reserves the 'r' channel for (optional) occlusion map data
+    vec4 mrSample = texture(pbr_metallicRoughnessSampler, pbr_vUV);
+    perceptualRoughness = mrSample.g * perceptualRoughness;
+    metallic = mrSample.b * metallic;
+#endif
+    perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);
+    metallic = clamp(metallic, 0.0, 1.0);
+    // Roughness is authored as perceptual roughness; as is convention,
+    // convert to material roughness by squaring the perceptual roughness [2].
+    float alphaRoughness = perceptualRoughness * perceptualRoughness;
 
-  v[0] = mul_fp64(a[0], b[0]);
-  v[1] = mul_fp64(a[1], b[1]);
+    vec3 f0 = vec3(0.04);
+    vec3 diffuseColor = baseColor.rgb * (vec3(1.0) - f0);
+    diffuseColor *= 1.0 - metallic;
+    vec3 specularColor = mix(f0, baseColor.rgb, metallic);
 
-  return sum_fp64(v[0], v[1]);
-}
+    // Compute reflectance.
+    float reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);
 
-// vec3 functions
-void vec3_sub_fp64(vec2 a[3], vec2 b[3], out vec2 out_val[3]) {
-  for (int i = 0; i < 3; i++) {
-    out_val[i] = sum_fp64(a[i], b[i]);
-  }
-}
+    // For typical incident reflectance range (between 4% to 100%) set the grazing
+    // reflectance to 100% for typical fresnel effect.
+    // For very low reflectance range on highly diffuse objects (below 4%),
+    // incrementally reduce grazing reflecance to 0%.
+    float reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);
+    vec3 specularEnvironmentR0 = specularColor.rgb;
+    vec3 specularEnvironmentR90 = vec3(1.0, 1.0, 1.0) * reflectance90;
 
-void vec3_sum_fp64(vec2 a[3], vec2 b[3], out vec2 out_val[3]) {
-  for (int i = 0; i < 3; i++) {
-    out_val[i] = sum_fp64(a[i], b[i]);
-  }
-}
+    vec3 n = getNormal();                          // normal at surface point
+    vec3 v = normalize(pbrProjection.camera - pbr_vPosition);  // Vector from surface point to camera
 
-vec2 vec3_length_fp64(vec2 x[3]) {
-  return sqrt_fp64(sum_fp64(sum_fp64(mul_fp64(x[0], x[0]), mul_fp64(x[1], x[1])),
-    mul_fp64(x[2], x[2])));
-}
+    float NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);
+    vec3 reflection = -normalize(reflect(v, n));
 
-vec2 vec3_distance_fp64(vec2 x[3], vec2 y[3]) {
-  vec2 diff[3];
-  vec3_sub_fp64(x, y, diff);
-  return vec3_length_fp64(diff);
-}
+    PBRInfo pbrInfo = PBRInfo(
+      0.0, // NdotL
+      NdotV,
+      0.0, // NdotH
+      0.0, // LdotH
+      0.0, // VdotH
+      perceptualRoughness,
+      metallic,
+      specularEnvironmentR0,
+      specularEnvironmentR90,
+      alphaRoughness,
+      diffuseColor,
+      specularColor,
+      n,
+      v
+    );
 
-// vec4 functions
-void vec4_fp64(vec4 a, out vec2 out_val[4]) {
-  out_val[0].x = a[0];
-  out_val[0].y = 0.0;
 
-  out_val[1].x = a[1];
-  out_val[1].y = 0.0;
+#ifdef USE_LIGHTS
+    // Apply ambient light
+    PBRInfo_setAmbientLight(pbrInfo);
+    color += calculateFinalColor(pbrInfo, lighting.ambientColor);
 
-  out_val[2].x = a[2];
-  out_val[2].y = 0.0;
+    // Apply directional light
+    for(int i = 0; i < lighting.directionalLightCount; i++) {
+      if (i < lighting.directionalLightCount) {
+        PBRInfo_setDirectionalLight(pbrInfo, lighting_getDirectionalLight(i).direction);
+        color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
+      }
+    }
 
-  out_val[3].x = a[3];
-  out_val[3].y = 0.0;
-}
+    // Apply point light
+    for(int i = 0; i < lighting.pointLightCount; i++) {
+      if (i < lighting.pointLightCount) {
+        PBRInfo_setPointLight(pbrInfo, lighting_getPointLight(i));
+        float attenuation = getPointLightAttenuation(lighting_getPointLight(i), distance(lighting_getPointLight(i).position, pbr_vPosition));
+        color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
+      }
+    }
+#endif
 
-void vec4_scalar_mul_fp64(vec2 a[4], vec2 b, out vec2 out_val[4]) {
-  out_val[0] = mul_fp64(a[0], b);
-  out_val[1] = mul_fp64(a[1], b);
-  out_val[2] = mul_fp64(a[2], b);
-  out_val[3] = mul_fp64(a[3], b);
-}
+    // Calculate lighting contribution from image based lighting source (IBL)
+#ifdef USE_IBL
+    if (pbrMaterial.IBLenabled) {
+      color += getIBLContribution(pbrInfo, n, reflection);
+    }
+#endif
 
-void vec4_sum_fp64(vec2 a[4], vec2 b[4], out vec2 out_val[4]) {
-  for (int i = 0; i < 4; i++) {
-    out_val[i] = sum_fp64(a[i], b[i]);
-  }
-}
+ // Apply optional PBR terms for additional (optional) shading
+#ifdef HAS_OCCLUSIONMAP
+    if (pbrMaterial.occlusionMapEnabled) {
+      float ao = texture(pbr_occlusionSampler, pbr_vUV).r;
+      color = mix(color, color * ao, pbrMaterial.occlusionStrength);
+    }
+#endif
 
-void vec4_dot_fp64(vec2 a[4], vec2 b[4], out vec2 out_val) {
-  vec2 v[4];
+#ifdef HAS_EMISSIVEMAP
+    if (pbrMaterial.emissiveMapEnabled) {
+      vec3 emissive = SRGBtoLINEAR(texture(pbr_emissiveSampler, pbr_vUV)).rgb * pbrMaterial.emissiveFactor;
+      color += emissive;
+    }
+#endif
 
-  v[0] = mul_fp64(a[0], b[0]);
-  v[1] = mul_fp64(a[1], b[1]);
-  v[2] = mul_fp64(a[2], b[2]);
-  v[3] = mul_fp64(a[3], b[3]);
+    // This section uses mix to override final color for reference app visualization
+    // of various parameters in the lighting equation.
+#ifdef PBR_DEBUG
+    // TODO: Figure out how to debug multiple lights
 
-  out_val = sum_fp64(sum_fp64(v[0], v[1]), sum_fp64(v[2], v[3]));
-}
+    // color = mix(color, F, pbr_scaleFGDSpec.x);
+    // color = mix(color, vec3(G), pbr_scaleFGDSpec.y);
+    // color = mix(color, vec3(D), pbr_scaleFGDSpec.z);
+    // color = mix(color, specContrib, pbr_scaleFGDSpec.w);
 
-void mat4_vec4_mul_fp64(vec2 b[16], vec2 a[4], out vec2 out_val[4]) {
-  vec2 tmp[4];
+    // color = mix(color, diffuseContrib, pbr_scaleDiffBaseMR.x);
+    color = mix(color, baseColor.rgb, pbrMaterial.scaleDiffBaseMR.y);
+    color = mix(color, vec3(metallic), pbrMaterial.scaleDiffBaseMR.z);
+    color = mix(color, vec3(perceptualRoughness), pbrMaterial.scaleDiffBaseMR.w);
+#endif
 
-  for (int i = 0; i < 4; i++)
-  {
-    for (int j = 0; j < 4; j++)
-    {
-      tmp[j] = b[j + i * 4];
-    }
-    vec4_dot_fp64(a, tmp, out_val[i]);
   }
+
+  return vec4(pow(color,vec3(1.0/2.2)), baseColor.a);
 }
 `
   );
 
-  // src/modules-webgl1/math/fp64/fp64.ts
-  var CONST_UNIFORMS = {
-    // Used in LUMA_FP64_CODE_ELIMINATION_WORKAROUND
-    ONE: 1
-  };
-  function getUniforms4() {
-    return CONST_UNIFORMS;
-  }
-  var fp64arithmetic = {
-    name: "fp64-arithmetic",
-    vs: fp64arithmeticShader,
-    getUniforms: getUniforms4,
-    fp64ify,
-    fp64LowPart,
-    fp64ifyMatrix4
+  // src/modules/lighting/pbr-material/pbr-projection.ts
+  var uniformBlock = (
+    /* glsl */
+    `uniform pbrProjectionUniforms {
+  mat4 modelViewProjectionMatrix;
+  mat4 modelMatrix;
+  mat4 normalMatrix;
+  vec3 camera;
+} pbrProjection;
+`
+  );
+  var pbrProjection = {
+    name: "pbrProjection",
+    vs: uniformBlock,
+    fs: uniformBlock,
+    // TODO why is this needed?
+    getUniforms: (props) => props,
+    uniformTypes: {
+      modelViewProjectionMatrix: "mat4x4<f32>",
+      modelMatrix: "mat4x4<f32>",
+      normalMatrix: "mat4x4<f32>",
+      camera: "vec3<i32>"
+    }
   };
-  var fp64 = {
-    name: "fp64",
-    vs: fp64functionShader,
-    dependencies: [fp64arithmetic],
-    // Additional Functions
-    fp64ify,
-    fp64LowPart,
-    fp64ifyMatrix4
+
+  // src/modules/lighting/pbr-material/pbr-material.ts
+  var pbrMaterial = {
+    props: {},
+    uniforms: {},
+    name: "pbrMaterial",
+    dependencies: [lighting, pbrProjection],
+    vs: vs2,
+    fs: fs3,
+    defines: {
+      LIGHTING_FRAGMENT: 1
+      // TODO defining these as 0 breaks shader
+      // HAS_NORMALMAP: 0
+      // HAS_EMISSIVEMAP: 0,
+      // HAS_OCCLUSIONMAP: 0,
+      // HAS_BASECOLORMAP: 0,
+      // HAS_METALROUGHNESSMAP: 0,
+      // ALPHA_CUTOFF: 0
+      // USE_IBL: 0
+      // PBR_DEBUG: 0
+    },
+    getUniforms: (props) => props,
+    uniformTypes: {
+      // Material is unlit
+      unlit: "i32",
+      // Base color map
+      baseColorMapEnabled: "i32",
+      baseColorFactor: "vec4<f32>",
+      normalMapEnabled: "i32",
+      normalScale: "f32",
+      // #ifdef HAS_NORMALMAP
+      emissiveMapEnabled: "i32",
+      emissiveFactor: "vec3<f32>",
+      // #ifdef HAS_EMISSIVEMAP
+      metallicRoughnessValues: "vec2<f32>",
+      metallicRoughnessMapEnabled: "i32",
+      occlusionMapEnabled: "i32",
+      occlusionStrength: "f32",
+      // #ifdef HAS_OCCLUSIONMAP
+      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>"
+    }
   };
 
   // src/modules-webgl1/geometry/geometry.ts
@@ -8865,7 +8875,7 @@ vec3 geometry_getNormal() {
     projectionMatrix: IDENTITY_MATRIX2,
     cameraPositionWorld: [0, 0, 0]
   };
-  function getUniforms5(opts = DEFAULT_MODULE_OPTIONS, prevUniforms = {}) {
+  function getUniforms4(opts = DEFAULT_MODULE_OPTIONS, prevUniforms = {}) {
     const uniforms = {};
     if (opts.modelMatrix !== void 0) {
       uniforms.modelMatrix = opts.modelMatrix;
@@ -8958,7 +8968,7 @@ vec4 project_to_clipspace(vec3 position) {
 ${common}`;
   var project = {
     name: "project",
-    getUniforms: getUniforms5,
+    getUniforms: getUniforms4,
     vs: vs4,
     fs: fs5
   };
@@ -9039,7 +9049,7 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
     lightSourceUniforms.lighting_uDirectionalLightCount = directionalLights.length;
     return lightSourceUniforms;
   }
-  function getUniforms6(opts = INITIAL_MODULE_OPTIONS) {
+  function getUniforms5(opts = INITIAL_MODULE_OPTIONS) {
     if ("lightSources" in opts) {
       const { ambientLight, pointLights, directionalLights } = opts.lightSources || {};
       const hasLights = ambientLight || pointLights && pointLights.length > 0 || directionalLights && directionalLights.length > 0;
@@ -9070,7 +9080,7 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
           default:
         }
       }
-      return getUniforms6({ lightSources });
+      return getUniforms5({ lightSources });
     }
     return {};
   }
@@ -9078,7 +9088,7 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
     name: "lights",
     vs: lightingShader,
     fs: lightingShader,
-    getUniforms: getUniforms6,
+    getUniforms: getUniforms5,
     defines: {
       MAX_LIGHTS: 3
     }
@@ -9088,7 +9098,7 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
   var DEFAULT_MODULE_OPTIONS2 = {
     lightDirection: new Float32Array([1, 1, 2])
   };
-  function getUniforms7(opts = DEFAULT_MODULE_OPTIONS2) {
+  function getUniforms6(opts = DEFAULT_MODULE_OPTIONS2) {
     const uniforms = {};
     if (opts.lightDirection) {
       uniforms.dirlight_uLightDirection = opts.lightDirection;
@@ -9113,7 +9123,7 @@ vec4 dirlight_filterColor(vec4 color) {
     name: "dirlight",
     // vs // TODO - reuse normal from geometry module
     fs: fs6,
-    getUniforms: getUniforms7,
+    getUniforms: getUniforms6,
     dependencies: [project]
   };
 
@@ -9207,7 +9217,7 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
       lighting_uSpecularColor: specularColor.map((x) => x / 255)
     };
   }
-  function getUniforms8(opts = INITIAL_MODULE_OPTIONS2) {
+  function getUniforms7(opts = INITIAL_MODULE_OPTIONS2) {
     if (!("material" in opts)) {
       return {};
     }
@@ -9224,7 +9234,7 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
     defines: {
       LIGHTING_VERTEX: 1
     },
-    getUniforms: getUniforms8
+    getUniforms: getUniforms7
   };
   var phongLighting = {
     name: "phong-lighting",
@@ -9233,7 +9243,7 @@ vec3 lighting_getSpecularLightColor(vec3 cameraPosition, vec3 position_worldspac
     defines: {
       LIGHTING_FRAGMENT: 1
     },
-    getUniforms: getUniforms8
+    getUniforms: getUniforms7
   };
 
   // src/modules-webgl1/lighting/pbr/pbr-vertex-glsl.ts