@loaders.gl/gltf 4.3.0-alpha.7 → 4.3.0-alpha.8

package/dist/index.cjs

@@ -29,6 +29,8 @@ __export(dist_exports, {
   GLTFScenegraph: () => GLTFScenegraph,
   GLTFWriter: () => GLTFWriter,
   _getMemoryUsageGLTF: () => getMemoryUsageGLTF,
+  createExtMeshFeatures: () => createExtMeshFeatures,
+  createExtStructuralMetadata: () => createExtStructuralMetadata,
   postProcessGLTF: () => postProcessGLTF
 });
 module.exports = __toCommonJS(dist_exports);
@@ -36,7 +38,9 @@ module.exports = __toCommonJS(dist_exports);
 // dist/lib/extensions/EXT_mesh_features.js
 var EXT_mesh_features_exports = {};
 __export(EXT_mesh_features_exports, {
+  createExtMeshFeatures: () => createExtMeshFeatures,
   decode: () => decode,
+  encode: () => encode,
   name: () => name
 });
 
@@ -611,7 +615,6 @@ var GLTFScenegraph = class {
   /** Pack the binary chunk */
   createBinaryChunk() {
     var _a, _b;
-    this.gltf.buffers = [];
     const totalByteLength = this.byteLength;
     const arrayBuffer = new ArrayBuffer(totalByteLength);
     const targetArray = new Uint8Array(arrayBuffer);
@@ -626,6 +629,7 @@ var GLTFScenegraph = class {
     }
     this.gltf.binary = arrayBuffer;
     this.sourceBuffers = [arrayBuffer];
+    this.gltf.buffers = [{ arrayBuffer, byteOffset: 0, byteLength: arrayBuffer.byteLength }];
   }
   // PRIVATE
   _removeStringFromArray(array, string) {
@@ -927,6 +931,12 @@ async function decode(gltfData, options) {
   const scenegraph = new GLTFScenegraph(gltfData);
   decodeExtMeshFeatures(scenegraph, options);
 }
+function encode(gltfData, options) {
+  const scenegraph = new GLTFScenegraph(gltfData);
+  encodeExtMeshFeatures(scenegraph, options);
+  scenegraph.createBinaryChunk();
+  return scenegraph.gltf;
+}
 function decodeExtMeshFeatures(scenegraph, options) {
   const json = scenegraph.gltf.json;
   if (!json.meshes) {
@@ -962,11 +972,87 @@ function processMeshPrimitiveFeatures(scenegraph, primitive, options) {
     featureId.data = featureIdData;
   }
 }
+function encodeExtMeshFeatures(scenegraph, options) {
+  const meshes = scenegraph.gltf.json.meshes;
+  if (!meshes) {
+    return;
+  }
+  for (const mesh of meshes) {
+    for (const primitive of mesh.primitives) {
+      encodeExtMeshFeaturesForPrimitive(scenegraph, primitive);
+    }
+  }
+}
+function createExtMeshFeatures(scenegraph, primitive, featureIdArray, propertyTableIndex) {
+  if (!primitive.extensions) {
+    primitive.extensions = {};
+  }
+  let extension = primitive.extensions[EXT_MESH_FEATURES_NAME];
+  if (!extension) {
+    extension = { featureIds: [] };
+    primitive.extensions[EXT_MESH_FEATURES_NAME] = extension;
+  }
+  const { featureIds } = extension;
+  const featureId = {
+    featureCount: featureIdArray.length,
+    propertyTable: propertyTableIndex,
+    data: featureIdArray
+  };
+  featureIds.push(featureId);
+  scenegraph.addObjectExtension(primitive, EXT_MESH_FEATURES_NAME, extension);
+}
+function encodeExtMeshFeaturesForPrimitive(scenegraph, primitive) {
+  var _a;
+  const extension = (_a = primitive.extensions) == null ? void 0 : _a[EXT_MESH_FEATURES_NAME];
+  if (!extension) {
+    return;
+  }
+  const featureIds = extension.featureIds;
+  featureIds.forEach((featureId, elementIndex) => {
+    if (featureId.data) {
+      const { accessorKey, index } = createAccessorKey(primitive.attributes);
+      const typedArray = new Uint32Array(featureId.data);
+      featureIds[elementIndex] = {
+        featureCount: typedArray.length,
+        propertyTable: featureId.propertyTable,
+        attribute: index
+      };
+      scenegraph.gltf.buffers.push({
+        arrayBuffer: typedArray.buffer,
+        byteOffset: typedArray.byteOffset,
+        byteLength: typedArray.byteLength
+      });
+      const bufferViewIndex = scenegraph.addBufferView(typedArray);
+      const accessorIndex = scenegraph.addAccessor(bufferViewIndex, {
+        size: 1,
+        componentType: getComponentTypeFromArray(typedArray),
+        count: typedArray.length
+      });
+      primitive.attributes[accessorKey] = accessorIndex;
+    }
+  });
+}
+function createAccessorKey(attributes) {
+  const prefix = "_FEATURE_ID_";
+  const attrs = Object.keys(attributes).filter((item) => item.indexOf(prefix) === 0);
+  let max = -1;
+  for (const a of attrs) {
+    const n = Number(a.substring(prefix.length));
+    if (n > max) {
+      max = n;
+    }
+  }
+  max++;
+  const accessorKey = `${prefix}${max}`;
+  return { accessorKey, index: max };
+}
 
 // dist/lib/extensions/EXT_structural_metadata.js
 var EXT_structural_metadata_exports = {};
 __export(EXT_structural_metadata_exports, {
+  createExtStructuralMetadata: () => createExtStructuralMetadata,
   decode: () => decode2,
+  encode: () => encode2,
   name: () => name2
 });
 var EXT_STRUCTURAL_METADATA_NAME = "EXT_structural_metadata";
@@ -975,6 +1061,12 @@ async function decode2(gltfData, options) {
   const scenegraph = new GLTFScenegraph(gltfData);
   decodeExtStructuralMetadata(scenegraph, options);
 }
+function encode2(gltfData, options) {
+  const scenegraph = new GLTFScenegraph(gltfData);
+  encodeExtStructuralMetadata(scenegraph, options);
+  scenegraph.createBinaryChunk();
+  return scenegraph.gltf;
+}
 function decodeExtStructuralMetadata(scenegraph, options) {
   var _a, _b;
   if (!((_a = options.gltf) == null ? void 0 : _a.loadBuffers)) {
@@ -1245,6 +1337,155 @@ function getEnumByValue(enumEntry, value) {
   }
   return null;
 }
+var SCHEMA_CLASS_ID_DEFAULT = "schemaClassId";
+function encodeExtStructuralMetadata(scenegraph, options) {
+  var _a, _b;
+  const extension = scenegraph.getExtension(EXT_STRUCTURAL_METADATA_NAME);
+  if (!extension) {
+    return;
+  }
+  if (extension.propertyTables) {
+    for (const table of extension.propertyTables) {
+      const classId = table.class;
+      const schemaClass = (_b = (_a = extension.schema) == null ? void 0 : _a.classes) == null ? void 0 : _b[classId];
+      if (table.properties && schemaClass) {
+        encodeProperties(table, schemaClass, scenegraph);
+      }
+    }
+  }
+}
+function encodeProperties(table, schemaClass, scenegraph) {
+  for (const propertyName in table.properties) {
+    const data = table.properties[propertyName].data;
+    if (data) {
+      const classProperty = schemaClass.properties[propertyName];
+      if (classProperty) {
+        const tableProperty = createPropertyTableProperty(data, classProperty, scenegraph);
+        table.properties[propertyName] = tableProperty;
+      }
+    }
+  }
+}
+function createExtStructuralMetadata(scenegraph, propertyAttributes, classId = SCHEMA_CLASS_ID_DEFAULT) {
+  let extension = scenegraph.getExtension(EXT_STRUCTURAL_METADATA_NAME);
+  if (!extension) {
+    extension = scenegraph.addExtension(EXT_STRUCTURAL_METADATA_NAME);
+  }
+  extension.schema = createSchema(propertyAttributes, classId, extension.schema);
+  const table = createPropertyTable(propertyAttributes, classId, extension.schema);
+  if (!extension.propertyTables) {
+    extension.propertyTables = [];
+  }
+  return extension.propertyTables.push(table) - 1;
+}
+function createSchema(propertyAttributes, classId, schemaToUpdate) {
+  const schema = schemaToUpdate ?? {
+    id: "schema_id"
+  };
+  const schemaClass = {
+    properties: {}
+  };
+  for (const attribute of propertyAttributes) {
+    const classProperty = {
+      type: attribute.elementType,
+      componentType: attribute.componentType
+    };
+    schemaClass.properties[attribute.name] = classProperty;
+  }
+  schema.classes = {};
+  schema.classes[classId] = schemaClass;
+  return schema;
+}
+function createPropertyTable(propertyAttributes, classId, schema) {
+  var _a;
+  const table = {
+    class: classId,
+    count: 0
+  };
+  let count = 0;
+  const schemaClass = (_a = schema.classes) == null ? void 0 : _a[classId];
+  for (const attribute of propertyAttributes) {
+    if (count === 0) {
+      count = attribute.values.length;
+    }
+    if (count !== attribute.values.length && attribute.values.length) {
+      throw new Error("Illegal values in attributes");
+    }
+    const classProperty = schemaClass == null ? void 0 : schemaClass.properties[attribute.name];
+    if (classProperty) {
+      if (!table.properties) {
+        table.properties = {};
+      }
+      table.properties[attribute.name] = { values: 0, data: attribute.values };
+    }
+  }
+  table.count = count;
+  return table;
+}
+function createPropertyTableProperty(values, classProperty, scenegraph) {
+  const prop = { values: 0 };
+  if (classProperty.type === "STRING") {
+    const { stringData, stringOffsets } = createPropertyDataString(values);
+    prop.stringOffsets = createBufferView(stringOffsets, scenegraph);
+    prop.values = createBufferView(stringData, scenegraph);
+  } else if (classProperty.type === "SCALAR" && classProperty.componentType) {
+    const data = createPropertyDataScalar(values, classProperty.componentType);
+    prop.values = createBufferView(data, scenegraph);
+  }
+  return prop;
+}
+var COMPONENT_TYPE_TO_ARRAY_CONSTRUCTOR = {
+  INT8: Int8Array,
+  UINT8: Uint8Array,
+  INT16: Int16Array,
+  UINT16: Uint16Array,
+  INT32: Int32Array,
+  UINT32: Uint32Array,
+  INT64: Int32Array,
+  UINT64: Uint32Array,
+  FLOAT32: Float32Array,
+  FLOAT64: Float64Array
+};
+function createPropertyDataScalar(array, componentType) {
+  const numberArray = [];
+  for (const value of array) {
+    numberArray.push(Number(value));
+  }
+  const Construct = COMPONENT_TYPE_TO_ARRAY_CONSTRUCTOR[componentType];
+  if (!Construct) {
+    throw new Error("Illegal component type");
+  }
+  return new Construct(numberArray);
+}
+function createPropertyDataString(strings) {
+  const utf8Encode = new TextEncoder();
+  const arr = [];
+  let len = 0;
+  for (const str of strings) {
+    const uint8Array = utf8Encode.encode(str);
+    len += uint8Array.length;
+    arr.push(uint8Array);
+  }
+  const strArray = new Uint8Array(len);
+  const strOffsets = [];
+  let offset = 0;
+  for (const str of arr) {
+    strArray.set(str, offset);
+    strOffsets.push(offset);
+    offset += str.length;
+  }
+  strOffsets.push(offset);
+  const stringOffsetsTypedArray = new Uint32Array(strOffsets);
+  return { stringData: strArray, stringOffsets: stringOffsetsTypedArray };
+}
+function createBufferView(typedArray, scenegraph) {
+  scenegraph.gltf.buffers.push({
+    arrayBuffer: typedArray.buffer,
+    byteOffset: typedArray.byteOffset,
+    byteLength: typedArray.byteLength
+  });
+  return scenegraph.addBufferView(typedArray);
+}
 
 // dist/lib/extensions/deprecated/EXT_feature_metadata.js
 var EXT_feature_metadata_exports = {};
@@ -1452,7 +1693,7 @@ function processPrimitiveTextures(scenegraph, attributeName, featureTexturePrope
 }
 
 // dist/lib/utils/version.js
-var VERSION = true ? "4.3.0-alpha.6" : "latest";
+var VERSION = true ? "4.3.0-alpha.7" : "latest";
 
 // dist/lib/parsers/parse-gltf.js
 var import_loader_utils4 = require("@loaders.gl/loader-utils");
@@ -1862,7 +2103,7 @@ function preprocess2(gltfData, options) {
 var KHR_draco_mesh_compression_exports = {};
 __export(KHR_draco_mesh_compression_exports, {
   decode: () => decode6,
-  encode: () => encode,
+  encode: () => encode3,
   name: () => name7,
   preprocess: () => preprocess3
 });
@@ -1953,7 +2194,7 @@ async function decode6(gltfData, options, context) {
   await Promise.all(promises);
   scenegraph.removeExtension(KHR_DRACO_MESH_COMPRESSION);
 }
-function encode(gltfData, options = {}) {
+function encode3(gltfData, options = {}) {
   const scenegraph = new GLTFScenegraph(gltfData);
   for (const mesh of scenegraph.json.meshes || []) {
     compressMesh(mesh, options);
@@ -2184,7 +2425,7 @@ function makeTransformationMatrix(extensionData) {
 var KHR_lights_punctual_exports = {};
 __export(KHR_lights_punctual_exports, {
   decode: () => decode8,
-  encode: () => encode2,
+  encode: () => encode4,
   name: () => name9
 });
 var KHR_LIGHTS_PUNCTUAL = "KHR_lights_punctual";
@@ -2205,7 +2446,7 @@ async function decode8(gltfData) {
     gltfScenegraph.removeObjectExtension(node, KHR_LIGHTS_PUNCTUAL);
   }
 }
-async function encode2(gltfData) {
+async function encode4(gltfData) {
   const gltfScenegraph = new GLTFScenegraph(gltfData);
   const { json } = gltfScenegraph;
   if (json.lights) {
@@ -2227,7 +2468,7 @@ async function encode2(gltfData) {
 var KHR_materials_unlit_exports = {};
 __export(KHR_materials_unlit_exports, {
   decode: () => decode9,
-  encode: () => encode3,
+  encode: () => encode5,
   name: () => name10
 });
 var KHR_MATERIALS_UNLIT = "KHR_materials_unlit";
@@ -2244,7 +2485,7 @@ async function decode9(gltfData) {
   }
   gltfScenegraph.removeExtension(KHR_MATERIALS_UNLIT);
 }
-function encode3(gltfData) {
+function encode5(gltfData) {
   const gltfScenegraph = new GLTFScenegraph(gltfData);
   const { json } = gltfScenegraph;
   if (gltfScenegraph.materials) {
@@ -2262,7 +2503,7 @@ function encode3(gltfData) {
 var KHR_techniques_webgl_exports = {};
 __export(KHR_techniques_webgl_exports, {
   decode: () => decode10,
-  encode: () => encode4,
+  encode: () => encode6,
   name: () => name11
 });
 var KHR_TECHNIQUES_WEBGL = "KHR_techniques_webgl";
@@ -2289,7 +2530,7 @@ async function decode10(gltfData) {
     gltfScenegraph.removeExtension(KHR_TECHNIQUES_WEBGL);
   }
 }
-async function encode4(gltfData, options) {
+async function encode6(gltfData, options) {
 }
 function resolveTechniques(techniquesExtension, gltfScenegraph) {
   const { programs = [], shaders = [], techniques = [] } = techniquesExtension;
@@ -2344,6 +2585,7 @@ var EXTENSIONS = [
   KHR_texture_transform_exports,
   EXT_feature_metadata_exports
 ];
+var EXTENSIONS_ENCODING = [EXT_structural_metadata_exports, EXT_mesh_features_exports];
 function preprocessExtensions(gltf, options = {}, context) {
   var _a;
   const extensions = EXTENSIONS.filter((extension) => useExtension(extension.name, options));
@@ -2358,6 +2600,13 @@ async function decodeExtensions(gltf, options = {}, context) {
     await ((_a = extension.decode) == null ? void 0 : _a.call(extension, gltf, options, context));
   }
 }
+function encodeExtensions(gltf, options = {}) {
+  var _a;
+  for (const extension of EXTENSIONS_ENCODING) {
+    gltf = ((_a = extension.encode) == null ? void 0 : _a.call(extension, gltf, options)) ?? gltf;
+  }
+  return gltf;
+}
 function useExtension(extensionName, options) {
   var _a;
   const excludes = ((_a = options == null ? void 0 : options.gltf) == null ? void 0 : _a.excludeExtensions) || {};
@@ -2811,11 +3060,11 @@ function encodeGLBSync(glb, dataView, byteOffset = 0, options = {}) {
 
 // dist/lib/encoders/encode-gltf.js
 function encodeGLTFSync(gltf, arrayBuffer, byteOffset, options) {
-  convertBuffersToBase64(gltf);
+  validateGltf(gltf);
   return encodeGLBSync(gltf, arrayBuffer, byteOffset, options);
 }
-function convertBuffersToBase64(gltf, { firstBuffer = 0 } = {}) {
-  if (gltf.buffers && gltf.buffers.length > firstBuffer) {
+function validateGltf(gltf) {
+  if (gltf.buffers && gltf.buffers.length > 1) {
     throw new Error("encodeGLTF: multiple buffers not yet implemented");
   }
 }
@@ -2841,10 +3090,11 @@ var GLTFWriter = {
 };
 function encodeSync(gltf, options = {}) {
   const { byteOffset = 0 } = options;
-  const byteLength = encodeGLTFSync(gltf, null, byteOffset, options);
+  const gltfToEncode = encodeExtensions(gltf);
+  const byteLength = encodeGLTFSync(gltfToEncode, null, byteOffset, options);
   const arrayBuffer = new ArrayBuffer(byteLength);
   const dataView = new DataView(arrayBuffer);
-  encodeGLTFSync(gltf, dataView, byteOffset, options);
+  encodeGLTFSync(gltfToEncode, dataView, byteOffset, options);
   return arrayBuffer;
 }
 
@@ -2894,7 +3144,7 @@ var GLBWriter = {
   encodeSync: encodeSync2
 };
 function encodeSync2(glb, options) {
-  const { byteOffset = 0 } = options;
+  const { byteOffset = 0 } = options ?? {};
   const byteLength = encodeGLBSync(glb, null, byteOffset, options);
   const arrayBuffer = new ArrayBuffer(byteLength);
   const dataView = new DataView(arrayBuffer);