@loaders.gl/gltf 4.0.0-alpha.5 → 4.0.0-alpha.6

package/dist/esm/lib/extensions/deprecated/EXT_feature_metadata.js

@@ -0,0 +1,77 @@
+import GLTFScenegraph from '../../api/gltf-scenegraph';
+const EXT_FEATURE_METADATA = 'EXT_feature_metadata';
+export const name = EXT_FEATURE_METADATA;
+export async function decode(gltfData) {
+  const scenegraph = new GLTFScenegraph(gltfData);
+  decodeExtFeatureMetadata(scenegraph);
+}
+function decodeExtFeatureMetadata(scenegraph) {
+  var _extension$schema;
+  const extension = scenegraph.getExtension(EXT_FEATURE_METADATA);
+  const schemaClasses = extension === null || extension === void 0 ? void 0 : (_extension$schema = extension.schema) === null || _extension$schema === void 0 ? void 0 : _extension$schema.classes;
+  const featureTables = extension === null || extension === void 0 ? void 0 : extension.featureTables;
+  const featureTextures = extension === null || extension === void 0 ? void 0 : extension.featureTextures;
+  if (featureTextures) {
+    console.warn('featureTextures is not yet supported in the "EXT_feature_metadata" extension.');
+  }
+  if (schemaClasses && featureTables) {
+    for (const schemaName in schemaClasses) {
+      const schemaClass = schemaClasses[schemaName];
+      const featureTable = findFeatureTableByName(featureTables, schemaName);
+      if (featureTable) {
+        handleFeatureTableProperties(scenegraph, featureTable, schemaClass);
+      }
+    }
+  }
+}
+function handleFeatureTableProperties(scenegraph, featureTable, schemaClass) {
+  for (const propertyName in schemaClass.properties) {
+    var _featureTable$propert;
+    const schemaProperty = schemaClass.properties[propertyName];
+    const featureTableProperty = featureTable === null || featureTable === void 0 ? void 0 : (_featureTable$propert = featureTable.properties) === null || _featureTable$propert === void 0 ? void 0 : _featureTable$propert[propertyName];
+    const numberOfFeatures = featureTable.count;
+    if (featureTableProperty) {
+      const data = getPropertyDataFromBinarySource(scenegraph, schemaProperty, numberOfFeatures, featureTableProperty);
+      featureTableProperty.data = data;
+    }
+  }
+}
+function getPropertyDataFromBinarySource(scenegraph, schemaProperty, numberOfFeatures, featureTableProperty) {
+  const bufferView = featureTableProperty.bufferView;
+  let data = scenegraph.getTypedArrayForBufferView(bufferView);
+  switch (schemaProperty.type) {
+    case 'STRING':
+      {
+        const stringOffsetBufferView = featureTableProperty.stringOffsetBufferView;
+        const offsetsData = scenegraph.getTypedArrayForBufferView(stringOffsetBufferView);
+        data = getStringAttributes(data, offsetsData, numberOfFeatures);
+        break;
+      }
+    default:
+  }
+  return data;
+}
+function findFeatureTableByName(featureTables, schemaClassName) {
+  for (const featureTableName in featureTables) {
+    const featureTable = featureTables[featureTableName];
+    if (featureTable.class === schemaClassName) {
+      return featureTable;
+    }
+  }
+  return null;
+}
+function getStringAttributes(data, offsetsData, stringsCount) {
+  const stringsArray = [];
+  const textDecoder = new TextDecoder('utf8');
+  let stringOffset = 0;
+  const bytesPerStringSize = 4;
+  for (let index = 0; index < stringsCount; index++) {
+    const stringByteSize = offsetsData[(index + 1) * bytesPerStringSize] - offsetsData[index * bytesPerStringSize];
+    const stringData = data.subarray(stringOffset, stringByteSize + stringOffset);
+    const stringAttribute = textDecoder.decode(stringData);
+    stringsArray.push(stringAttribute);
+    stringOffset += stringByteSize;
+  }
+  return stringsArray;
+}
+//# sourceMappingURL=EXT_feature_metadata.js.map

