@luma.gl/engine 9.1.0-alpha.1 → 9.1.0-alpha.2

package/dist/dist.dev.js

@@ -235,15 +235,15 @@ var __exports__ = (() => {
       return this.values[this.endIndex];
     }
     _calculateKeys(time) {
-      let index2 = 0;
+      let index = 0;
       const numKeys = this.times.length;
-      for (index2 = 0; index2 < numKeys - 2; ++index2) {
-        if (this.times[index2 + 1] > time) {
+      for (index = 0; index < numKeys - 2; ++index) {
+        if (this.times[index + 1] > time) {
           break;
         }
       }
-      this.startIndex = index2;
-      this.endIndex = index2 + 1;
+      this.startIndex = index;
+      this.endIndex = index + 1;
       const startTime = this.times[this.startIndex];
       const endTime = this.times[this.endIndex];
       this.factor = Math.min(Math.max(0, (time - startTime) / (endTime - startTime)), 1);
@@ -902,23 +902,6 @@ var __exports__ = (() => {
     }
     return propValidators;
   }
-  function getValidatedProperties(properties, propValidators, errorMessage) {
-    const validated = {};
-    for (const [key, propsValidator] of Object.entries(propValidators)) {
-      if (properties && key in properties && !propsValidator.private) {
-        if (propsValidator.validate) {
-          assert(
-            propsValidator.validate(properties[key], propsValidator),
-            `${errorMessage}: invalid ${key}`
-          );
-        }
-        validated[key] = properties[key];
-      } else {
-        validated[key] = propsValidator.value;
-      }
-    }
-    return validated;
-  }
   function makePropValidator(propType) {
     let type = getTypeOf(propType);
     if (type !== "object") {
@@ -1063,148 +1046,63 @@ var __exports__ = (() => {
     return source;
   }
 
-  // ../shadertools/src/lib/shader-module/shader-module-instance.ts
-  var index = 1;
-  var ShaderModuleInstance = class {
-    name;
-    vs;
-    fs;
-    getModuleUniforms;
-    dependencies;
-    deprecations;
-    defines;
-    injections;
-    uniforms = {};
-    uniformTypes = {};
-    static instantiateModules(modules) {
-      return modules.map((module) => {
-        if (module instanceof ShaderModuleInstance) {
-          return module;
-        }
-        assert(
-          typeof module !== "string",
-          `Shader module use by name is deprecated. Import shader module '${JSON.stringify(
-            module
-          )}' and use it directly.`
-        );
-        if (!module.name) {
-          console.warn("shader module has no name");
-          module.name = `shader-module-${index++}`;
-        }
-        const moduleObject = new ShaderModuleInstance(module);
-        moduleObject.dependencies = ShaderModuleInstance.instantiateModules(
-          module.dependencies || []
-        );
-        return moduleObject;
-      });
-    }
-    constructor(props) {
-      const {
-        name,
-        vs,
-        fs,
-        dependencies = [],
-        uniformPropTypes = {},
-        getUniforms,
-        deprecations = [],
-        defines = {},
-        inject = {}
-      } = props;
-      assert(typeof name === "string");
-      this.name = name;
-      this.vs = vs;
-      this.fs = fs;
-      this.getModuleUniforms = getUniforms;
-      this.dependencies = ShaderModuleInstance.instantiateModules(dependencies);
-      this.deprecations = this._parseDeprecationDefinitions(deprecations);
-      this.defines = defines;
-      this.injections = normalizeInjections(inject);
-      if (uniformPropTypes) {
-        this.uniforms = makePropValidators(uniformPropTypes);
-      }
-    }
-    // Extracts the source code chunk for the specified shader type from the named shader module
-    getModuleSource(stage) {
-      let moduleSource;
-      switch (stage) {
-        case "vertex":
-          moduleSource = this.vs || "";
-          break;
-        case "fragment":
-          moduleSource = this.fs || "";
-          break;
-        default:
-          assert(false);
-      }
-      const moduleName = this.name.toUpperCase().replace(/[^0-9a-z]/gi, "_");
-      return `// ----- MODULE ${this.name} ---------------
-
-#define MODULE_${moduleName}
-${moduleSource}
-
-`;
-    }
-    getUniforms(userProps, uniforms) {
-      if (this.getModuleUniforms) {
-        return this.getModuleUniforms(userProps, uniforms);
-      }
-      return getValidatedProperties(userProps, this.uniforms, this.name);
-    }
-    getDefines() {
-      return this.defines;
-    }
-    // Warn about deprecated uniforms or functions
-    checkDeprecations(shaderSource, log6) {
-      this.deprecations.forEach((def) => {
-        if (def.regex?.test(shaderSource)) {
-          if (def.deprecated) {
-            log6.deprecated(def.old, def.new)();
-          } else {
-            log6.removed(def.old, def.new)();
-          }
-        }
-      });
+  // ../shadertools/src/lib/shader-module/shader-module.ts
+  function initializeShaderModules(modules) {
+    modules.map((module) => initializeShaderModule(module));
+  }
+  function initializeShaderModule(module) {
+    if (module.instance) {
+      return;
     }
-    _parseDeprecationDefinitions(deprecations) {
-      deprecations.forEach((def) => {
-        switch (def.type) {
-          case "function":
-            def.regex = new RegExp(`\\b${def.old}\\(`);
-            break;
-          default:
-            def.regex = new RegExp(`${def.type} ${def.old};`);
-        }
-      });
-      return deprecations;
+    initializeShaderModules(module.dependencies || []);
+    const {
+      uniformPropTypes = {},
+      deprecations = [],
+      // defines = {},
+      inject = {}
+    } = module;
+    const instance = {
+      normalizedInjections: normalizeInjections(inject),
+      parsedDeprecations: parseDeprecationDefinitions(deprecations)
+    };
+    if (uniformPropTypes) {
+      instance.propValidators = makePropValidators(uniformPropTypes);
     }
-    _defaultGetUniforms(opts = {}) {
-      const uniforms = {};
-      const propTypes = this.uniforms;
-      for (const key in propTypes) {
-        const propDef = propTypes[key];
-        if (key in opts && !propDef.private) {
-          if (propDef.validate) {
-            assert(propDef.validate(opts[key], propDef), `${this.name}: invalid ${key}`);
-          }
-          uniforms[key] = opts[key];
+    module.instance = instance;
+  }
+  function checkShaderModuleDeprecations(shaderModule, shaderSource, log6) {
+    shaderModule.deprecations?.forEach((def) => {
+      if (def.regex?.test(shaderSource)) {
+        if (def.deprecated) {
+          log6.deprecated(def.old, def.new)();
         } else {
-          uniforms[key] = propDef.value;
+          log6.removed(def.old, def.new)();
         }
       }
-      return uniforms;
-    }
-  };
-
-  // ../shadertools/src/lib/shader-assembly/resolve-modules.ts
-  function resolveModules(modules) {
-    const instances = ShaderModuleInstance.instantiateModules(modules);
-    return getShaderDependencies(instances);
+    });
   }
-  function getShaderDependencies(modules) {
+  function parseDeprecationDefinitions(deprecations) {
+    deprecations.forEach((def) => {
+      switch (def.type) {
+        case "function":
+          def.regex = new RegExp(`\\b${def.old}\\(`);
+          break;
+        default:
+          def.regex = new RegExp(`${def.type} ${def.old};`);
+      }
+    });
+    return deprecations;
+  }
+
+  // ../shadertools/src/lib/shader-module/shader-module-dependencies.ts
+  function getShaderModuleDependencies(modules) {
+    initializeShaderModules(modules);
     const moduleMap = {};
     const moduleDepth = {};
     getDependencyGraph({ modules, level: 0, moduleMap, moduleDepth });
-    return Object.keys(moduleDepth).sort((a, b) => moduleDepth[b] - moduleDepth[a]).map((name) => moduleMap[name]);
+    const dependencies = Object.keys(moduleDepth).sort((a, b) => moduleDepth[b] - moduleDepth[a]).map((name) => moduleMap[name]);
+    initializeShaderModules(dependencies);
+    return dependencies;
   }
   function getDependencyGraph(options) {
     const { modules, level, moduleMap, moduleDepth } = options;
@@ -1407,7 +1305,7 @@ ${DECLARATION_INJECT_MARKER}
 precision highp float;
 `;
   function assembleWGSLShader(options) {
-    const modules = resolveModules(options.modules || []);
+    const modules = getShaderModuleDependencies(options.modules || []);
     return {
       source: assembleShaderWGSL(options.platformInfo, {
         ...options,
@@ -1420,7 +1318,7 @@ precision highp float;
   }
   function assembleGLSLShaderPair(options) {
     const { vs, fs } = options;
-    const modules = resolveModules(options.modules || []);
+    const modules = getShaderModuleDependencies(options.modules || []);
     return {
       vs: assembleShaderGLSL(options.platformInfo, {
         ...options,
@@ -1478,9 +1376,9 @@ precision highp float;
     const modulesToInject = platformInfo.type !== "webgpu" ? modules : [];
     for (const module of modulesToInject) {
       if (log6) {
-        module.checkDeprecations(coreSource, log6);
+        checkShaderModuleDeprecations(module, coreSource, log6);
       }
-      const moduleSource = module.getModuleSource(stage, "wgsl");
+      const moduleSource = getShaderModuleSource(module, stage);
       assembledSource += moduleSource;
       const injections = module.injections[stage];
       for (const key in injections) {
@@ -1524,7 +1422,7 @@ precision highp float;
     const coreSource = sourceLines.slice(1).join("\n");
     const allDefines = {};
     modules.forEach((module) => {
-      Object.assign(allDefines, module.getDefines());
+      Object.assign(allDefines, module.defines);
     });
     Object.assign(allDefines, defines);
     let assembledSource = "";
@@ -1573,11 +1471,11 @@ ${getApplicationDefines(allDefines)}
     }
     for (const module of modules) {
       if (log6) {
-        module.checkDeprecations(coreSource, log6);
+        checkShaderModuleDeprecations(module, coreSource, log6);
       }
-      const moduleSource = module.getModuleSource(stage);
+      const moduleSource = getShaderModuleSource(module, stage);
       assembledSource += moduleSource;
-      const injections = module.injections[stage];
+      const injections = module.instance?.normalizedInjections[stage] || {};
       for (const key in injections) {
         const match = /^(v|f)s:#([\w-]+)$/.exec(key);
         if (match) {
@@ -1606,7 +1504,7 @@ ${getApplicationDefines(allDefines)}
     return function getUniforms(opts) {
       const uniforms = {};
       for (const module of modules) {
-        const moduleUniforms = module.getUniforms(opts, uniforms);
+        const moduleUniforms = module.getUniforms?.(opts, uniforms);
         Object.assign(uniforms, moduleUniforms);
       }
       return uniforms;
@@ -1631,6 +1529,32 @@ ${getApplicationDefines(allDefines)}
     }
     return sourceText;
   }
+  function getShaderModuleSource(module, stage) {
+    let moduleSource;
+    switch (stage) {
+      case "vertex":
+        moduleSource = module.vs || "";
+        break;
+      case "fragment":
+        moduleSource = module.fs || "";
+        break;
+      case "wgsl":
+        moduleSource = module.source || "";
+        break;
+      default:
+        assert(false);
+    }
+    if (!module.name) {
+      throw new Error("Shader module must have a name");
+    }
+    const moduleName = module.name.toUpperCase().replace(/[^0-9a-z]/gi, "_");
+    return `// ----- MODULE ${module.name} ---------------
+
+#define MODULE_${moduleName}
+${moduleSource}
+
+`;
+  }
 
   // ../shadertools/src/lib/preprocessor/preprocessor.ts
   var IFDEF_REGEXP = /^\s*\#\s*ifdef\s*([a-zA-Z_]+)\s*$/;
@@ -1740,9 +1664,7 @@ ${getApplicationDefines(allDefines)}
      * Dedupe and combine with default modules
      */
     _getModuleList(appModules = []) {
-      const modules = new Array(
-        this._defaultModules.length + appModules.length
-      );
+      const modules = new Array(this._defaultModules.length + appModules.length);
       const seen = {};
       let count = 0;
       for (let i = 0, len = this._defaultModules.length; i < len; ++i) {
@@ -1760,7 +1682,8 @@ ${getApplicationDefines(allDefines)}
         }
       }
       modules.length = count;
-      return ShaderModuleInstance.instantiateModules(modules);
+      initializeShaderModules(modules);
+      return modules;
     }
   };
   var ShaderAssembler = _ShaderAssembler;
@@ -3328,8 +3251,8 @@ void main() {
       const tk = this._peek();
       if (types instanceof Array) {
         const t = tk.type;
-        const index2 = types.indexOf(t);
-        return index2 != -1;
+        const index = types.indexOf(t);
+        return index != -1;
       }
       return tk.type == types;
     }
@@ -7479,7 +7402,7 @@ void main() {
      */
     // @ts-expect-error Fix typings
     constructor(modules) {
-      const allModules = resolveModules(Object.values(modules));
+      const allModules = getShaderModuleDependencies(Object.values(modules));
       import_core7.log.log(
         1,
         "Creating ShaderInputs with modules",
@@ -8262,11 +8185,11 @@ void main() {
   function mergeBufferLayouts(layouts1, layouts2) {
     const layouts = [...layouts1];
     for (const attribute of layouts2) {
-      const index2 = layouts.findIndex((attribute2) => attribute2.name === attribute.name);
-      if (index2 < 0) {
+      const index = layouts.findIndex((attribute2) => attribute2.name === attribute.name);
+      if (index < 0) {
         layouts.push(attribute);
       } else {
-        layouts[index2] = attribute;
+        layouts[index] = attribute;
       }
     }
     return layouts;
@@ -8458,8 +8381,8 @@ void main() {
     }
     // set texture filtering parameters on source textures.
     _setSourceTextureParameters() {
-      const index2 = this.currentIndex;
-      const { sourceTextures } = this.bindings[index2];
+      const index = this.currentIndex;
+      const { sourceTextures } = this.bindings[index];
       for (const name in sourceTextures) {
         sourceTextures[name].sampler = this.sampler;
       }
@@ -8941,13 +8864,13 @@ void main(void) {
     }
     for (let i = 0; i < nvertical + extra; i++) {
       for (let j = 0; j < nradial; j++) {
-        const index2 = (i * nradial + j) * 6;
-        indices[index2 + 0] = vertsAroundEdge * (i + 0) + 0 + j;
-        indices[index2 + 1] = vertsAroundEdge * (i + 0) + 1 + j;
-        indices[index2 + 2] = vertsAroundEdge * (i + 1) + 1 + j;
-        indices[index2 + 3] = vertsAroundEdge * (i + 0) + 0 + j;
-        indices[index2 + 4] = vertsAroundEdge * (i + 1) + 1 + j;
-        indices[index2 + 5] = vertsAroundEdge * (i + 1) + 0 + j;
+        const index = (i * nradial + j) * 6;
+        indices[index + 0] = vertsAroundEdge * (i + 0) + 0 + j;
+        indices[index + 1] = vertsAroundEdge * (i + 0) + 1 + j;
+        indices[index + 2] = vertsAroundEdge * (i + 1) + 1 + j;
+        indices[index + 3] = vertsAroundEdge * (i + 0) + 0 + j;
+        indices[index + 4] = vertsAroundEdge * (i + 1) + 1 + j;
+        indices[index + 5] = vertsAroundEdge * (i + 1) + 0 + j;
       }
     }
     return {
@@ -9761,9 +9684,9 @@ void main(void) {
       }
       const unpackedValue = new value.constructor(vertexCount * size);
       for (let x = 0; x < vertexCount; ++x) {
-        const index2 = indices.value[x];
+        const index = indices.value[x];
         for (let i = 0; i < size; i++) {
-          unpackedValue[x * size + i] = value[index2 * size + i];
+          unpackedValue[x * size + i] = value[index * size + i];
         }
       }
       unpackedAttributes[attributeName] = { size, value: unpackedValue };
@@ -9845,13 +9768,13 @@ void main(void) {
     const indices = new Uint16Array(subdivisions1 * subdivisions2 * 6);
     for (let z = 0; z < subdivisions2; z++) {
       for (let x = 0; x < subdivisions1; x++) {
-        const index2 = (z * subdivisions1 + x) * 6;
-        indices[index2 + 0] = (z + 0) * numVertsAcross + x;
-        indices[index2 + 1] = (z + 1) * numVertsAcross + x;
-        indices[index2 + 2] = (z + 0) * numVertsAcross + x + 1;
-        indices[index2 + 3] = (z + 1) * numVertsAcross + x;
-        indices[index2 + 4] = (z + 1) * numVertsAcross + x + 1;
-        indices[index2 + 5] = (z + 0) * numVertsAcross + x + 1;
+        const index = (z * subdivisions1 + x) * 6;
+        indices[index + 0] = (z + 0) * numVertsAcross + x;
+        indices[index + 1] = (z + 1) * numVertsAcross + x;
+        indices[index + 2] = (z + 0) * numVertsAcross + x + 1;
+        indices[index + 3] = (z + 1) * numVertsAcross + x;
+        indices[index + 4] = (z + 1) * numVertsAcross + x + 1;
+        indices[index + 5] = (z + 0) * numVertsAcross + x + 1;
       }
     }
     const geometry = {
@@ -9898,9 +9821,9 @@ void main(void) {
       for (let x = 0; x <= nlong; x++) {
         const u = x / nlong;
         const v = y / nlat;
-        const index2 = x + y * (nlong + 1);
-        const i2 = index2 * 2;
-        const i3 = index2 * 3;
+        const index = x + y * (nlong + 1);
+        const i2 = index * 2;
+        const i3 = index * 3;
         const theta = longRange * u;
         const phi = latRange * v;
         const sinTheta = Math.sin(theta);
@@ -9924,13 +9847,13 @@ void main(void) {
     const numVertsAround = nlong + 1;
     for (let x = 0; x < nlong; x++) {
       for (let y = 0; y < nlat; y++) {
-        const index2 = (x * nlat + y) * 6;
-        indices[index2 + 0] = y * numVertsAround + x;
-        indices[index2 + 1] = y * numVertsAround + x + 1;
-        indices[index2 + 2] = (y + 1) * numVertsAround + x;
-        indices[index2 + 3] = (y + 1) * numVertsAround + x;
-        indices[index2 + 4] = y * numVertsAround + x + 1;
-        indices[index2 + 5] = (y + 1) * numVertsAround + x + 1;
+        const index = (x * nlat + y) * 6;
+        indices[index + 0] = y * numVertsAround + x;
+        indices[index + 1] = y * numVertsAround + x + 1;
+        indices[index + 2] = (y + 1) * numVertsAround + x;
+        indices[index + 3] = (y + 1) * numVertsAround + x;
+        indices[index + 4] = y * numVertsAround + x + 1;
+        indices[index + 5] = (y + 1) * numVertsAround + x + 1;
       }
     }
     return {