@luma.gl/gltf 9.0.17 → 9.1.0-alpha.10

package/dist/dist.dev.js

@@ -85,9 +85,9 @@ var __exports__ = (() => {
     parsedMaterial.defines.USE_TEX_LOD = 1;
     const { imageBasedLightingEnvironment } = options;
     if (imageBasedLightingEnvironment) {
-      parsedMaterial.bindings.u_DiffuseEnvSampler = imageBasedLightingEnvironment.diffuseEnvSampler;
-      parsedMaterial.bindings.u_SpecularEnvSampler = imageBasedLightingEnvironment.specularEnvSampler;
-      parsedMaterial.bindings.u_brdfLUT = imageBasedLightingEnvironment.brdfLutTexture;
+      parsedMaterial.bindings.u_DiffuseEnvSampler = imageBasedLightingEnvironment.diffuseEnvSampler.texture;
+      parsedMaterial.bindings.u_SpecularEnvSampler = imageBasedLightingEnvironment.specularEnvSampler.texture;
+      parsedMaterial.bindings.u_brdfLUT = imageBasedLightingEnvironment.brdfLutTexture.texture;
       parsedMaterial.uniforms.u_ScaleIBLAmbient = [1, 1];
     }
     if (options?.pbrDebug) {
@@ -219,6 +219,9 @@ var __exports__ = (() => {
     parsedMaterial.generatedTextures.push(texture);
   }
 
+  // src/pbr/pbr-environment.ts
+  var import_engine = __toESM(require_engine(), 1);
+
   // ../../node_modules/@loaders.gl/loader-utils/dist/lib/env-utils/assert.js
   function assert(condition, message) {
     if (!condition) {
@@ -755,7 +758,7 @@ var __exports__ = (() => {
 
   // src/pbr/pbr-environment.ts
   function loadPBREnvironment(device, props) {
-    const brdfLutTexture = device.createTexture({
+    const brdfLutTexture = new import_engine.AsyncTexture(device, {
       id: "brdfLUT",
       sampler: {
         wrapS: "clamp-to-edge",
@@ -809,17 +812,18 @@ var __exports__ = (() => {
     FACES.forEach((face) => {
       data[String(face)] = getTextureForFace(face);
     });
-    return device.createTexture({
+    return new import_engine.AsyncTexture(device, {
       id,
       dimension: "cube",
       mipmaps: false,
       sampler,
+      // @ts-expect-error
       data
     });
   }
 
   // src/gltf/gltf-instantiator.ts
-  var import_engine2 = __toESM(require_engine(), 1);
+  var import_engine3 = __toESM(require_engine(), 1);
 
   // ../../node_modules/@math.gl/core/dist/lib/common.js
   var RADIANS_TO_DEGREES = 1 / Math.PI * 180;
@@ -3539,7 +3543,6 @@ var __exports__ = (() => {
           import_core2.log.warn(`Bad animation path ${path}`)();
       }
     }
-    (0, import_core2.assert)(target[path].length === output[previousIndex].length);
     const previousTime = input[previousIndex];
     const nextTime = input[nextIndex];
     switch (interpolation) {
@@ -3572,12 +3575,10 @@ var __exports__ = (() => {
   // src/gltf/create-gltf-model.ts
   var import_core4 = __toESM(require_core(), 1);
 
-  // ../shadertools/src/lib/glsl-utils/highlight.ts
-  var glsl = (x) => `${x}`;
-
   // ../shadertools/src/modules-webgl1/lighting/lights/lights-glsl.ts
-  var lightingShader = glsl`\
-#if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
+  var lightingShader = (
+    /* glsl */
+    `#if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
 
 struct AmbientLight {
  vec3 color;
@@ -3611,7 +3612,8 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
 }
 
 #endif
-`;
+`
+  );
 
   // ../shadertools/src/modules-webgl1/lighting/lights/lights.ts
   var INITIAL_MODULE_OPTIONS = {
@@ -3695,8 +3697,9 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
   };
 
   // ../shadertools/src/modules-webgl1/lighting/pbr/pbr-vertex-glsl.ts
-  var vs = glsl`\
-uniform mat4 u_MVPMatrix;
+  var vs = (
+    /* glsl */
+    `uniform mat4 u_MVPMatrix;
 uniform mat4 u_ModelMatrix;
 uniform mat4 u_NormalMatrix;
 
@@ -3733,11 +3736,13 @@ void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, ve
   pbr_vUV = vec2(0.,0.);
 #endif
 }
-`;
+`
+  );
 
   // ../shadertools/src/modules-webgl1/lighting/pbr/pbr-fragment-glsl.ts
-  var fs = glsl`\
-precision highp float;
+  var fs = (
+    /* glsl */
+    `precision highp float;
 
 uniform bool pbr_uUnlit;
 
@@ -4118,7 +4123,8 @@ vec4 pbr_filterColor(vec4 colorUnused)
 
   return vec4(pow(color,vec3(1.0/2.2)), baseColor.a);
 }
-`;
+`
+  );
 
   // ../shadertools/src/modules-webgl1/lighting/pbr/pbr.ts
   var pbr = {
@@ -4128,34 +4134,80 @@ vec4 pbr_filterColor(vec4 colorUnused)
     defines: {
       LIGHTING_FRAGMENT: 1
     },
-    dependencies: [lights]
+    dependencies: [lights],
+    getUniforms: (props) => props
   };
 
   // src/gltf/create-gltf-model.ts
-  var import_engine = __toESM(require_engine(), 1);
-  var vs2 = `
-#pragma vscode_glsllint_stage: vert
-#if (__VERSION__ < 300)
-  #define _attr attribute
-#else
-  #define _attr in
-#endif
+  var import_engine2 = __toESM(require_engine(), 1);
+  var SHADER = (
+    /* WGSL */
+    `
+layout(0) positions: vec4; // in vec4 POSITION;
+
+  #ifdef HAS_NORMALS
+    in vec4 normals; // in vec4 NORMAL;
+  #endif
+
+  #ifdef HAS_TANGENTS
+    in vec4 TANGENT;
+  #endif
+
+  #ifdef HAS_UV
+    // in vec2 TEXCOORD_0;
+    in vec2 texCoords;
+  #endif
+
+@vertex
+  void main(void) {
+    vec4 _NORMAL = vec4(0.);
+    vec4 _TANGENT = vec4(0.);
+    vec2 _TEXCOORD_0 = vec2(0.);
+
+    #ifdef HAS_NORMALS
+      _NORMAL = normals;
+    #endif
+
+    #ifdef HAS_TANGENTS
+      _TANGENT = TANGENT;
+    #endif
+
+    #ifdef HAS_UV
+      _TEXCOORD_0 = texCoords;
+    #endif
+
+    pbr_setPositionNormalTangentUV(positions, _NORMAL, _TANGENT, _TEXCOORD_0);
+    gl_Position = u_MVPMatrix * positions;
+  }
 
-  // _attr vec4 POSITION;
-  _attr vec4 positions;
+@fragment
+  out vec4 fragmentColor;
+
+  void main(void) {
+    vec3 pos = pbr_vPosition;
+    fragmentColor = pbr_filterColor(vec4(1.0));
+  }
+`
+  );
+  var vs2 = (
+    /* glsl */
+    `#version 300 es
+
+  // in vec4 POSITION;
+  in vec4 positions;
 
   #ifdef HAS_NORMALS
-    // _attr vec4 NORMAL;
-    _attr vec4 normals;
+    // in vec4 NORMAL;
+    in vec4 normals;
   #endif
 
   #ifdef HAS_TANGENTS
-    _attr vec4 TANGENT;
+    in vec4 TANGENT;
   #endif
 
   #ifdef HAS_UV
-    // _attr vec2 TEXCOORD_0;
-    _attr vec2 texCoords;
+    // in vec2 TEXCOORD_0;
+    in vec2 texCoords;
   #endif
 
   void main(void) {
@@ -4178,20 +4230,19 @@ vec4 pbr_filterColor(vec4 colorUnused)
     pbr_setPositionNormalTangentUV(positions, _NORMAL, _TANGENT, _TEXCOORD_0);
     gl_Position = u_MVPMatrix * positions;
   }
-`;
-  var fs2 = `
-#pragma vscode_glsllint_stage: frag
-#if (__VERSION__ < 300)
-  #define fragmentColor gl_FragColor
-#else
+`
+  );
+  var fs2 = (
+    /* glsl */
+    `#version 300 es
   out vec4 fragmentColor;
-#endif
 
   void main(void) {
     vec3 pos = pbr_vPosition;
     fragmentColor = pbr_filterColor(vec4(1.0));
   }
-`;
+`
+  );
   function createGLTFModel(device, options) {
     const { id, geometry, material, vertexCount, materialOptions, modelOptions } = options;
     const parsedMaterial = parsePBRMaterial(device, material, geometry.attributes, materialOptions);
@@ -4205,24 +4256,39 @@ vec4 pbr_filterColor(vec4 colorUnused)
     };
     const modelProps = {
       id,
+      source: SHADER,
+      vs: vs2,
+      fs: fs2,
       geometry,
       topology: geometry.topology,
       vertexCount,
       modules: [pbr],
-      vs: addVersionToShader(device, vs2),
-      fs: addVersionToShader(device, fs2),
       ...modelOptions,
       bindings: { ...parsedMaterial.bindings, ...modelOptions.bindings },
       defines: { ...parsedMaterial.defines, ...modelOptions.defines },
       parameters: { ...parameters, ...parsedMaterial.parameters, ...modelOptions.parameters },
       uniforms: { ...parsedMaterial.uniforms, ...modelOptions.uniforms }
     };
-    const model = new import_engine.Model(device, modelProps);
-    return new import_engine.ModelNode({ managedResources, model });
+    const model = new import_engine2.Model(device, modelProps);
+    return new import_engine2.ModelNode({ managedResources, model });
   }
-  function addVersionToShader(device, source) {
-    return `#version 300 es
-${source}`;
+
+  // src/gltf/gl-utils.ts
+  function convertGLDrawModeToTopology(drawMode) {
+    switch (drawMode) {
+      case 0 /* POINTS */:
+        return "point-list";
+      case 1 /* LINES */:
+        return "line-list";
+      case 3 /* LINE_STRIP */:
+        return "line-strip";
+      case 4 /* TRIANGLES */:
+        return "triangle-list";
+      case 5 /* TRIANGLE_STRIP */:
+        return "triangle-strip";
+      default:
+        throw new Error(String(drawMode));
+    }
   }
 
   // src/gltf/gltf-instantiator.ts
@@ -4255,7 +4321,7 @@ ${source}`;
     createScene(gltfScene) {
       const gltfNodes = gltfScene.nodes || [];
       const nodes = gltfNodes.map((node) => this.createNode(node));
-      const scene = new import_engine2.GroupNode({
+      const scene = new import_engine3.GroupNode({
         id: gltfScene.name || gltfScene.id,
         children: nodes
       });
@@ -4268,7 +4334,7 @@ ${source}`;
         if (gltfNode.mesh) {
           children.push(this.createMesh(gltfNode.mesh));
         }
-        const node = new import_engine2.GroupNode({
+        const node = new import_engine3.GroupNode({
           id: gltfNode.name || gltfNode.id,
           children
         });
@@ -4297,7 +4363,7 @@ ${source}`;
         const primitives = gltfPrimitives.map(
           (gltfPrimitive, i) => this.createPrimitive(gltfPrimitive, i, gltfMesh)
         );
-        const mesh = new import_engine2.GroupNode({
+        const mesh = new import_engine3.GroupNode({
           id: gltfMesh.name || gltfMesh.id,
           children: primitives
         });
@@ -4332,7 +4398,7 @@ ${source}`;
         const { components, size, value } = attribute;
         attributes[attributeName] = { size: size ?? components, value };
       }
-      return new import_engine2.Geometry({
+      return new import_engine3.Geometry({
         id,
         topology,
         indices: gltfPrimitive.indices.value,
@@ -4365,26 +4431,6 @@ ${source}`;
       return false;
     }
   };
-  function convertGLDrawModeToTopology(drawMode) {
-    switch (drawMode) {
-      case 0 /* POINTS */:
-        return "point-list";
-      case 1 /* LINES */:
-        return "line-list";
-      case 3 /* LINE_STRIP */:
-        return "line-strip";
-      case 2 /* LINE_LOOP */:
-        return "line-loop-webgl";
-      case 4 /* TRIANGLES */:
-        return "triangle-list";
-      case 5 /* TRIANGLE_STRIP */:
-        return "triangle-strip";
-      case 6 /* TRIANGLE_FAN */:
-        return "triangle-fan-webgl";
-      default:
-        throw new Error(drawMode);
-    }
-  }
 
   // src/gltf/create-gltf-objects.ts
   function createScenegraphsFromGLTF(device, gltf, options) {