package/dist/esm/lib/extensions/deprecated/EXT_feature_metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EXT_feature_metadata.js","names":["GLTFScenegraph","EXT_FEATURE_METADATA","name","decode","gltfData","scenegraph","decodeExtFeatureMetadata","_extension$schema","extension","getExtension","schemaClasses","schema","classes","featureTables","featureTextures","console","warn","schemaName","schemaClass","featureTable","findFeatureTableByName","handleFeatureTableProperties","propertyName","properties","_featureTable$propert","schemaProperty","featureTableProperty","numberOfFeatures","count","data","getPropertyDataFromBinarySource","bufferView","getTypedArrayForBufferView","type","stringOffsetBufferView","offsetsData","getStringAttributes","schemaClassName","featureTableName","class","stringsCount","stringsArray","textDecoder","TextDecoder","stringOffset","bytesPerStringSize","index","stringByteSize","stringData","subarray","stringAttribute","push"],"sources":["../../../../../src/lib/extensions/deprecated/EXT_feature_metadata.ts"],"sourcesContent":["/* eslint-disable camelcase */\nimport type {GLTF} from '../../types/gltf-types';\n\nimport GLTFScenegraph from '../../api/gltf-scenegraph';\nimport {\n  ClassProperty,\n  EXT_feature_metadata_class_object,\n  EXT_feature_metadata_feature_table,\n  FeatureTableProperty,\n  GLTF_EXT_feature_metadata\n} from '../../types/gltf-json-schema';\n\n/** Extension name */\nconst EXT_FEATURE_METADATA = 'EXT_feature_metadata';\n\nexport const name = EXT_FEATURE_METADATA;\n\nexport async function decode(gltfData: {json: GLTF}): Promise<void> {\n  const scenegraph = new GLTFScenegraph(gltfData);\n  decodeExtFeatureMetadata(scenegraph);\n}\n\n/**\n * Decodes feature metadata from extension\n * @param scenegraph\n */\nfunction decodeExtFeatureMetadata(scenegraph: GLTFScenegraph): void {\n  const extension: GLTF_EXT_feature_metadata | null = scenegraph.getExtension(EXT_FEATURE_METADATA);\n  const schemaClasses = extension?.schema?.classes;\n  const featureTables = extension?.featureTables;\n  const featureTextures = extension?.featureTextures;\n\n  if (featureTextures) {\n    /*\n     * TODO add support for featureTextures\n     * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata#feature-textures\n     */\n    // eslint-disable-next-line no-console\n    console.warn('featureTextures is not yet supported in the \"EXT_feature_metadata\" extension.');\n  }\n\n  if (schemaClasses && featureTables) {\n    for (const schemaName in schemaClasses) {\n      const schemaClass = schemaClasses[schemaName];\n      const featureTable = findFeatureTableByName(featureTables, schemaName);\n\n      if (featureTable) {\n        handleFeatureTableProperties(scenegraph, featureTable, schemaClass);\n      }\n    }\n  }\n}\n\n/**\n * Navigate throw all properies in feature table and gets properties data.\n * @param scenegraph\n * @param featureTable\n * @param schemaClass\n */\nfunction handleFeatureTableProperties(\n  scenegraph: GLTFScenegraph,\n  featureTable: EXT_feature_metadata_feature_table,\n  schemaClass: EXT_feature_metadata_class_object\n): void {\n  for (const propertyName in schemaClass.properties) {\n    const schemaProperty = schemaClass.properties[propertyName];\n    const featureTableProperty = featureTable?.properties?.[propertyName];\n    const numberOfFeatures = featureTable.count;\n\n    if (featureTableProperty) {\n      const data = getPropertyDataFromBinarySource(\n        scenegraph,\n        schemaProperty,\n        numberOfFeatures,\n        featureTableProperty\n      );\n      featureTableProperty.data = data;\n    }\n  }\n}\n\n/**\n * Decode properties from binary sourse based on property type.\n * @param scenegraph\n * @param schemaProperty\n * @param numberOfFeatures\n * @param featureTableProperty\n */\nfunction getPropertyDataFromBinarySource(\n  scenegraph: GLTFScenegraph,\n  schemaProperty: ClassProperty,\n  numberOfFeatures: number,\n  featureTableProperty: FeatureTableProperty\n): Uint8Array | string[] {\n  const bufferView = featureTableProperty.bufferView;\n  // TODO think maybe we shouldn't get data only in Uint8Array format.\n  let data: Uint8Array | string[] = scenegraph.getTypedArrayForBufferView(bufferView);\n\n  switch (schemaProperty.type) {\n    case 'STRING': {\n      // stringOffsetBufferView should be available for string type.\n      const stringOffsetBufferView = featureTableProperty.stringOffsetBufferView!;\n      const offsetsData = scenegraph.getTypedArrayForBufferView(stringOffsetBufferView);\n      data = getStringAttributes(data, offsetsData, numberOfFeatures);\n      break;\n    }\n    default:\n  }\n\n  return data;\n}\n\n/**\n * Find the feature table by class name.\n * @param featureTables\n * @param schemaClassName\n */\nfunction findFeatureTableByName(\n  featureTables: {[key: string]: EXT_feature_metadata_feature_table},\n  schemaClassName: string\n): EXT_feature_metadata_feature_table | null {\n  for (const featureTableName in featureTables) {\n    const featureTable = featureTables[featureTableName];\n\n    if (featureTable.class === schemaClassName) {\n      return featureTable;\n    }\n  }\n\n  return null;\n}\n\n/**\n * Getting string attributes from binary data.\n * Spec - https://github.com/CesiumGS/3d-tiles/tree/main/specification/Metadata#strings\n * @param data\n * @param offsetsData\n * @param stringsCount\n */\nfunction getStringAttributes(\n  data: Uint8Array,\n  offsetsData: Uint8Array,\n  stringsCount: number\n): string[] {\n  const stringsArray: string[] = [];\n  const textDecoder = new TextDecoder('utf8');\n\n  let stringOffset = 0;\n  const bytesPerStringSize = 4;\n\n  for (let index = 0; index < stringsCount; index++) {\n    // TODO check if it is multiplication on bytesPerStringSize is valid operation?\n    const stringByteSize =\n      offsetsData[(index + 1) * bytesPerStringSize] - offsetsData[index * bytesPerStringSize];\n    const stringData = data.subarray(stringOffset, stringByteSize + stringOffset);\n    const stringAttribute = textDecoder.decode(stringData);\n\n    stringsArray.push(stringAttribute);\n    stringOffset += stringByteSize;\n  }\n\n  return stringsArray;\n}\n"],"mappings":"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"}

package/dist/esm/lib/extensions/deprecated/KHR_lights_punctual.js

@@ -0,0 +1,42 @@
+import { assert } from '../../utils/assert';
+import GLTFScenegraph from '../../api/gltf-scenegraph';
+const KHR_LIGHTS_PUNCTUAL = 'KHR_lights_punctual';
+export const name = KHR_LIGHTS_PUNCTUAL;
+export async function decode(gltfData) {
+  const gltfScenegraph = new GLTFScenegraph(gltfData);
+  const {
+    json
+  } = gltfScenegraph;
+  const extension = gltfScenegraph.getExtension(KHR_LIGHTS_PUNCTUAL);
+  if (extension) {
+    gltfScenegraph.json.lights = extension.lights;
+    gltfScenegraph.removeExtension(KHR_LIGHTS_PUNCTUAL);
+  }
+  for (const node of json.nodes || []) {
+    const nodeExtension = gltfScenegraph.getObjectExtension(node, KHR_LIGHTS_PUNCTUAL);
+    if (nodeExtension) {
+      node.light = nodeExtension.light;
+    }
+    gltfScenegraph.removeObjectExtension(node, KHR_LIGHTS_PUNCTUAL);
+  }
+}
+export async function encode(gltfData) {
+  const gltfScenegraph = new GLTFScenegraph(gltfData);
+  const {
+    json
+  } = gltfScenegraph;
+  if (json.lights) {
+    const extension = gltfScenegraph.addExtension(KHR_LIGHTS_PUNCTUAL);
+    assert(!extension.lights);
+    extension.lights = json.lights;
+    delete json.lights;
+  }
+  if (gltfScenegraph.json.lights) {
+    for (const light of gltfScenegraph.json.lights) {
+      const node = light.node;
+      gltfScenegraph.addObjectExtension(node, KHR_LIGHTS_PUNCTUAL, light);
+    }
+    delete gltfScenegraph.json.lights;
+  }
+}
+//# sourceMappingURL=KHR_lights_punctual.js.map

package/dist/esm/lib/extensions/deprecated/KHR_lights_punctual.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KHR_lights_punctual.js","names":["assert","GLTFScenegraph","KHR_LIGHTS_PUNCTUAL","name","decode","gltfData","gltfScenegraph","json","extension","getExtension","lights","removeExtension","node","nodes","nodeExtension","getObjectExtension","light","removeObjectExtension","encode","addExtension","addObjectExtension"],"sources":["../../../../../src/lib/extensions/deprecated/KHR_lights_punctual.ts"],"sourcesContent":["// GLTF EXTENSION: KHR_lights_punctual\n// https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual\n\nimport type {GLTF} from '../../types/gltf-types';\n\nimport {assert} from '../../utils/assert';\nimport GLTFScenegraph from '../../api/gltf-scenegraph';\n\nconst KHR_LIGHTS_PUNCTUAL = 'KHR_lights_punctual';\n\nexport const name = KHR_LIGHTS_PUNCTUAL;\n\nexport async function decode(gltfData: {json: GLTF}): Promise<void> {\n  const gltfScenegraph = new GLTFScenegraph(gltfData);\n  const {json} = gltfScenegraph;\n\n  // Move the light array out of the extension and remove the extension\n  const extension = gltfScenegraph.getExtension(KHR_LIGHTS_PUNCTUAL);\n  if (extension) {\n    // @ts-ignore\n    gltfScenegraph.json.lights = extension.lights;\n    gltfScenegraph.removeExtension(KHR_LIGHTS_PUNCTUAL);\n  }\n\n  // Any nodes that have the extension, add lights field pointing to light object\n  // and remove the extension\n  for (const node of json.nodes || []) {\n    const nodeExtension = gltfScenegraph.getObjectExtension(node, KHR_LIGHTS_PUNCTUAL);\n    if (nodeExtension) {\n      // @ts-ignore\n      node.light = nodeExtension.light;\n    }\n    gltfScenegraph.removeObjectExtension(node, KHR_LIGHTS_PUNCTUAL);\n  }\n}\n\n// Move the light ar ray out of the extension and remove the extension\nexport async function encode(gltfData): Promise<void> {\n  const gltfScenegraph = new GLTFScenegraph(gltfData);\n  const {json} = gltfScenegraph;\n\n  // @ts-ignore\n  if (json.lights) {\n    const extension = gltfScenegraph.addExtension(KHR_LIGHTS_PUNCTUAL);\n    // @ts-ignore\n    assert(!extension.lights);\n    // @ts-ignore\n    extension.lights = json.lights;\n    // @ts-ignore\n    delete json.lights;\n  }\n\n  // Any nodes that have lights field pointing to light object\n  // add the extension\n  // @ts-ignore\n  if (gltfScenegraph.json.lights) {\n    // @ts-ignore\n    for (const light of gltfScenegraph.json.lights) {\n      const node = light.node;\n      gltfScenegraph.addObjectExtension(node, KHR_LIGHTS_PUNCTUAL, light);\n    }\n    // @ts-ignore\n    delete gltfScenegraph.json.lights;\n  }\n}\n"],"mappings":"AAKA,SAAQA,MAAM,QAAO,oBAAoB;AACzC,OAAOC,cAAc,MAAM,2BAA2B;AAEtD,MAAMC,mBAAmB,GAAG,qBAAqB;AAEjD,OAAO,MAAMC,IAAI,GAAGD,mBAAmB;AAEvC,OAAO,eAAeE,MAAMA,CAACC,QAAsB,EAAiB;EAClE,MAAMC,cAAc,GAAG,IAAIL,cAAc,CAACI,QAAQ,CAAC;EACnD,MAAM;IAACE;EAAI,CAAC,GAAGD,cAAc;EAG7B,MAAME,SAAS,GAAGF,cAAc,CAACG,YAAY,CAACP,mBAAmB,CAAC;EAClE,IAAIM,SAAS,EAAE;IAEbF,cAAc,CAACC,IAAI,CAACG,MAAM,GAAGF,SAAS,CAACE,MAAM;IAC7CJ,cAAc,CAACK,eAAe,CAACT,mBAAmB,CAAC;EACrD;EAIA,KAAK,MAAMU,IAAI,IAAIL,IAAI,CAACM,KAAK,IAAI,EAAE,EAAE;IACnC,MAAMC,aAAa,GAAGR,cAAc,CAACS,kBAAkB,CAACH,IAAI,EAAEV,mBAAmB,CAAC;IAClF,IAAIY,aAAa,EAAE;MAEjBF,IAAI,CAACI,KAAK,GAAGF,aAAa,CAACE,KAAK;IAClC;IACAV,cAAc,CAACW,qBAAqB,CAACL,IAAI,EAAEV,mBAAmB,CAAC;EACjE;AACF;AAGA,OAAO,eAAegB,MAAMA,CAACb,QAAQ,EAAiB;EACpD,MAAMC,cAAc,GAAG,IAAIL,cAAc,CAACI,QAAQ,CAAC;EACnD,MAAM;IAACE;EAAI,CAAC,GAAGD,cAAc;EAG7B,IAAIC,IAAI,CAACG,MAAM,EAAE;IACf,MAAMF,SAAS,GAAGF,cAAc,CAACa,YAAY,CAACjB,mBAAmB,CAAC;IAElEF,MAAM,CAAC,CAACQ,SAAS,CAACE,MAAM,CAAC;IAEzBF,SAAS,CAACE,MAAM,GAAGH,IAAI,CAACG,MAAM;IAE9B,OAAOH,IAAI,CAACG,MAAM;EACpB;EAKA,IAAIJ,cAAc,CAACC,IAAI,CAACG,MAAM,EAAE;IAE9B,KAAK,MAAMM,KAAK,IAAIV,cAAc,CAACC,IAAI,CAACG,MAAM,EAAE;MAC9C,MAAME,IAAI,GAAGI,KAAK,CAACJ,IAAI;MACvBN,cAAc,CAACc,kBAAkB,CAACR,IAAI,EAAEV,mBAAmB,EAAEc,KAAK,CAAC;IACrE;IAEA,OAAOV,cAAc,CAACC,IAAI,CAACG,MAAM;EACnC;AACF"}

package/dist/esm/lib/extensions/deprecated/KHR_materials_unlit.js

@@ -0,0 +1,33 @@
+import GLTFScenegraph from '../../api/gltf-scenegraph';
+const KHR_MATERIALS_UNLIT = 'KHR_materials_unlit';
+export const name = KHR_MATERIALS_UNLIT;
+export async function decode(gltfData) {
+  const gltfScenegraph = new GLTFScenegraph(gltfData);
+  const {
+    json
+  } = gltfScenegraph;
+  for (const material of json.materials || []) {
+    const extension = material.extensions && material.extensions.KHR_materials_unlit;
+    if (extension) {
+      material.unlit = true;
+    }
+    gltfScenegraph.removeObjectExtension(material, KHR_MATERIALS_UNLIT);
+  }
+  gltfScenegraph.removeExtension(KHR_MATERIALS_UNLIT);
+}
+export function encode(gltfData) {
+  const gltfScenegraph = new GLTFScenegraph(gltfData);
+  const {
+    json
+  } = gltfScenegraph;
+  if (gltfScenegraph.materials) {
+    for (const material of json.materials || []) {
+      if (material.unlit) {
+        delete material.unlit;
+        gltfScenegraph.addObjectExtension(material, KHR_MATERIALS_UNLIT, {});
+        gltfScenegraph.addExtension(KHR_MATERIALS_UNLIT);
+      }
+    }
+  }
+}
+//# sourceMappingURL=KHR_materials_unlit.js.map

package/dist/esm/lib/extensions/deprecated/KHR_materials_unlit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KHR_materials_unlit.js","names":["GLTFScenegraph","KHR_MATERIALS_UNLIT","name","decode","gltfData","gltfScenegraph","json","material","materials","extension","extensions","KHR_materials_unlit","unlit","removeObjectExtension","removeExtension","encode","addObjectExtension","addExtension"],"sources":["../../../../../src/lib/extensions/deprecated/KHR_materials_unlit.ts"],"sourcesContent":["// GLTF EXTENSION: KHR_materials_unlit\n// https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit\n\nimport type {GLTF} from '../../types/gltf-types';\n\nimport GLTFScenegraph from '../../api/gltf-scenegraph';\n\nconst KHR_MATERIALS_UNLIT = 'KHR_materials_unlit';\n\nexport const name = KHR_MATERIALS_UNLIT;\n\nexport async function decode(gltfData: {json: GLTF}): Promise<void> {\n  const gltfScenegraph = new GLTFScenegraph(gltfData);\n  const {json} = gltfScenegraph;\n\n  // Any nodes that have the extension, add lights field pointing to light object\n  // and remove the extension\n  for (const material of json.materials || []) {\n    const extension = material.extensions && material.extensions.KHR_materials_unlit;\n    if (extension) {\n      // @ts-ignore TODO\n      material.unlit = true;\n    }\n    gltfScenegraph.removeObjectExtension(material, KHR_MATERIALS_UNLIT);\n  }\n\n  // Remove the top-level extension\n  gltfScenegraph.removeExtension(KHR_MATERIALS_UNLIT);\n}\n\nexport function encode(gltfData) {\n  const gltfScenegraph = new GLTFScenegraph(gltfData);\n  const {json} = gltfScenegraph;\n\n  // Any nodes that have lights field pointing to light object\n  // add the extension\n  // @ts-ignore\n  if (gltfScenegraph.materials) {\n    for (const material of json.materials || []) {\n      // @ts-ignore\n      if (material.unlit) {\n        // @ts-ignore\n        delete material.unlit;\n        gltfScenegraph.addObjectExtension(material, KHR_MATERIALS_UNLIT, {});\n        gltfScenegraph.addExtension(KHR_MATERIALS_UNLIT);\n      }\n    }\n  }\n}\n"],"mappings":"AAKA,OAAOA,cAAc,MAAM,2BAA2B;AAEtD,MAAMC,mBAAmB,GAAG,qBAAqB;AAEjD,OAAO,MAAMC,IAAI,GAAGD,mBAAmB;AAEvC,OAAO,eAAeE,MAAMA,CAACC,QAAsB,EAAiB;EAClE,MAAMC,cAAc,GAAG,IAAIL,cAAc,CAACI,QAAQ,CAAC;EACnD,MAAM;IAACE;EAAI,CAAC,GAAGD,cAAc;EAI7B,KAAK,MAAME,QAAQ,IAAID,IAAI,CAACE,SAAS,IAAI,EAAE,EAAE;IAC3C,MAAMC,SAAS,GAAGF,QAAQ,CAACG,UAAU,IAAIH,QAAQ,CAACG,UAAU,CAACC,mBAAmB;IAChF,IAAIF,SAAS,EAAE;MAEbF,QAAQ,CAACK,KAAK,GAAG,IAAI;IACvB;IACAP,cAAc,CAACQ,qBAAqB,CAACN,QAAQ,EAAEN,mBAAmB,CAAC;EACrE;EAGAI,cAAc,CAACS,eAAe,CAACb,mBAAmB,CAAC;AACrD;AAEA,OAAO,SAASc,MAAMA,CAACX,QAAQ,EAAE;EAC/B,MAAMC,cAAc,GAAG,IAAIL,cAAc,CAACI,QAAQ,CAAC;EACnD,MAAM;IAACE;EAAI,CAAC,GAAGD,cAAc;EAK7B,IAAIA,cAAc,CAACG,SAAS,EAAE;IAC5B,KAAK,MAAMD,QAAQ,IAAID,IAAI,CAACE,SAAS,IAAI,EAAE,EAAE;MAE3C,IAAID,QAAQ,CAACK,KAAK,EAAE;QAElB,OAAOL,QAAQ,CAACK,KAAK;QACrBP,cAAc,CAACW,kBAAkB,CAACT,QAAQ,EAAEN,mBAAmB,EAAE,CAAC,CAAC,CAAC;QACpEI,cAAc,CAACY,YAAY,CAAChB,mBAAmB,CAAC;MAClD;IACF;EACF;AACF"}

package/dist/esm/lib/extensions/deprecated/KHR_techniques_webgl.js

@@ -0,0 +1,61 @@
+import GLTFScenegraph from '../../api/gltf-scenegraph';
+const KHR_TECHNIQUES_WEBGL = 'KHR_techniques_webgl';
+export const name = KHR_TECHNIQUES_WEBGL;
+export async function decode(gltfData) {
+  const gltfScenegraph = new GLTFScenegraph(gltfData);
+  const {
+    json
+  } = gltfScenegraph;
+  const extension = gltfScenegraph.getExtension(KHR_TECHNIQUES_WEBGL);
+  if (extension) {
+    const techniques = resolveTechniques(extension, gltfScenegraph);
+    for (const material of json.materials || []) {
+      const materialExtension = gltfScenegraph.getObjectExtension(material, KHR_TECHNIQUES_WEBGL);
+      if (materialExtension) {
+        material.technique = Object.assign({}, materialExtension, techniques[materialExtension.technique]);
+        material.technique.values = resolveValues(material.technique, gltfScenegraph);
+      }
+      gltfScenegraph.removeObjectExtension(material, KHR_TECHNIQUES_WEBGL);
+    }
+    gltfScenegraph.removeExtension(KHR_TECHNIQUES_WEBGL);
+  }
+}
+export async function encode(gltfData, options) {}
+function resolveTechniques(techniquesExtension, gltfScenegraph) {
+  const {
+    programs = [],
+    shaders = [],
+    techniques = []
+  } = techniquesExtension;
+  const textDecoder = new TextDecoder();
+  shaders.forEach(shader => {
+    if (Number.isFinite(shader.bufferView)) {
+      shader.code = textDecoder.decode(gltfScenegraph.getTypedArrayForBufferView(shader.bufferView));
+    } else {
+      throw new Error('KHR_techniques_webgl: no shader code');
+    }
+  });
+  programs.forEach(program => {
+    program.fragmentShader = shaders[program.fragmentShader];
+    program.vertexShader = shaders[program.vertexShader];
+  });
+  techniques.forEach(technique => {
+    technique.program = programs[technique.program];
+  });
+  return techniques;
+}
+function resolveValues(technique, gltfScenegraph) {
+  const values = Object.assign({}, technique.values);
+  Object.keys(technique.uniforms || {}).forEach(uniform => {
+    if (technique.uniforms[uniform].value && !(uniform in values)) {
+      values[uniform] = technique.uniforms[uniform].value;
+    }
+  });
+  Object.keys(values).forEach(uniform => {
+    if (typeof values[uniform] === 'object' && values[uniform].index !== undefined) {
+      values[uniform].texture = gltfScenegraph.getTexture(values[uniform].index);
+    }
+  });
+  return values;
+}
+//# sourceMappingURL=KHR_techniques_webgl.js.map

package/dist/esm/lib/extensions/deprecated/KHR_techniques_webgl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KHR_techniques_webgl.js","names":["GLTFScenegraph","KHR_TECHNIQUES_WEBGL","name","decode","gltfData","gltfScenegraph","json","extension","getExtension","techniques","resolveTechniques","material","materials","materialExtension","getObjectExtension","technique","Object","assign","values","resolveValues","removeObjectExtension","removeExtension","encode","options","techniquesExtension","programs","shaders","textDecoder","TextDecoder","forEach","shader","Number","isFinite","bufferView","code","getTypedArrayForBufferView","Error","program","fragmentShader","vertexShader","keys","uniforms","uniform","value","index","undefined","texture","getTexture"],"sources":["../../../../../src/lib/extensions/deprecated/KHR_techniques_webgl.ts"],"sourcesContent":["// GLTF EXTENSION: KHR_techniques_webgl\n// https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_techniques_webgl\n\nimport type {GLTF} from '../../types/gltf-types';\n\nimport GLTFScenegraph from '../../api/gltf-scenegraph';\n\nconst KHR_TECHNIQUES_WEBGL = 'KHR_techniques_webgl';\n\nexport const name = KHR_TECHNIQUES_WEBGL;\n\nexport async function decode(gltfData: {json: GLTF}): Promise<void> {\n  const gltfScenegraph = new GLTFScenegraph(gltfData);\n  const {json} = gltfScenegraph;\n\n  const extension = gltfScenegraph.getExtension(KHR_TECHNIQUES_WEBGL);\n  if (extension) {\n    const techniques = resolveTechniques(extension, gltfScenegraph);\n\n    for (const material of json.materials || []) {\n      const materialExtension = gltfScenegraph.getObjectExtension(material, KHR_TECHNIQUES_WEBGL);\n      if (materialExtension) {\n        // @ts-ignore TODO\n        material.technique = Object.assign(\n          {},\n          materialExtension,\n          // @ts-ignore\n          techniques[materialExtension.technique]\n        );\n        // @ts-ignore TODO\n        material.technique.values = resolveValues(material.technique, gltfScenegraph);\n      }\n      gltfScenegraph.removeObjectExtension(material, KHR_TECHNIQUES_WEBGL);\n    }\n\n    // Remove the top-level extension\n    gltfScenegraph.removeExtension(KHR_TECHNIQUES_WEBGL);\n  }\n}\n// eslint-disable-next-line\nexport async function encode(gltfData, options): Promise<void> {\n  // TODO\n}\n\nfunction resolveTechniques(\n  techniquesExtension: {[key: string]: any},\n  // programs: {[key: string]: any}[],\n  // shaders: {[key: string]: any}[],\n  // techniques: {[key: string]: any}[]\n  gltfScenegraph\n) {\n  const {programs = [], shaders = [], techniques = []} = techniquesExtension;\n  const textDecoder = new TextDecoder();\n\n  shaders.forEach((shader) => {\n    if (Number.isFinite(shader.bufferView)) {\n      shader.code = textDecoder.decode(\n        gltfScenegraph.getTypedArrayForBufferView(shader.bufferView)\n      );\n    } else {\n      // TODO: handle URI shader\n      throw new Error('KHR_techniques_webgl: no shader code');\n    }\n  });\n\n  programs.forEach((program) => {\n    program.fragmentShader = shaders[program.fragmentShader];\n    program.vertexShader = shaders[program.vertexShader];\n  });\n\n  techniques.forEach((technique) => {\n    technique.program = programs[technique.program];\n  });\n\n  return techniques;\n}\n\nfunction resolveValues(technique, gltfScenegraph) {\n  const values = Object.assign({}, technique.values);\n\n  // merge values from uniforms\n  Object.keys(technique.uniforms || {}).forEach((uniform) => {\n    if (technique.uniforms[uniform].value && !(uniform in values)) {\n      values[uniform] = technique.uniforms[uniform].value;\n    }\n  });\n\n  // resolve textures\n  Object.keys(values).forEach((uniform) => {\n    if (typeof values[uniform] === 'object' && values[uniform].index !== undefined) {\n      // Assume this is a texture\n      // TODO: find if there are any other types that can be referenced\n      values[uniform].texture = gltfScenegraph.getTexture(values[uniform].index);\n    }\n  });\n\n  return values;\n}\n"],"mappings":"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"}

package/dist/esm/lib/gltf-utils/get-typed-array.js

@@ -0,0 +1,16 @@
+import { assert } from '../utils/assert';
+export function getTypedArrayForBufferView(json, buffers, bufferViewIndex) {
+  const bufferView = json.bufferViews[bufferViewIndex];
+  assert(bufferView);
+  const bufferIndex = bufferView.buffer;
+  const binChunk = buffers[bufferIndex];
+  assert(binChunk);
+  const byteOffset = (bufferView.byteOffset || 0) + binChunk.byteOffset;
+  return new Uint8Array(binChunk.arrayBuffer, byteOffset, bufferView.byteLength);
+}
+export function getTypedArrayForImageData(json, buffers, imageIndex) {
+  const image = json.images[imageIndex];
+  const bufferViewIndex = json.bufferViews[image.bufferView];
+  return getTypedArrayForBufferView(json, buffers, bufferViewIndex);
+}
+//# sourceMappingURL=get-typed-array.js.map

package/dist/esm/lib/gltf-utils/get-typed-array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-typed-array.js","names":["assert","getTypedArrayForBufferView","json","buffers","bufferViewIndex","bufferView","bufferViews","bufferIndex","buffer","binChunk","byteOffset","Uint8Array","arrayBuffer","byteLength","getTypedArrayForImageData","imageIndex","image","images"],"sources":["../../../../src/lib/gltf-utils/get-typed-array.ts"],"sourcesContent":["// TODO - GLTFScenegraph should use these\nimport {assert} from '../utils/assert';\n\n// accepts buffer view index or buffer view object\n// returns a `Uint8Array`\nexport function getTypedArrayForBufferView(json, buffers, bufferViewIndex) {\n  const bufferView = json.bufferViews[bufferViewIndex];\n  assert(bufferView);\n\n  // Get hold of the arrayBuffer\n  const bufferIndex = bufferView.buffer;\n  const binChunk = buffers[bufferIndex];\n  assert(binChunk);\n\n  const byteOffset = (bufferView.byteOffset || 0) + binChunk.byteOffset;\n  return new Uint8Array(binChunk.arrayBuffer, byteOffset, bufferView.byteLength);\n}\n\n// accepts accessor index or accessor object\n// returns a `Uint8Array`\nexport function getTypedArrayForImageData(json, buffers, imageIndex) {\n  const image = json.images[imageIndex];\n  const bufferViewIndex = json.bufferViews[image.bufferView];\n  return getTypedArrayForBufferView(json, buffers, bufferViewIndex);\n}\n\n/*\n// accepts accessor index or accessor object\n// returns a typed array with type that matches the types\nexport function getTypedArrayForAccessor(accessor) {\n  accessor = this.getAccessor(accessor);\n  const bufferView = this.getBufferView(accessor.bufferView);\n  const buffer = this.getBuffer(bufferView.buffer);\n  const arrayBuffer = buffer.data;\n\n  // Create a new typed array as a view into the combined buffer\n  const {ArrayType, length} = getAccessorArrayTypeAndLength(accessor, bufferView);\n  const byteOffset = bufferView.byteOffset + accessor.byteOffset;\n  return new ArrayType(arrayBuffer, byteOffset, length);\n}\n*/\n"],"mappings":"AACA,SAAQA,MAAM,QAAO,iBAAiB;AAItC,OAAO,SAASC,0BAA0BA,CAACC,IAAI,EAAEC,OAAO,EAAEC,eAAe,EAAE;EACzE,MAAMC,UAAU,GAAGH,IAAI,CAACI,WAAW,CAACF,eAAe,CAAC;EACpDJ,MAAM,CAACK,UAAU,CAAC;EAGlB,MAAME,WAAW,GAAGF,UAAU,CAACG,MAAM;EACrC,MAAMC,QAAQ,GAAGN,OAAO,CAACI,WAAW,CAAC;EACrCP,MAAM,CAACS,QAAQ,CAAC;EAEhB,MAAMC,UAAU,GAAG,CAACL,UAAU,CAACK,UAAU,IAAI,CAAC,IAAID,QAAQ,CAACC,UAAU;EACrE,OAAO,IAAIC,UAAU,CAACF,QAAQ,CAACG,WAAW,EAAEF,UAAU,EAAEL,UAAU,CAACQ,UAAU,CAAC;AAChF;AAIA,OAAO,SAASC,yBAAyBA,CAACZ,IAAI,EAAEC,OAAO,EAAEY,UAAU,EAAE;EACnE,MAAMC,KAAK,GAAGd,IAAI,CAACe,MAAM,CAACF,UAAU,CAAC;EACrC,MAAMX,eAAe,GAAGF,IAAI,CAACI,WAAW,CAACU,KAAK,CAACX,UAAU,CAAC;EAC1D,OAAOJ,0BAA0B,CAACC,IAAI,EAAEC,OAAO,EAAEC,eAAe,CAAC;AACnE"}

package/dist/esm/lib/gltf-utils/gltf-attribute-utils.js

@@ -0,0 +1,62 @@
+import { getAccessorTypeFromSize, getComponentTypeFromArray } from './gltf-utils';
+export function getGLTFAccessors(attributes) {
+  const accessors = {};
+  for (const name in attributes) {
+    const attribute = attributes[name];
+    if (name !== 'indices') {
+      const glTFAccessor = getGLTFAccessor(attribute);
+      accessors[name] = glTFAccessor;
+    }
+  }
+  return accessors;
+}
+export function getGLTFAccessor(attribute) {
+  const {
+    buffer,
+    size,
+    count
+  } = getAccessorData(attribute);
+  const glTFAccessor = {
+    value: buffer,
+    size,
+    byteOffset: 0,
+    count,
+    type: getAccessorTypeFromSize(size),
+    componentType: getComponentTypeFromArray(buffer)
+  };
+  return glTFAccessor;
+}
+function getAccessorData(attribute) {
+  let buffer = attribute;
+  let size = 1;
+  let count = 0;
+  if (attribute && attribute.value) {
+    buffer = attribute.value;
+    size = attribute.size || 1;
+  }
+  if (buffer) {
+    if (!ArrayBuffer.isView(buffer)) {
+      buffer = toTypedArray(buffer, Float32Array);
+    }
+    count = buffer.length / size;
+  }
+  return {
+    buffer,
+    size,
+    count
+  };
+}
+function toTypedArray(array, ArrayType) {
+  let convertTypedArrays = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  if (!array) {
+    return null;
+  }
+  if (Array.isArray(array)) {
+    return new ArrayType(array);
+  }
+  if (convertTypedArrays && !(array instanceof ArrayType)) {
+    return new ArrayType(array);
+  }
+  return array;
+}
+//# sourceMappingURL=gltf-attribute-utils.js.map

package/dist/esm/lib/gltf-utils/gltf-attribute-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-attribute-utils.js","names":["getAccessorTypeFromSize","getComponentTypeFromArray","getGLTFAccessors","attributes","accessors","name","attribute","glTFAccessor","getGLTFAccessor","buffer","size","count","getAccessorData","value","byteOffset","type","componentType","ArrayBuffer","isView","toTypedArray","Float32Array","length","array","ArrayType","convertTypedArrays","arguments","undefined","Array","isArray"],"sources":["../../../../src/lib/gltf-utils/gltf-attribute-utils.ts"],"sourcesContent":["// import type {TypedArray} from '../types/loader-utils';\nimport type {GLTFAccessor} from '../types/gltf-types';\n// TODO - remove\nimport {getAccessorTypeFromSize, getComponentTypeFromArray} from './gltf-utils';\n\n// Returns a fresh attributes object with glTF-standardized attributes names\n// Attributes that cannot be identified will not be included\n// Removes `indices` if present, as it should be stored separately from the attributes\nexport function getGLTFAccessors(attributes): {[key: string]: GLTFAccessor} {\n  const accessors = {};\n  for (const name in attributes) {\n    const attribute = attributes[name];\n    if (name !== 'indices') {\n      const glTFAccessor = getGLTFAccessor(attribute);\n      accessors[name] = glTFAccessor;\n    }\n  }\n  return accessors;\n}\n\n// Fix up a single accessor.\n// Input: typed array or a partial accessor object\n// Return: accessor object\nexport function getGLTFAccessor(attribute) {\n  const {buffer, size, count} = getAccessorData(attribute);\n\n  const glTFAccessor: GLTFAccessor = {\n    // glTF Accessor values\n    // TODO: Instead of a bufferView index we could have an actual buffer (typed array)\n    // bufferView: null,\n    // TODO: Deprecate `value` in favor of bufferView?\n    // @ts-ignore\n    value: buffer,\n    size, // Decoded `type` (e.g. SCALAR)\n\n    byteOffset: 0,\n    count,\n    type: getAccessorTypeFromSize(size),\n    componentType: getComponentTypeFromArray(buffer)\n  };\n\n  return glTFAccessor;\n}\n\n// export function getGLTFAttribute(data, gltfAttributeName): GLTFAccessor {\n//   return data.attributes[data.glTFAttributeMap[gltfAttributeName]];\n// }\n\nfunction getAccessorData(attribute) {\n  let buffer = attribute;\n  let size = 1;\n  let count = 0;\n\n  if (attribute && attribute.value) {\n    buffer = attribute.value;\n    size = attribute.size || 1;\n  }\n\n  if (buffer) {\n    if (!ArrayBuffer.isView(buffer)) {\n      buffer = toTypedArray(buffer, Float32Array);\n    }\n    count = buffer.length / size;\n  }\n\n  return {buffer, size, count};\n}\n\n// Convert non-typed arrays to arrays of specified format\nfunction toTypedArray(array, ArrayType, convertTypedArrays = false) {\n  if (!array) {\n    return null;\n  }\n  if (Array.isArray(array)) {\n    return new ArrayType(array);\n  }\n  if (convertTypedArrays && !(array instanceof ArrayType)) {\n    return new ArrayType(array);\n  }\n  return array;\n}\n"],"mappings":"AAGA,SAAQA,uBAAuB,EAAEC,yBAAyB,QAAO,cAAc;AAK/E,OAAO,SAASC,gBAAgBA,CAACC,UAAU,EAAiC;EAC1E,MAAMC,SAAS,GAAG,CAAC,CAAC;EACpB,KAAK,MAAMC,IAAI,IAAIF,UAAU,EAAE;IAC7B,MAAMG,SAAS,GAAGH,UAAU,CAACE,IAAI,CAAC;IAClC,IAAIA,IAAI,KAAK,SAAS,EAAE;MACtB,MAAME,YAAY,GAAGC,eAAe,CAACF,SAAS,CAAC;MAC/CF,SAAS,CAACC,IAAI,CAAC,GAAGE,YAAY;IAChC;EACF;EACA,OAAOH,SAAS;AAClB;AAKA,OAAO,SAASI,eAAeA,CAACF,SAAS,EAAE;EACzC,MAAM;IAACG,MAAM;IAAEC,IAAI;IAAEC;EAAK,CAAC,GAAGC,eAAe,CAACN,SAAS,CAAC;EAExD,MAAMC,YAA0B,GAAG;IAMjCM,KAAK,EAAEJ,MAAM;IACbC,IAAI;IAEJI,UAAU,EAAE,CAAC;IACbH,KAAK;IACLI,IAAI,EAAEf,uBAAuB,CAACU,IAAI,CAAC;IACnCM,aAAa,EAAEf,yBAAyB,CAACQ,MAAM;EACjD,CAAC;EAED,OAAOF,YAAY;AACrB;AAMA,SAASK,eAAeA,CAACN,SAAS,EAAE;EAClC,IAAIG,MAAM,GAAGH,SAAS;EACtB,IAAII,IAAI,GAAG,CAAC;EACZ,IAAIC,KAAK,GAAG,CAAC;EAEb,IAAIL,SAAS,IAAIA,SAAS,CAACO,KAAK,EAAE;IAChCJ,MAAM,GAAGH,SAAS,CAACO,KAAK;IACxBH,IAAI,GAAGJ,SAAS,CAACI,IAAI,IAAI,CAAC;EAC5B;EAEA,IAAID,MAAM,EAAE;IACV,IAAI,CAACQ,WAAW,CAACC,MAAM,CAACT,MAAM,CAAC,EAAE;MAC/BA,MAAM,GAAGU,YAAY,CAACV,MAAM,EAAEW,YAAY,CAAC;IAC7C;IACAT,KAAK,GAAGF,MAAM,CAACY,MAAM,GAAGX,IAAI;EAC9B;EAEA,OAAO;IAACD,MAAM;IAAEC,IAAI;IAAEC;EAAK,CAAC;AAC9B;AAGA,SAASQ,YAAYA,CAACG,KAAK,EAAEC,SAAS,EAA8B;EAAA,IAA5BC,kBAAkB,GAAAC,SAAA,CAAAJ,MAAA,QAAAI,SAAA,QAAAC,SAAA,GAAAD,SAAA,MAAG,KAAK;EAChE,IAAI,CAACH,KAAK,EAAE;IACV,OAAO,IAAI;EACb;EACA,IAAIK,KAAK,CAACC,OAAO,CAACN,KAAK,CAAC,EAAE;IACxB,OAAO,IAAIC,SAAS,CAACD,KAAK,CAAC;EAC7B;EACA,IAAIE,kBAAkB,IAAI,EAAEF,KAAK,YAAYC,SAAS,CAAC,EAAE;IACvD,OAAO,IAAIA,SAAS,CAACD,KAAK,CAAC;EAC7B;EACA,OAAOA,KAAK;AACd"}

package/dist/esm/lib/gltf-utils/gltf-constants.js

@@ -0,0 +1,37 @@
+export const COMPONENTS = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+};
+export const BYTES = {
+  5120: 1,
+  5121: 1,
+  5122: 2,
+  5123: 2,
+  5125: 4,
+  5126: 4
+};
+export function getBytesFromComponentType(componentType) {
+  return BYTES[componentType];
+}
+export function getSizeFromAccessorType(type) {
+  return COMPONENTS[type];
+}
+export function getGLEnumFromSamplerParameter(parameter) {
+  const GL_TEXTURE_MAG_FILTER = 0x2800;
+  const GL_TEXTURE_MIN_FILTER = 0x2801;
+  const GL_TEXTURE_WRAP_S = 0x2802;
+  const GL_TEXTURE_WRAP_T = 0x2803;
+  const PARAMETER_MAP = {
+    magFilter: GL_TEXTURE_MAG_FILTER,
+    minFilter: GL_TEXTURE_MIN_FILTER,
+    wrapS: GL_TEXTURE_WRAP_S,
+    wrapT: GL_TEXTURE_WRAP_T
+  };
+  return PARAMETER_MAP[parameter];
+}
+//# sourceMappingURL=gltf-constants.js.map

package/dist/esm/lib/gltf-utils/gltf-constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-constants.js","names":["COMPONENTS","SCALAR","VEC2","VEC3","VEC4","MAT2","MAT3","MAT4","BYTES","getBytesFromComponentType","componentType","getSizeFromAccessorType","type","getGLEnumFromSamplerParameter","parameter","GL_TEXTURE_MAG_FILTER","GL_TEXTURE_MIN_FILTER","GL_TEXTURE_WRAP_S","GL_TEXTURE_WRAP_T","PARAMETER_MAP","magFilter","minFilter","wrapS","wrapT"],"sources":["../../../../src/lib/gltf-utils/gltf-constants.ts"],"sourcesContent":["export const COMPONENTS = {\n  SCALAR: 1,\n  VEC2: 2,\n  VEC3: 3,\n  VEC4: 4,\n  MAT2: 4,\n  MAT3: 9,\n  MAT4: 16\n};\n\nexport const BYTES = {\n  5120: 1, // BYTE\n  5121: 1, // UNSIGNED_BYTE\n  5122: 2, // SHORT\n  5123: 2, // UNSIGNED_SHORT\n  5125: 4, // UNSIGNED_INT\n  5126: 4 // FLOAT\n};\n\n// ENUM LOOKUP\n\nexport function getBytesFromComponentType(componentType) {\n  return BYTES[componentType];\n}\n\nexport function getSizeFromAccessorType(type) {\n  return COMPONENTS[type];\n}\n\nexport function getGLEnumFromSamplerParameter(parameter) {\n  const GL_TEXTURE_MAG_FILTER = 0x2800;\n  const GL_TEXTURE_MIN_FILTER = 0x2801;\n  const GL_TEXTURE_WRAP_S = 0x2802;\n  const GL_TEXTURE_WRAP_T = 0x2803;\n\n  const PARAMETER_MAP = {\n    magFilter: GL_TEXTURE_MAG_FILTER,\n    minFilter: GL_TEXTURE_MIN_FILTER,\n    wrapS: GL_TEXTURE_WRAP_S,\n    wrapT: GL_TEXTURE_WRAP_T\n  };\n\n  return PARAMETER_MAP[parameter];\n}\n"],"mappings":"AAAA,OAAO,MAAMA,UAAU,GAAG;EACxBC,MAAM,EAAE,CAAC;EACTC,IAAI,EAAE,CAAC;EACPC,IAAI,EAAE,CAAC;EACPC,IAAI,EAAE,CAAC;EACPC,IAAI,EAAE,CAAC;EACPC,IAAI,EAAE,CAAC;EACPC,IAAI,EAAE;AACR,CAAC;AAED,OAAO,MAAMC,KAAK,GAAG;EACnB,IAAI,EAAE,CAAC;EACP,IAAI,EAAE,CAAC;EACP,IAAI,EAAE,CAAC;EACP,IAAI,EAAE,CAAC;EACP,IAAI,EAAE,CAAC;EACP,IAAI,EAAE;AACR,CAAC;AAID,OAAO,SAASC,yBAAyBA,CAACC,aAAa,EAAE;EACvD,OAAOF,KAAK,CAACE,aAAa,CAAC;AAC7B;AAEA,OAAO,SAASC,uBAAuBA,CAACC,IAAI,EAAE;EAC5C,OAAOZ,UAAU,CAACY,IAAI,CAAC;AACzB;AAEA,OAAO,SAASC,6BAA6BA,CAACC,SAAS,EAAE;EACvD,MAAMC,qBAAqB,GAAG,MAAM;EACpC,MAAMC,qBAAqB,GAAG,MAAM;EACpC,MAAMC,iBAAiB,GAAG,MAAM;EAChC,MAAMC,iBAAiB,GAAG,MAAM;EAEhC,MAAMC,aAAa,GAAG;IACpBC,SAAS,EAAEL,qBAAqB;IAChCM,SAAS,EAAEL,qBAAqB;IAChCM,KAAK,EAAEL,iBAAiB;IACxBM,KAAK,EAAEL;EACT,CAAC;EAED,OAAOC,aAAa,CAACL,SAAS,CAAC;AACjC"}

package/dist/esm/lib/gltf-utils/gltf-utils.js

@@ -0,0 +1,54 @@
+import { assert } from '../utils/assert';
+const TYPES = ['SCALAR', 'VEC2', 'VEC3', 'VEC4'];
+const ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT = [[Int8Array, 5120], [Uint8Array, 5121], [Int16Array, 5122], [Uint16Array, 5123], [Uint32Array, 5125], [Float32Array, 5126], [Float64Array, 5130]];
+const ARRAY_TO_COMPONENT_TYPE = new Map(ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT);
+const ATTRIBUTE_TYPE_TO_COMPONENTS = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+};
+const ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE = {
+  5120: 1,
+  5121: 1,
+  5122: 2,
+  5123: 2,
+  5125: 4,
+  5126: 4
+};
+const ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {
+  5120: Int8Array,
+  5121: Uint8Array,
+  5122: Int16Array,
+  5123: Uint16Array,
+  5125: Uint32Array,
+  5126: Float32Array
+};
+export function getAccessorTypeFromSize(size) {
+  const type = TYPES[size - 1];
+  return type || TYPES[0];
+}
+export function getComponentTypeFromArray(typedArray) {
+  const componentType = ARRAY_TO_COMPONENT_TYPE.get(typedArray.constructor);
+  if (!componentType) {
+    throw new Error('Illegal typed array');
+  }
+  return componentType;
+}
+export function getAccessorArrayTypeAndLength(accessor, bufferView) {
+  const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];
+  const components = ATTRIBUTE_TYPE_TO_COMPONENTS[accessor.type];
+  const bytesPerComponent = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[accessor.componentType];
+  const length = accessor.count * components;
+  const byteLength = accessor.count * components * bytesPerComponent;
+  assert(byteLength >= 0 && byteLength <= bufferView.byteLength);
+  return {
+    ArrayType,
+    length,
+    byteLength
+  };
+}
+//# sourceMappingURL=gltf-utils.js.map

