@luma.gl/gltf 9.0.0-alpha.53 → 9.0.0-alpha.54

package/dist/dist.dev.js

@@ -975,14 +975,20 @@ var __exports__ = (() => {
       this.usage = props.usage || 0;
       this.indexType = deducedProps.indexType;
     }
-    write(data, byteOffset) {
+    readSyncWebGL2(byteOffset, byteLength) {
       throw new Error("not implemented");
     }
-    readAsync(byteOffset, byteLength) {
-      throw new Error("not implemented");
-    }
-    getData() {
-      throw new Error("not implemented");
+    debugData = new ArrayBuffer(0);
+    _setDebugData(data, byteOffset, byteLength) {
+      const buffer = ArrayBuffer.isView(data) ? data.buffer : data;
+      const debugDataLength = Math.min(data ? data.byteLength : byteLength, _Buffer.DEBUG_DATA_MAX_LENGTH);
+      if (data === null) {
+        this.debugData = new ArrayBuffer(debugDataLength);
+      } else if (byteOffset === 0 && byteLength === data.byteLength) {
+        this.debugData = buffer.slice(0, debugDataLength);
+      } else {
+        this.debugData = buffer.slice(byteOffset, byteOffset + debugDataLength);
+      }
     }
   };
   var Buffer2 = _Buffer;
@@ -1005,6 +1011,7 @@ var __exports__ = (() => {
   __publicField(Buffer2, "STORAGE", 128);
   __publicField(Buffer2, "INDIRECT", 256);
   __publicField(Buffer2, "QUERY_RESOLVE", 512);
+  __publicField(Buffer2, "DEBUG_DATA_MAX_LENGTH", 32);
 
   // ../core/src/adapter/device.ts
   var _Device = class {
@@ -2528,6 +2535,30 @@ ${htmlLog}
         throw new Error(type.constructor.name);
     }
   }
+  function getTypedArrayFromDataType(dataType) {
+    switch (dataType) {
+      case "float32":
+        return Float32Array;
+      case "uint32":
+        return Uint32Array;
+      case "sint32":
+        return Int32Array;
+      case "uint16":
+      case "unorm16":
+        return Uint16Array;
+      case "sint16":
+      case "snorm16":
+        return Int16Array;
+      case "uint8":
+      case "unorm8":
+        return Uint8Array;
+      case "sint8":
+      case "snorm8":
+        return Int8Array;
+      default:
+        throw new Error(dataType);
+    }
+  }
   function getVertexFormatFromAttribute(typedArray, size, normalized) {
     if (!size || size > 4) {
       throw new Error(`size ${size}`);
@@ -8046,12 +8077,12 @@ vec4 pbr_filterColor(vec4 colorUnused)
         log.warn(`Model:${this.id} setAttributes() - indexBuffer should be set using setIndexBuffer()`)();
       }
       for (const [bufferName, buffer] of Object.entries(buffers)) {
-        const bufferLayout = this.bufferLayout.find((layout) => layout.name === bufferName);
+        const bufferLayout = this.bufferLayout.find((layout) => getAttributeNames(layout).includes(bufferName));
         if (!bufferLayout) {
           log.warn(`Model(${this.id}): Missing layout for buffer "${bufferName}".`)();
           continue;
         }
-        const attributeNames = bufferLayout.attributes ? bufferLayout.attributes?.map((layout) => layout.attribute) : [bufferLayout.name];
+        const attributeNames = getAttributeNames(bufferLayout);
         let set2 = false;
         for (const attributeName of attributeNames) {
           const attributeInfo = this._attributeInfos[attributeName];
@@ -8128,10 +8159,40 @@ vec4 pbr_filterColor(vec4 colorUnused)
           };
         }
         log.table(LOG_DRAW_PRIORITY, uniformTable)();
+        const attributeTable = this._getAttributeDebugTable();
+        log.table(LOG_DRAW_PRIORITY, this._attributeInfos)();
+        log.table(LOG_DRAW_PRIORITY, attributeTable)();
         log.groupEnd(LOG_DRAW_PRIORITY)();
         this._logOpen = false;
       }
     }
+    _getAttributeDebugTable() {
+      const table = {};
+      for (const [name2, attributeInfo] of Object.entries(this._attributeInfos)) {
+        table[attributeInfo.location] = {
+          name: name2,
+          type: attributeInfo.shaderType,
+          values: this._getBufferOrConstantValues(this.vertexArray.attributes[attributeInfo.location], attributeInfo.bufferDataType)
+        };
+      }
+      if (this.vertexArray.indexBuffer) {
+        const {
+          indexBuffer
+        } = this.vertexArray;
+        const values = indexBuffer.indexType === "uint32" ? new Uint32Array(indexBuffer.debugData) : new Uint16Array(indexBuffer.debugData);
+        table.indices = {
+          name: "indices",
+          type: indexBuffer.indexType,
+          values: values.toString()
+        };
+      }
+      return table;
+    }
+    _getBufferOrConstantValues(attribute, dataType) {
+      const TypedArrayConstructor = getTypedArrayFromDataType(dataType);
+      const typedArray = attribute instanceof Buffer2 ? new TypedArrayConstructor(attribute.debugData) : attribute;
+      return typedArray.toString();
+    }
   };
   var Model = _Model;
   __publicField(Model, "defaultProps", {
@@ -8175,6 +8236,9 @@ vec4 pbr_filterColor(vec4 colorUnused)
       features: device.features
     };
   }
+  function getAttributeNames(bufferLayout) {
+    return bufferLayout.attributes ? bufferLayout.attributes?.map((layout) => layout.attribute) : [bufferLayout.name];
+  }
 
   // ../engine/src/geometry/geometry.ts
   var Geometry = class {
@@ -11929,10 +11993,8 @@ void main(void) {}`;
   }
 
   // ../webgl/src/adapter/resources/webgl-buffer.ts
-  var DEBUG_DATA_LENGTH = 10;
   var WEBGLBuffer = class extends Buffer2 {
     glIndexType = GLEnum2.UNSIGNED_SHORT;
-    debugData = null;
     constructor(device, props = {}) {
       super(device, props);
       this.device = device;
@@ -11947,7 +12009,6 @@ void main(void) {}`;
       this.glTarget = getWebGLTarget(this.props.usage);
       this.glUsage = getWebGLUsage(this.props.usage);
       this.glIndexType = this.props.indexType === "uint32" ? GLEnum2.UNSIGNED_INT : GLEnum2.UNSIGNED_SHORT;
-      this.debugData = null;
       if (props.data) {
         this._initWithData(props.data, props.byteOffset, props.byteLength);
       } else {
@@ -11955,17 +12016,15 @@ void main(void) {}`;
       }
     }
     _initWithData(data, byteOffset = 0, byteLength = data.byteLength + byteOffset) {
-      assert2(ArrayBuffer.isView(data));
-      const glTarget = this._getWriteTarget();
+      const glTarget = this.glTarget;
       this.gl.bindBuffer(glTarget, this.handle);
       this.gl.bufferData(glTarget, byteLength, this.glUsage);
       this.gl.bufferSubData(glTarget, byteOffset, data);
       this.gl.bindBuffer(glTarget, null);
-      this.debugData = data.slice(0, DEBUG_DATA_LENGTH);
       this.bytesUsed = byteLength;
       this.byteLength = byteLength;
+      this._setDebugData(data, byteOffset, byteLength);
       this.trackAllocatedMemory(byteLength);
-      return this;
     }
     _initWithByteLength(byteLength) {
       assert2(byteLength >= 0);
@@ -11973,13 +12032,14 @@ void main(void) {}`;
       if (byteLength === 0) {
         data = new Float32Array(0);
       }
-      const glTarget = this._getWriteTarget();
+      const glTarget = this.glTarget;
       this.gl.bindBuffer(glTarget, this.handle);
       this.gl.bufferData(glTarget, data, this.glUsage);
       this.gl.bindBuffer(glTarget, null);
-      this.debugData = null;
       this.bytesUsed = byteLength;
       this.byteLength = byteLength;
+      this._setDebugData(null, 0, byteLength);
+      this.trackAllocatedMemory(byteLength);
       return this;
     }
     destroy() {
@@ -12003,26 +12063,22 @@ void main(void) {}`;
         this.gl.bufferSubData(glTarget, byteOffset, data);
       }
       this.gl.bindBuffer(glTarget, null);
+      this._setDebugData(data, byteOffset, data.byteLength);
     }
     async readAsync(byteOffset = 0, byteLength) {
+      return this.readSyncWebGL2(byteOffset, byteLength);
+    }
+    readSyncWebGL2(byteOffset = 0, byteLength) {
       this.device.assertWebGL2();
-      byteLength = byteLength ?? this.byteLength;
+      byteLength = byteLength ?? this.byteLength - byteOffset;
       const data = new Uint8Array(byteLength);
       const dstOffset = 0;
       this.gl.bindBuffer(GLEnum2.COPY_READ_BUFFER, this.handle);
       this.gl2.getBufferSubData(GLEnum2.COPY_READ_BUFFER, byteOffset, data, dstOffset, byteLength);
       this.gl.bindBuffer(GLEnum2.COPY_READ_BUFFER, null);
+      this._setDebugData(data, byteOffset, byteLength);
       return data;
     }
-    _invalidateDebugData() {
-      this.debugData = null;
-    }
-    _getWriteTarget() {
-      return this.glTarget;
-    }
-    _getReadTarget() {
-      return this.glTarget;
-    }
   };
   function getWebGLTarget(usage) {
     if (usage & Buffer2.INDEX) {