package/dist/esm/lib/gltf-utils/gltf-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-utils.js","names":["assert","TYPES","ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT","Int8Array","Uint8Array","Int16Array","Uint16Array","Uint32Array","Float32Array","Float64Array","ARRAY_TO_COMPONENT_TYPE","Map","ATTRIBUTE_TYPE_TO_COMPONENTS","SCALAR","VEC2","VEC3","VEC4","MAT2","MAT3","MAT4","ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE","ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY","getAccessorTypeFromSize","size","type","getComponentTypeFromArray","typedArray","componentType","get","constructor","Error","getAccessorArrayTypeAndLength","accessor","bufferView","ArrayType","components","bytesPerComponent","length","count","byteLength"],"sources":["../../../../src/lib/gltf-utils/gltf-utils.ts"],"sourcesContent":["import {assert} from '../utils/assert';\n\nconst TYPES = ['SCALAR', 'VEC2', 'VEC3', 'VEC4'];\n\ntype TypedArrayConstructor =\n  | Int8ArrayConstructor\n  | Uint8ArrayConstructor\n  | Int16ArrayConstructor\n  | Uint16ArrayConstructor\n  | Int32ArrayConstructor\n  | Uint32ArrayConstructor\n  | Int32ArrayConstructor\n  | Uint32ArrayConstructor\n  | Float32ArrayConstructor\n  | Float64ArrayConstructor;\n\nconst ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT: [TypedArrayConstructor, number][] = [\n  [Int8Array, 5120],\n  [Uint8Array, 5121],\n  [Int16Array, 5122],\n  [Uint16Array, 5123],\n  [Uint32Array, 5125],\n  [Float32Array, 5126],\n  [Float64Array, 5130]\n];\nconst ARRAY_TO_COMPONENT_TYPE = new Map<TypedArrayConstructor, number>(\n  ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT\n);\n\nconst ATTRIBUTE_TYPE_TO_COMPONENTS = {\n  SCALAR: 1,\n  VEC2: 2,\n  VEC3: 3,\n  VEC4: 4,\n  MAT2: 4,\n  MAT3: 9,\n  MAT4: 16\n};\n\nconst ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE = {\n  5120: 1,\n  5121: 1,\n  5122: 2,\n  5123: 2,\n  5125: 4,\n  5126: 4\n};\n\nconst ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {\n  5120: Int8Array,\n  5121: Uint8Array,\n  5122: Int16Array,\n  5123: Uint16Array,\n  5125: Uint32Array,\n  5126: Float32Array\n};\n\nexport function getAccessorTypeFromSize(size) {\n  const type = TYPES[size - 1];\n  return type || TYPES[0];\n}\n\nexport function getComponentTypeFromArray(typedArray) {\n  const componentType = ARRAY_TO_COMPONENT_TYPE.get(typedArray.constructor);\n  if (!componentType) {\n    throw new Error('Illegal typed array');\n  }\n  return componentType;\n}\n\nexport function getAccessorArrayTypeAndLength(accessor, bufferView) {\n  const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];\n  const components = ATTRIBUTE_TYPE_TO_COMPONENTS[accessor.type];\n  const bytesPerComponent = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[accessor.componentType];\n  const length = accessor.count * components;\n  const byteLength = accessor.count * components * bytesPerComponent;\n  assert(byteLength >= 0 && byteLength <= bufferView.byteLength);\n  return {ArrayType, length, byteLength};\n}\n"],"mappings":"AAAA,SAAQA,MAAM,QAAO,iBAAiB;AAEtC,MAAMC,KAAK,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;AAchD,MAAMC,mCAAsE,GAAG,CAC7E,CAACC,SAAS,EAAE,IAAI,CAAC,EACjB,CAACC,UAAU,EAAE,IAAI,CAAC,EAClB,CAACC,UAAU,EAAE,IAAI,CAAC,EAClB,CAACC,WAAW,EAAE,IAAI,CAAC,EACnB,CAACC,WAAW,EAAE,IAAI,CAAC,EACnB,CAACC,YAAY,EAAE,IAAI,CAAC,EACpB,CAACC,YAAY,EAAE,IAAI,CAAC,CACrB;AACD,MAAMC,uBAAuB,GAAG,IAAIC,GAAG,CACrCT,mCACF,CAAC;AAED,MAAMU,4BAA4B,GAAG;EACnCC,MAAM,EAAE,CAAC;EACTC,IAAI,EAAE,CAAC;EACPC,IAAI,EAAE,CAAC;EACPC,IAAI,EAAE,CAAC;EACPC,IAAI,EAAE,CAAC;EACPC,IAAI,EAAE,CAAC;EACPC,IAAI,EAAE;AACR,CAAC;AAED,MAAMC,qCAAqC,GAAG;EAC5C,IAAI,EAAE,CAAC;EACP,IAAI,EAAE,CAAC;EACP,IAAI,EAAE,CAAC;EACP,IAAI,EAAE,CAAC;EACP,IAAI,EAAE,CAAC;EACP,IAAI,EAAE;AACR,CAAC;AAED,MAAMC,iCAAiC,GAAG;EACxC,IAAI,EAAElB,SAAS;EACf,IAAI,EAAEC,UAAU;EAChB,IAAI,EAAEC,UAAU;EAChB,IAAI,EAAEC,WAAW;EACjB,IAAI,EAAEC,WAAW;EACjB,IAAI,EAAEC;AACR,CAAC;AAED,OAAO,SAASc,uBAAuBA,CAACC,IAAI,EAAE;EAC5C,MAAMC,IAAI,GAAGvB,KAAK,CAACsB,IAAI,GAAG,CAAC,CAAC;EAC5B,OAAOC,IAAI,IAAIvB,KAAK,CAAC,CAAC,CAAC;AACzB;AAEA,OAAO,SAASwB,yBAAyBA,CAACC,UAAU,EAAE;EACpD,MAAMC,aAAa,GAAGjB,uBAAuB,CAACkB,GAAG,CAACF,UAAU,CAACG,WAAW,CAAC;EACzE,IAAI,CAACF,aAAa,EAAE;IAClB,MAAM,IAAIG,KAAK,CAAC,qBAAqB,CAAC;EACxC;EACA,OAAOH,aAAa;AACtB;AAEA,OAAO,SAASI,6BAA6BA,CAACC,QAAQ,EAAEC,UAAU,EAAE;EAClE,MAAMC,SAAS,GAAGb,iCAAiC,CAACW,QAAQ,CAACL,aAAa,CAAC;EAC3E,MAAMQ,UAAU,GAAGvB,4BAA4B,CAACoB,QAAQ,CAACR,IAAI,CAAC;EAC9D,MAAMY,iBAAiB,GAAGhB,qCAAqC,CAACY,QAAQ,CAACL,aAAa,CAAC;EACvF,MAAMU,MAAM,GAAGL,QAAQ,CAACM,KAAK,GAAGH,UAAU;EAC1C,MAAMI,UAAU,GAAGP,QAAQ,CAACM,KAAK,GAAGH,UAAU,GAAGC,iBAAiB;EAClEpC,MAAM,CAACuC,UAAU,IAAI,CAAC,IAAIA,UAAU,IAAIN,UAAU,CAACM,UAAU,CAAC;EAC9D,OAAO;IAACL,SAAS;IAAEG,MAAM;IAAEE;EAAU,CAAC;AACxC"}

package/dist/esm/lib/gltf-utils/resolve-url.js

@@ -0,0 +1,12 @@
+export function resolveUrl(url, options) {
+  const absolute = url.startsWith('data:') || url.startsWith('http:') || url.startsWith('https:');
+  if (absolute) {
+    return url;
+  }
+  const baseUrl = options.baseUri || options.uri;
+  if (!baseUrl) {
+    throw new Error("'baseUri' must be provided to resolve relative url ".concat(url));
+  }
+  return baseUrl.substr(0, baseUrl.lastIndexOf('/') + 1) + url;
+}
+//# sourceMappingURL=resolve-url.js.map

package/dist/esm/lib/gltf-utils/resolve-url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-url.js","names":["resolveUrl","url","options","absolute","startsWith","baseUrl","baseUri","uri","Error","concat","substr","lastIndexOf"],"sources":["../../../../src/lib/gltf-utils/resolve-url.ts"],"sourcesContent":["// Resolves a relative url against a baseUrl\n// If url is absolute, return it unchanged\nexport function resolveUrl(url, options) {\n  // TODO: Use better logic to handle all protocols plus not delay on data\n  const absolute = url.startsWith('data:') || url.startsWith('http:') || url.startsWith('https:');\n  if (absolute) {\n    return url;\n  }\n  const baseUrl = options.baseUri || options.uri;\n  if (!baseUrl) {\n    throw new Error(`'baseUri' must be provided to resolve relative url ${url}`);\n  }\n  return baseUrl.substr(0, baseUrl.lastIndexOf('/') + 1) + url;\n}\n"],"mappings":"AAEA,OAAO,SAASA,UAAUA,CAACC,GAAG,EAAEC,OAAO,EAAE;EAEvC,MAAMC,QAAQ,GAAGF,GAAG,CAACG,UAAU,CAAC,OAAO,CAAC,IAAIH,GAAG,CAACG,UAAU,CAAC,OAAO,CAAC,IAAIH,GAAG,CAACG,UAAU,CAAC,QAAQ,CAAC;EAC/F,IAAID,QAAQ,EAAE;IACZ,OAAOF,GAAG;EACZ;EACA,MAAMI,OAAO,GAAGH,OAAO,CAACI,OAAO,IAAIJ,OAAO,CAACK,GAAG;EAC9C,IAAI,CAACF,OAAO,EAAE;IACZ,MAAM,IAAIG,KAAK,uDAAAC,MAAA,CAAuDR,GAAG,CAAE,CAAC;EAC9E;EACA,OAAOI,OAAO,CAACK,MAAM,CAAC,CAAC,EAAEL,OAAO,CAACM,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAGV,GAAG;AAC9D"}

package/dist/esm/lib/parsers/parse-glb.js

@@ -0,0 +1,114 @@
+import { padToNBytes, assert } from '@loaders.gl/loader-utils';
+const MAGIC_glTF = 0x676c5446;
+const GLB_FILE_HEADER_SIZE = 12;
+const GLB_CHUNK_HEADER_SIZE = 8;
+const GLB_CHUNK_TYPE_JSON = 0x4e4f534a;
+const GLB_CHUNK_TYPE_BIN = 0x004e4942;
+const GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED = 0;
+const GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED = 1;
+const GLB_V1_CONTENT_FORMAT_JSON = 0x0;
+const LE = true;
+function getMagicString(dataView) {
+  let byteOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  return "".concat(String.fromCharCode(dataView.getUint8(byteOffset + 0))).concat(String.fromCharCode(dataView.getUint8(byteOffset + 1))).concat(String.fromCharCode(dataView.getUint8(byteOffset + 2))).concat(String.fromCharCode(dataView.getUint8(byteOffset + 3)));
+}
+export function isGLB(arrayBuffer) {
+  let byteOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const dataView = new DataView(arrayBuffer);
+  const {
+    magic = MAGIC_glTF
+  } = options;
+  const magic1 = dataView.getUint32(byteOffset, false);
+  return magic1 === magic || magic1 === MAGIC_glTF;
+}
+export default function parseGLBSync(glb, arrayBuffer) {
+  let byteOffset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  const dataView = new DataView(arrayBuffer);
+  const type = getMagicString(dataView, byteOffset + 0);
+  const version = dataView.getUint32(byteOffset + 4, LE);
+  const byteLength = dataView.getUint32(byteOffset + 8, LE);
+  Object.assign(glb, {
+    header: {
+      byteOffset,
+      byteLength,
+      hasBinChunk: false
+    },
+    type,
+    version,
+    json: {},
+    binChunks: []
+  });
+  byteOffset += GLB_FILE_HEADER_SIZE;
+  switch (glb.version) {
+    case 1:
+      return parseGLBV1(glb, dataView, byteOffset);
+    case 2:
+      return parseGLBV2(glb, dataView, byteOffset, options = {});
+    default:
+      throw new Error("Invalid GLB version ".concat(glb.version, ". Only supports v1 and v2."));
+  }
+}
+function parseGLBV1(glb, dataView, byteOffset) {
+  assert(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
+  const contentLength = dataView.getUint32(byteOffset + 0, LE);
+  const contentFormat = dataView.getUint32(byteOffset + 4, LE);
+  byteOffset += GLB_CHUNK_HEADER_SIZE;
+  assert(contentFormat === GLB_V1_CONTENT_FORMAT_JSON);
+  parseJSONChunk(glb, dataView, byteOffset, contentLength);
+  byteOffset += contentLength;
+  byteOffset += parseBINChunk(glb, dataView, byteOffset, glb.header.byteLength);
+  return byteOffset;
+}
+function parseGLBV2(glb, dataView, byteOffset, options) {
+  assert(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
+  parseGLBChunksSync(glb, dataView, byteOffset, options);
+  return byteOffset + glb.header.byteLength;
+}
+function parseGLBChunksSync(glb, dataView, byteOffset, options) {
+  while (byteOffset + 8 <= glb.header.byteLength) {
+    const chunkLength = dataView.getUint32(byteOffset + 0, LE);
+    const chunkFormat = dataView.getUint32(byteOffset + 4, LE);
+    byteOffset += GLB_CHUNK_HEADER_SIZE;
+    switch (chunkFormat) {
+      case GLB_CHUNK_TYPE_JSON:
+        parseJSONChunk(glb, dataView, byteOffset, chunkLength);
+        break;
+      case GLB_CHUNK_TYPE_BIN:
+        parseBINChunk(glb, dataView, byteOffset, chunkLength);
+        break;
+      case GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED:
+        if (!options.strict) {
+          parseJSONChunk(glb, dataView, byteOffset, chunkLength);
+        }
+        break;
+      case GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED:
+        if (!options.strict) {
+          parseBINChunk(glb, dataView, byteOffset, chunkLength);
+        }
+        break;
+      default:
+        break;
+    }
+    byteOffset += padToNBytes(chunkLength, 4);
+  }
+  return byteOffset;
+}
+function parseJSONChunk(glb, dataView, byteOffset, chunkLength) {
+  const jsonChunk = new Uint8Array(dataView.buffer, byteOffset, chunkLength);
+  const textDecoder = new TextDecoder('utf8');
+  const jsonText = textDecoder.decode(jsonChunk);
+  glb.json = JSON.parse(jsonText);
+  return padToNBytes(chunkLength, 4);
+}
+function parseBINChunk(glb, dataView, byteOffset, chunkLength) {
+  glb.header.hasBinChunk = true;
+  glb.binChunks.push({
+    byteOffset,
+    byteLength: chunkLength,
+    arrayBuffer: dataView.buffer
+  });
+  return padToNBytes(chunkLength, 4);
+}
+//# sourceMappingURL=parse-glb.js.map