@loaders.gl/gltf 3.2.7 → 3.3.0-alpha.3

package/dist/es5/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA;;AACA;;AAGA;;AACA;;AAGA;;AACA","sourcesContent":["/* eslint-disable camelcase, indent */\nexport type {GLB} from './lib/types/glb-types';\nexport type {\n  GLTF,\n  GLTFAccessor,\n  GLTFBuffer,\n  GLTFBufferView,\n  GLTFMeshPrimitive,\n  GLTFMesh,\n  GLTFNode,\n  GLTFMaterial,\n  GLTFSampler,\n  GLTFScene,\n  GLTFSkin,\n  GLTFTexture,\n  GLTFImage,\n  GLTFPostprocessed,\n  GLTFNodePostprocessed,\n  GLTFMaterialPostprocessed,\n  GLTFImagePostprocessed,\n  // The following extensions are handled by the GLTFLoader and removed from the parsed glTF (disable via options.gltf.excludeExtensions)\n  GLTF_KHR_binary_glTF,\n  GLTF_KHR_draco_mesh_compression,\n  GLTF_KHR_texture_basisu,\n  GLTF_EXT_meshopt_compression,\n  GLTF_EXT_texture_webp\n} from './lib/types/gltf-types';\n\n// glTF loader/writer definition objects\nexport {GLTFLoader} from './gltf-loader';\nexport {GLTFWriter} from './gltf-writer';\n\n// GLB Loader & Writer (for custom formats that want to leverage the GLB binary \"envelope\")\nexport {GLBLoader} from './glb-loader';\nexport {GLBWriter} from './glb-writer';\n\n// glTF Data Access Helper Class\nexport {default as GLTFScenegraph} from './lib/api/gltf-scenegraph';\nexport {postProcessGLTF} from './lib/api/post-process-gltf';\nexport type {Mesh} from './lib/types/gltf-json-schema';\nexport type {GLTFObject} from './lib/types/gltf-types';\n"],"file":"index.js"}
+{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA;;AACA;;AAGA;;AACA;;AAGA;;AACA","sourcesContent":["/* eslint-disable camelcase, indent */\nexport type {GLB} from './lib/types/glb-types';\nexport type {\n  GLTF,\n  GLTFAccessor,\n  GLTFBuffer,\n  GLTFBufferView,\n  GLTFMeshPrimitive,\n  GLTFMesh,\n  GLTFNode,\n  GLTFMaterial,\n  GLTFSampler,\n  GLTFScene,\n  GLTFSkin,\n  GLTFTexture,\n  GLTFImage,\n  GLTFPostprocessed,\n  GLTFNodePostprocessed,\n  GLTFMaterialPostprocessed,\n  GLTFImagePostprocessed,\n  // The following extensions are handled by the GLTFLoader and removed from the parsed glTF (disable via options.gltf.excludeExtensions)\n  GLTF_KHR_binary_glTF,\n  GLTF_KHR_draco_mesh_compression,\n  GLTF_KHR_texture_basisu,\n  GLTF_EXT_meshopt_compression,\n  GLTF_EXT_texture_webp,\n  GLTF_EXT_feature_metadata\n} from './lib/types/gltf-types';\n\n// glTF loader/writer definition objects\nexport {GLTFLoader} from './gltf-loader';\nexport {GLTFWriter} from './gltf-writer';\n\n// GLB Loader & Writer (for custom formats that want to leverage the GLB binary \"envelope\")\nexport {GLBLoader} from './glb-loader';\nexport {GLBWriter} from './glb-writer';\n\n// glTF Data Access Helper Class\nexport {default as GLTFScenegraph} from './lib/api/gltf-scenegraph';\nexport {postProcessGLTF} from './lib/api/post-process-gltf';\nexport type {Mesh} from './lib/types/gltf-json-schema';\nexport type {GLTFObject} from './lib/types/gltf-types';\n"],"file":"index.js"}

package/dist/es5/lib/api/gltf-extensions.js

@@ -23,12 +23,16 @@ var KHR_texture_basisu = _interopRequireWildcard(require("../extensions/KHR_text
 
 var KHR_draco_mesh_compression = _interopRequireWildcard(require("../extensions/KHR_draco_mesh_compression"));
 
+var KHR_texture_transform = _interopRequireWildcard(require("../extensions/KHR_texture_transform"));
+
 var KHR_lights_punctual = _interopRequireWildcard(require("../extensions/deprecated/KHR_lights_punctual"));
 
 var KHR_materials_unlit = _interopRequireWildcard(require("../extensions/deprecated/KHR_materials_unlit"));
 
 var KHR_techniques_webgl = _interopRequireWildcard(require("../extensions/deprecated/KHR_techniques_webgl"));
 
+var EXT_feature_metadata = _interopRequireWildcard(require("../extensions/deprecated/EXT_feature_metadata"));
+
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
@@ -39,7 +43,7 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-var EXTENSIONS = [EXT_meshopt_compression, EXT_texture_webp, KHR_texture_basisu, KHR_draco_mesh_compression, KHR_lights_punctual, KHR_materials_unlit, KHR_techniques_webgl];
+var EXTENSIONS = [EXT_meshopt_compression, EXT_texture_webp, KHR_texture_basisu, KHR_draco_mesh_compression, KHR_lights_punctual, KHR_materials_unlit, KHR_techniques_webgl, KHR_texture_transform, EXT_feature_metadata];
 exports.EXTENSIONS = EXTENSIONS;
 
 function preprocessExtensions(gltf) {

package/dist/es5/lib/api/gltf-extensions.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/api/gltf-extensions.ts"],"names":["EXTENSIONS","EXT_meshopt_compression","EXT_texture_webp","KHR_texture_basisu","KHR_draco_mesh_compression","KHR_lights_punctual","KHR_materials_unlit","KHR_techniques_webgl","preprocessExtensions","gltf","options","context","extensions","filter","extension","useExtension","name","preprocess","decodeExtensions","decode","extensionName","excludes","excludeExtensions","exclude"],"mappings":";;;;;;;;;;;;;;;;;AAQA;;AACA;;AACA;;AACA;;AAGA;;AACA;;AACA;;;;;;;;;;;;AAgBO,IAAMA,UAAiC,GAAG,CAM/CC,uBAN+C,EAO/CC,gBAP+C,EAS/CC,kBAT+C,EAU/CC,0BAV+C,EAW/CC,mBAX+C,EAY/CC,mBAZ+C,EAa/CC,oBAb+C,CAA1C;;;AAiBA,SAASC,oBAAT,CAA8BC,IAA9B,EAA+E;AAAA,MAA3CC,OAA2C,uEAAd,EAAc;AAAA,MAAVC,OAAU;AACpF,MAAMC,UAAU,GAAGZ,UAAU,CAACa,MAAX,CAAkB,UAACC,SAAD;AAAA,WAAeC,YAAY,CAACD,SAAS,CAACE,IAAX,EAAiBN,OAAjB,CAA3B;AAAA,GAAlB,CAAnB;;AADoF,6CAE5DE,UAF4D;AAAA;;AAAA;AAEpF,wDAAoC;AAAA;;AAAA,UAAzBE,SAAyB;AAClC,+BAAAA,SAAS,CAACG,UAAV,qFAAAH,SAAS,EAAcL,IAAd,EAAoBC,OAApB,EAA6BC,OAA7B,CAAT;AACD;AAJmF;AAAA;AAAA;AAAA;AAAA;AAKrF;;SAGqBO,gB;;;;;gFAAf,iBAAgCT,IAAhC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAsCC,YAAAA,OAAtC,2DAAmE,EAAnE;AAAuEC,YAAAA,OAAvE;AACCC,YAAAA,UADD,GACcZ,UAAU,CAACa,MAAX,CAAkB,UAACC,SAAD;AAAA,qBAAeC,YAAY,CAACD,SAAS,CAACE,IAAX,EAAiBN,OAAjB,CAA3B;AAAA,aAAlB,CADd;AAAA,oDAEmBE,UAFnB;AAAA;;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;;AAEME,YAAAA,SAFN;AAAA;AAAA,wCAKGA,SAAS,CAACK,MALb,sDAKG,uBAAAL,SAAS,EAAUL,IAAV,EAAgBC,OAAhB,EAAyBC,OAAzB,CALZ;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;;AAAA;AAAA;;AAAA;;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;AASP,SAASI,YAAT,CAAsBK,aAAtB,EAA6CV,OAA7C,EAAyE;AAAA;;AACvE,MAAMW,QAAQ,GAAG,CAAAX,OAAO,SAAP,IAAAA,OAAO,WAAP,6BAAAA,OAAO,CAAED,IAAT,gEAAea,iBAAf,KAAoC,EAArD;AACA,MAAMC,OAAO,GAAGH,aAAa,IAAIC,QAAjB,IAA6B,CAACA,QAAQ,CAACD,aAAD,CAAtD;AACA,SAAO,CAACG,OAAR;AACD","sourcesContent":["/* eslint-disable camelcase */\nimport {GLTF} from '../types/gltf-types';\nimport type {GLTFLoaderOptions} from '../../gltf-loader';\n\n// GLTF 1.0 extensions (decode only)\n// import * as KHR_binary_gltf from './KHR_draco_mesh_compression';\n\n// GLTF 2.0 Khronos extensions (decode/encode)\nimport * as EXT_meshopt_compression from '../extensions/EXT_meshopt_compression';\nimport * as EXT_texture_webp from '../extensions/EXT_texture_webp';\nimport * as KHR_texture_basisu from '../extensions/KHR_texture_basisu';\nimport * as KHR_draco_mesh_compression from '../extensions/KHR_draco_mesh_compression';\n\n// Deprecated. These should be handled by rendering library (e.g. luma.gl), not the loader.\nimport * as KHR_lights_punctual from '../extensions/deprecated/KHR_lights_punctual';\nimport * as KHR_materials_unlit from '../extensions/deprecated/KHR_materials_unlit';\nimport * as KHR_techniques_webgl from '../extensions/deprecated/KHR_techniques_webgl';\n\n// Vendor extensions\n\ntype GLTFExtensionPlugin = {\n  name: string;\n  preprocess?: (gltfData: {json: GLTF}, options: GLTFLoaderOptions, context) => void;\n  decode?: (gltfData: {json: GLTF}, options: GLTFLoaderOptions, context) => Promise<void>;\n  encode?: (gltfData: {json: GLTF}, options: GLTFLoaderOptions) => void;\n};\n\n/**\n * List of extensions processed by the GLTFLoader\n * Note that may extensions can only be handled on the rendering stage and are left out here\n * These are just extensions that can be handled fully or partially during loading.\n */\nexport const EXTENSIONS: GLTFExtensionPlugin[] = [\n  // 1.0\n  // KHR_binary_gltf is handled separately - must be processed before other parsing starts\n  // KHR_binary_gltf,\n\n  // 2.0\n  EXT_meshopt_compression,\n  EXT_texture_webp,\n  // Basisu should come after webp, we want basisu to be preferred if both are provided\n  KHR_texture_basisu,\n  KHR_draco_mesh_compression,\n  KHR_lights_punctual,\n  KHR_materials_unlit,\n  KHR_techniques_webgl\n];\n\n/** Call before any resource loading starts */\nexport function preprocessExtensions(gltf, options: GLTFLoaderOptions = {}, context?) {\n  const extensions = EXTENSIONS.filter((extension) => useExtension(extension.name, options));\n  for (const extension of extensions) {\n    extension.preprocess?.(gltf, options, context);\n  }\n}\n\n/** Call after resource loading */\nexport async function decodeExtensions(gltf, options: GLTFLoaderOptions = {}, context?) {\n  const extensions = EXTENSIONS.filter((extension) => useExtension(extension.name, options));\n  for (const extension of extensions) {\n    // Note: We decode async extensions sequentially, this might not be necessary\n    // Currently we only have Draco, but when we add Basis we may revisit\n    await extension.decode?.(gltf, options, context);\n  }\n}\n\nfunction useExtension(extensionName: string, options: GLTFLoaderOptions) {\n  const excludes = options?.gltf?.excludeExtensions || {};\n  const exclude = extensionName in excludes && !excludes[extensionName];\n  return !exclude;\n}\n"],"file":"gltf-extensions.js"}
+{"version":3,"sources":["../../../../src/lib/api/gltf-extensions.ts"],"names":["EXTENSIONS","EXT_meshopt_compression","EXT_texture_webp","KHR_texture_basisu","KHR_draco_mesh_compression","KHR_lights_punctual","KHR_materials_unlit","KHR_techniques_webgl","KHR_texture_transform","EXT_feature_metadata","preprocessExtensions","gltf","options","context","extensions","filter","extension","useExtension","name","preprocess","decodeExtensions","decode","extensionName","excludes","excludeExtensions","exclude"],"mappings":";;;;;;;;;;;;;;;;;AAQA;;AACA;;AACA;;AACA;;AACA;;AAGA;;AACA;;AACA;;AACA;;;;;;;;;;;;AAuBO,IAAMA,UAAiC,GAAG,CAM/CC,uBAN+C,EAO/CC,gBAP+C,EAS/CC,kBAT+C,EAU/CC,0BAV+C,EAW/CC,mBAX+C,EAY/CC,mBAZ+C,EAa/CC,oBAb+C,EAc/CC,qBAd+C,EAe/CC,oBAf+C,CAA1C;;;AAmBA,SAASC,oBAAT,CAA8BC,IAA9B,EAA+E;AAAA,MAA3CC,OAA2C,uEAAd,EAAc;AAAA,MAAVC,OAAU;AACpF,MAAMC,UAAU,GAAGd,UAAU,CAACe,MAAX,CAAkB,UAACC,SAAD;AAAA,WAAeC,YAAY,CAACD,SAAS,CAACE,IAAX,EAAiBN,OAAjB,CAA3B;AAAA,GAAlB,CAAnB;;AADoF,6CAE5DE,UAF4D;AAAA;;AAAA;AAEpF,wDAAoC;AAAA;;AAAA,UAAzBE,SAAyB;AAClC,+BAAAA,SAAS,CAACG,UAAV,qFAAAH,SAAS,EAAcL,IAAd,EAAoBC,OAApB,EAA6BC,OAA7B,CAAT;AACD;AAJmF;AAAA;AAAA;AAAA;AAAA;AAKrF;;SAGqBO,gB;;;;;gFAAf,iBAAgCT,IAAhC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAsCC,YAAAA,OAAtC,2DAAmE,EAAnE;AAAuEC,YAAAA,OAAvE;AACCC,YAAAA,UADD,GACcd,UAAU,CAACe,MAAX,CAAkB,UAACC,SAAD;AAAA,qBAAeC,YAAY,CAACD,SAAS,CAACE,IAAX,EAAiBN,OAAjB,CAA3B;AAAA,aAAlB,CADd;AAAA,oDAEmBE,UAFnB;AAAA;;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;;AAEME,YAAAA,SAFN;AAAA;AAAA,wCAKGA,SAAS,CAACK,MALb,sDAKG,uBAAAL,SAAS,EAAUL,IAAV,EAAgBC,OAAhB,EAAyBC,OAAzB,CALZ;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;;AAAA;AAAA;;AAAA;;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;AASP,SAASI,YAAT,CAAsBK,aAAtB,EAA6CV,OAA7C,EAAyE;AAAA;;AACvE,MAAMW,QAAQ,GAAG,CAAAX,OAAO,SAAP,IAAAA,OAAO,WAAP,6BAAAA,OAAO,CAAED,IAAT,gEAAea,iBAAf,KAAoC,EAArD;AACA,MAAMC,OAAO,GAAGH,aAAa,IAAIC,QAAjB,IAA6B,CAACA,QAAQ,CAACD,aAAD,CAAtD;AACA,SAAO,CAACG,OAAR;AACD","sourcesContent":["/* eslint-disable camelcase */\nimport {GLTF} from '../types/gltf-types';\nimport type {GLTFLoaderOptions} from '../../gltf-loader';\n\n// GLTF 1.0 extensions (decode only)\n// import * as KHR_binary_gltf from './KHR_draco_mesh_compression';\n\n// GLTF 2.0 Khronos extensions (decode/encode)\nimport * as EXT_meshopt_compression from '../extensions/EXT_meshopt_compression';\nimport * as EXT_texture_webp from '../extensions/EXT_texture_webp';\nimport * as KHR_texture_basisu from '../extensions/KHR_texture_basisu';\nimport * as KHR_draco_mesh_compression from '../extensions/KHR_draco_mesh_compression';\nimport * as KHR_texture_transform from '../extensions/KHR_texture_transform';\n\n// Deprecated. These should be handled by rendering library (e.g. luma.gl), not the loader.\nimport * as KHR_lights_punctual from '../extensions/deprecated/KHR_lights_punctual';\nimport * as KHR_materials_unlit from '../extensions/deprecated/KHR_materials_unlit';\nimport * as KHR_techniques_webgl from '../extensions/deprecated/KHR_techniques_webgl';\nimport * as EXT_feature_metadata from '../extensions/deprecated/EXT_feature_metadata';\n\n// Vendor extensions\n\ntype GLTFExtensionPlugin = {\n  name: string;\n  preprocess?: (gltfData: {json: GLTF}, options: GLTFLoaderOptions, context) => void;\n  decode?: (\n    gltfData: {\n      json: GLTF;\n      buffers: {arrayBuffer: ArrayBuffer; byteOffset: number; byteLength: number}[];\n    },\n    options: GLTFLoaderOptions,\n    context\n  ) => Promise<void>;\n  encode?: (gltfData: {json: GLTF}, options: GLTFLoaderOptions) => void;\n};\n\n/**\n * List of extensions processed by the GLTFLoader\n * Note that may extensions can only be handled on the rendering stage and are left out here\n * These are just extensions that can be handled fully or partially during loading.\n */\nexport const EXTENSIONS: GLTFExtensionPlugin[] = [\n  // 1.0\n  // KHR_binary_gltf is handled separately - must be processed before other parsing starts\n  // KHR_binary_gltf,\n\n  // 2.0\n  EXT_meshopt_compression,\n  EXT_texture_webp,\n  // Basisu should come after webp, we want basisu to be preferred if both are provided\n  KHR_texture_basisu,\n  KHR_draco_mesh_compression,\n  KHR_lights_punctual,\n  KHR_materials_unlit,\n  KHR_techniques_webgl,\n  KHR_texture_transform,\n  EXT_feature_metadata\n];\n\n/** Call before any resource loading starts */\nexport function preprocessExtensions(gltf, options: GLTFLoaderOptions = {}, context?) {\n  const extensions = EXTENSIONS.filter((extension) => useExtension(extension.name, options));\n  for (const extension of extensions) {\n    extension.preprocess?.(gltf, options, context);\n  }\n}\n\n/** Call after resource loading */\nexport async function decodeExtensions(gltf, options: GLTFLoaderOptions = {}, context?) {\n  const extensions = EXTENSIONS.filter((extension) => useExtension(extension.name, options));\n  for (const extension of extensions) {\n    // Note: We decode async extensions sequentially, this might not be necessary\n    // Currently we only have Draco, but when we add Basis we may revisit\n    await extension.decode?.(gltf, options, context);\n  }\n}\n\nfunction useExtension(extensionName: string, options: GLTFLoaderOptions) {\n  const excludes = options?.gltf?.excludeExtensions || {};\n  const exclude = extensionName in excludes && !excludes[extensionName];\n  return !exclude;\n}\n"],"file":"gltf-extensions.js"}

package/dist/es5/lib/extensions/KHR_texture_transform.js

@@ -0,0 +1,293 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decode = decode;
+exports.name = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _core = require("@math.gl/core");
+
+var _gltfUtils = require("../gltf-utils/gltf-utils");
+
+var _gltfConstants = require("../gltf-utils/gltf-constants");
+
+var _gltfScenegraph = _interopRequireDefault(require("../api/gltf-scenegraph"));
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+var EXT_MESHOPT_TRANSFORM = 'KHR_texture_transform';
+var name = EXT_MESHOPT_TRANSFORM;
+exports.name = name;
+var scratchVector = new _core.Vector3();
+var scratchRotationMatrix = new _core.Matrix3();
+var scratchScaleMatrix = new _core.Matrix3();
+
+function decode(_x, _x2) {
+  return _decode.apply(this, arguments);
+}
+
+function _decode() {
+  _decode = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(gltfData, options) {
+    var gltfScenegraph, extension, materials, i;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            gltfScenegraph = new _gltfScenegraph.default(gltfData);
+            extension = gltfScenegraph.getExtension(EXT_MESHOPT_TRANSFORM);
+
+            if (extension) {
+              _context.next = 4;
+              break;
+            }
+
+            return _context.abrupt("return");
+
+          case 4:
+            materials = gltfData.json.materials || [];
+
+            for (i = 0; i < materials.length; i++) {
+              transformTexCoords(i, gltfData);
+            }
+
+          case 6:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _decode.apply(this, arguments);
+}
+
+function transformTexCoords(materialIndex, gltfData) {
+  var _gltfData$json$materi, _material$pbrMetallic, _material$pbrMetallic2;
+
+  var processedTexCoords = [];
+  var material = (_gltfData$json$materi = gltfData.json.materials) === null || _gltfData$json$materi === void 0 ? void 0 : _gltfData$json$materi[materialIndex];
+  var baseColorTexture = material === null || material === void 0 ? void 0 : (_material$pbrMetallic = material.pbrMetallicRoughness) === null || _material$pbrMetallic === void 0 ? void 0 : _material$pbrMetallic.baseColorTexture;
+
+  if (baseColorTexture) {
+    transformPrimitives(gltfData, materialIndex, baseColorTexture, processedTexCoords);
+  }
+
+  var emisiveTexture = material === null || material === void 0 ? void 0 : material.emissiveTexture;
+
+  if (emisiveTexture) {
+    transformPrimitives(gltfData, materialIndex, emisiveTexture, processedTexCoords);
+  }
+
+  var normalTexture = material === null || material === void 0 ? void 0 : material.normalTexture;
+
+  if (normalTexture) {
+    transformPrimitives(gltfData, materialIndex, normalTexture, processedTexCoords);
+  }
+
+  var occlusionTexture = material === null || material === void 0 ? void 0 : material.occlusionTexture;
+
+  if (occlusionTexture) {
+    transformPrimitives(gltfData, materialIndex, occlusionTexture, processedTexCoords);
+  }
+
+  var metallicRoughnessTexture = material === null || material === void 0 ? void 0 : (_material$pbrMetallic2 = material.pbrMetallicRoughness) === null || _material$pbrMetallic2 === void 0 ? void 0 : _material$pbrMetallic2.metallicRoughnessTexture;
+
+  if (metallicRoughnessTexture) {
+    transformPrimitives(gltfData, materialIndex, metallicRoughnessTexture, processedTexCoords);
+  }
+}
+
+function transformPrimitives(gltfData, materialIndex, texture, processedTexCoords) {
+  var transformParameters = getTransformParameters(texture, processedTexCoords);
+
+  if (!transformParameters) {
+    return;
+  }
+
+  var meshes = gltfData.json.meshes || [];
+
+  var _iterator = _createForOfIteratorHelper(meshes),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var mesh = _step.value;
+
+      var _iterator2 = _createForOfIteratorHelper(mesh.primitives),
+          _step2;
+
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var primitive = _step2.value;
+          var material = primitive.material;
+
+          if (Number.isFinite(material) && materialIndex === material) {
+            transformPrimitive(gltfData, primitive, transformParameters);
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+}
+
+function getTransformParameters(texture, processedTexCoords) {
+  var _texture$extensions;
+
+  var textureInfo = (_texture$extensions = texture.extensions) === null || _texture$extensions === void 0 ? void 0 : _texture$extensions[EXT_MESHOPT_TRANSFORM];
+  var _texture$texCoord = texture.texCoord,
+      originalTexCoord = _texture$texCoord === void 0 ? 0 : _texture$texCoord;
+  var _textureInfo$texCoord = textureInfo.texCoord,
+      texCoord = _textureInfo$texCoord === void 0 ? originalTexCoord : _textureInfo$texCoord;
+  var isProcessed = processedTexCoords.findIndex(function (_ref) {
+    var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
+        original = _ref2[0],
+        newTexCoord = _ref2[1];
+
+    return original === originalTexCoord && newTexCoord === texCoord;
+  }) !== -1;
+
+  if (!isProcessed) {
+    var matrix = makeTransformationMatrix(textureInfo);
+
+    if (originalTexCoord !== texCoord) {
+      texture.texCoord = texCoord;
+    }
+
+    processedTexCoords.push([originalTexCoord, texCoord]);
+    return {
+      originalTexCoord: originalTexCoord,
+      texCoord: texCoord,
+      matrix: matrix
+    };
+  }
+
+  return null;
+}
+
+function transformPrimitive(gltfData, primitive, transformParameters) {
+  var originalTexCoord = transformParameters.originalTexCoord,
+      texCoord = transformParameters.texCoord,
+      matrix = transformParameters.matrix;
+  var texCoordAccessor = primitive.attributes["TEXCOORD_".concat(originalTexCoord)];
+
+  if (Number.isFinite(texCoordAccessor)) {
+    var _gltfData$json$access;
+
+    var accessor = (_gltfData$json$access = gltfData.json.accessors) === null || _gltfData$json$access === void 0 ? void 0 : _gltfData$json$access[texCoordAccessor];
+
+    if (accessor && accessor.bufferView) {
+      var _gltfData$json$buffer;
+
+      var bufferView = (_gltfData$json$buffer = gltfData.json.bufferViews) === null || _gltfData$json$buffer === void 0 ? void 0 : _gltfData$json$buffer[accessor.bufferView];
+
+      if (bufferView) {
+        var _gltfData$buffers$buf = gltfData.buffers[bufferView.buffer],
+            arrayBuffer = _gltfData$buffers$buf.arrayBuffer,
+            bufferByteOffset = _gltfData$buffers$buf.byteOffset;
+        var byteOffset = (bufferByteOffset || 0) + (accessor.byteOffset || 0) + (bufferView.byteOffset || 0);
+
+        var _getAccessorArrayType = (0, _gltfUtils.getAccessorArrayTypeAndLength)(accessor, bufferView),
+            ArrayType = _getAccessorArrayType.ArrayType,
+            length = _getAccessorArrayType.length;
+
+        var bytes = _gltfConstants.BYTES[accessor.componentType];
+        var components = _gltfConstants.COMPONENTS[accessor.type];
+        var elementAddressScale = bufferView.byteStride || bytes * components;
+        var result = new Float32Array(length);
+
+        for (var i = 0; i < accessor.count; i++) {
+          var uv = new ArrayType(arrayBuffer, byteOffset + i * elementAddressScale, 2);
+          scratchVector.set(uv[0], uv[1], 1);
+          scratchVector.transformByMatrix3(matrix);
+          result.set([scratchVector[0], scratchVector[1]], i * components);
+        }
+
+        if (originalTexCoord === texCoord) {
+          updateGltf(accessor, bufferView, gltfData.buffers, result);
+        } else {
+          createAttribute(texCoord, accessor, primitive, gltfData, result);
+        }
+      }
+    }
+  }
+}
+
+function updateGltf(accessor, bufferView, buffers, newTexCoordArray) {
+  accessor.componentType = 5126;
+  buffers.push({
+    arrayBuffer: newTexCoordArray.buffer,
+    byteOffset: 0,
+    byteLength: newTexCoordArray.buffer.byteLength
+  });
+  bufferView.buffer = buffers.length - 1;
+  bufferView.byteLength = newTexCoordArray.buffer.byteLength;
+  bufferView.byteOffset = 0;
+  delete bufferView.byteStride;
+}
+
+function createAttribute(newTexCoord, originalAccessor, primitive, gltfData, newTexCoordArray) {
+  gltfData.buffers.push({
+    arrayBuffer: newTexCoordArray.buffer,
+    byteOffset: 0,
+    byteLength: newTexCoordArray.buffer.byteLength
+  });
+  var bufferViews = gltfData.json.bufferViews;
+
+  if (!bufferViews) {
+    return;
+  }
+
+  bufferViews.push({
+    buffer: gltfData.buffers.length - 1,
+    byteLength: newTexCoordArray.buffer.byteLength,
+    byteOffset: 0
+  });
+  var accessors = gltfData.json.accessors;
+
+  if (!accessors) {
+    return;
+  }
+
+  accessors.push({
+    bufferView: (bufferViews === null || bufferViews === void 0 ? void 0 : bufferViews.length) - 1,
+    byteOffset: 0,
+    componentType: 5126,
+    count: originalAccessor.count,
+    type: 'VEC2'
+  });
+  primitive.attributes["TEXCOORD_".concat(newTexCoord)] = accessors.length - 1;
+}
+
+function makeTransformationMatrix(extensionData) {
+  var _extensionData$offset = extensionData.offset,
+      offset = _extensionData$offset === void 0 ? [0, 0] : _extensionData$offset,
+      _extensionData$rotati = extensionData.rotation,
+      rotation = _extensionData$rotati === void 0 ? 0 : _extensionData$rotati,
+      _extensionData$scale = extensionData.scale,
+      scale = _extensionData$scale === void 0 ? [1, 1] : _extensionData$scale;
+  var translationMatirx = new _core.Matrix3().set(1, 0, 0, 0, 1, 0, offset[0], offset[1], 1);
+  var rotationMatirx = scratchRotationMatrix.set(Math.cos(rotation), Math.sin(rotation), 0, -Math.sin(rotation), Math.cos(rotation), 0, 0, 0, 1);
+  var scaleMatrix = scratchScaleMatrix.set(scale[0], 0, 0, 0, scale[1], 0, 0, 0, 1);
+  return translationMatirx.multiplyRight(rotationMatirx).multiplyRight(scaleMatrix);
+}
+//# sourceMappingURL=KHR_texture_transform.js.map

package/dist/es5/lib/extensions/KHR_texture_transform.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/extensions/KHR_texture_transform.ts"],"names":["EXT_MESHOPT_TRANSFORM","name","scratchVector","Vector3","scratchRotationMatrix","Matrix3","scratchScaleMatrix","decode","gltfData","options","gltfScenegraph","GLTFScenegraph","extension","getExtension","materials","json","i","length","transformTexCoords","materialIndex","processedTexCoords","material","baseColorTexture","pbrMetallicRoughness","transformPrimitives","emisiveTexture","emissiveTexture","normalTexture","occlusionTexture","metallicRoughnessTexture","texture","transformParameters","getTransformParameters","meshes","mesh","primitives","primitive","Number","isFinite","transformPrimitive","textureInfo","extensions","texCoord","originalTexCoord","isProcessed","findIndex","original","newTexCoord","matrix","makeTransformationMatrix","push","texCoordAccessor","attributes","accessor","accessors","bufferView","bufferViews","buffers","buffer","arrayBuffer","bufferByteOffset","byteOffset","ArrayType","bytes","BYTES","componentType","components","COMPONENTS","type","elementAddressScale","byteStride","result","Float32Array","count","uv","set","transformByMatrix3","updateGltf","createAttribute","newTexCoordArray","byteLength","originalAccessor","extensionData","offset","rotation","scale","translationMatirx","rotationMatirx","Math","cos","sin","scaleMatrix","multiplyRight"],"mappings":";;;;;;;;;;;;;;;;AAIA;;AAGA;;AACA;;AAQA;;;;;;;;AAGA,IAAMA,qBAAqB,GAAG,uBAA9B;AAEO,IAAMC,IAAI,GAAGD,qBAAb;;AAEP,IAAME,aAAa,GAAG,IAAIC,aAAJ,EAAtB;AACA,IAAMC,qBAAqB,GAAG,IAAIC,aAAJ,EAA9B;AACA,IAAMC,kBAAkB,GAAG,IAAID,aAAJ,EAA3B;;SAgCsBE,M;;;;;sEAAf,iBAAsBC,QAAtB,EAAiDC,OAAjD;AAAA;AAAA;AAAA;AAAA;AAAA;AACCC,YAAAA,cADD,GACkB,IAAIC,uBAAJ,CAAmBH,QAAnB,CADlB;AAECI,YAAAA,SAFD,GAEaF,cAAc,CAACG,YAAf,CAA4Bb,qBAA5B,CAFb;;AAAA,gBAGAY,SAHA;AAAA;AAAA;AAAA;;AAAA;;AAAA;AAMCE,YAAAA,SAND,GAMaN,QAAQ,CAACO,IAAT,CAAcD,SAAd,IAA2B,EANxC;;AAOL,iBAASE,CAAT,GAAa,CAAb,EAAgBA,CAAC,GAAGF,SAAS,CAACG,MAA9B,EAAsCD,CAAC,EAAvC,EAA2C;AACzCE,cAAAA,kBAAkB,CAACF,CAAD,EAAIR,QAAJ,CAAlB;AACD;;AATI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;AAiBP,SAASU,kBAAT,CAA4BC,aAA5B,EAAmDX,QAAnD,EAAoF;AAAA;;AAElF,MAAMY,kBAAsC,GAAG,EAA/C;AACA,MAAMC,QAAQ,4BAAGb,QAAQ,CAACO,IAAT,CAAcD,SAAjB,0DAAG,sBAA0BK,aAA1B,CAAjB;AACA,MAAMG,gBAAgB,GAAGD,QAAH,aAAGA,QAAH,gDAAGA,QAAQ,CAAEE,oBAAb,0DAAG,sBAAgCD,gBAAzD;;AACA,MAAIA,gBAAJ,EAAsB;AACpBE,IAAAA,mBAAmB,CAAChB,QAAD,EAAWW,aAAX,EAA0BG,gBAA1B,EAA4CF,kBAA5C,CAAnB;AACD;;AACD,MAAMK,cAAc,GAAGJ,QAAH,aAAGA,QAAH,uBAAGA,QAAQ,CAAEK,eAAjC;;AACA,MAAID,cAAJ,EAAoB;AAClBD,IAAAA,mBAAmB,CAAChB,QAAD,EAAWW,aAAX,EAA0BM,cAA1B,EAA0CL,kBAA1C,CAAnB;AACD;;AACD,MAAMO,aAAa,GAAGN,QAAH,aAAGA,QAAH,uBAAGA,QAAQ,CAAEM,aAAhC;;AACA,MAAIA,aAAJ,EAAmB;AACjBH,IAAAA,mBAAmB,CAAChB,QAAD,EAAWW,aAAX,EAA0BQ,aAA1B,EAAyCP,kBAAzC,CAAnB;AACD;;AACD,MAAMQ,gBAAgB,GAAGP,QAAH,aAAGA,QAAH,uBAAGA,QAAQ,CAAEO,gBAAnC;;AACA,MAAIA,gBAAJ,EAAsB;AACpBJ,IAAAA,mBAAmB,CAAChB,QAAD,EAAWW,aAAX,EAA0BS,gBAA1B,EAA4CR,kBAA5C,CAAnB;AACD;;AACD,MAAMS,wBAAwB,GAAGR,QAAH,aAAGA,QAAH,iDAAGA,QAAQ,CAAEE,oBAAb,2DAAG,uBAAgCM,wBAAjE;;AACA,MAAIA,wBAAJ,EAA8B;AAC5BL,IAAAA,mBAAmB,CAAChB,QAAD,EAAWW,aAAX,EAA0BU,wBAA1B,EAAoDT,kBAApD,CAAnB;AACD;AACF;;AASD,SAASI,mBAAT,CACEhB,QADF,EAEEW,aAFF,EAGEW,OAHF,EAIEV,kBAJF,EAKE;AACA,MAAMW,mBAAmB,GAAGC,sBAAsB,CAACF,OAAD,EAAUV,kBAAV,CAAlD;;AACA,MAAI,CAACW,mBAAL,EAA0B;AACxB;AACD;;AACD,MAAME,MAAM,GAAGzB,QAAQ,CAACO,IAAT,CAAckB,MAAd,IAAwB,EAAvC;;AALA,6CAMmBA,MANnB;AAAA;;AAAA;AAMA,wDAA2B;AAAA,UAAhBC,IAAgB;;AAAA,kDACDA,IAAI,CAACC,UADJ;AAAA;;AAAA;AACzB,+DAAyC;AAAA,cAA9BC,SAA8B;AACvC,cAAMf,QAAQ,GAAGe,SAAS,CAACf,QAA3B;;AACA,cAAIgB,MAAM,CAACC,QAAP,CAAgBjB,QAAhB,KAA6BF,aAAa,KAAKE,QAAnD,EAA6D;AAC3DkB,YAAAA,kBAAkB,CAAC/B,QAAD,EAAW4B,SAAX,EAAsBL,mBAAtB,CAAlB;AACD;AACF;AANwB;AAAA;AAAA;AAAA;AAAA;AAO1B;AAbD;AAAA;AAAA;AAAA;AAAA;AAcD;;AAQD,SAASC,sBAAT,CACEF,OADF,EAEEV,kBAFF,EAG8B;AAAA;;AAC5B,MAAMoB,WAAW,0BAAGV,OAAO,CAACW,UAAX,wDAAG,oBAAqBzC,qBAArB,CAApB;AACA,0BAAyC8B,OAAzC,CAAOY,QAAP;AAAA,MAAiBC,gBAAjB,kCAAoC,CAApC;AAEA,8BAAsCH,WAAtC,CAAOE,QAAP;AAAA,MAAOA,QAAP,sCAAkBC,gBAAlB;AAEA,MAAMC,WAAW,GACfxB,kBAAkB,CAACyB,SAAnB,CACE;AAAA;AAAA,QAAEC,QAAF;AAAA,QAAYC,WAAZ;;AAAA,WAA6BD,QAAQ,KAAKH,gBAAb,IAAiCI,WAAW,KAAKL,QAA9E;AAAA,GADF,MAEM,CAAC,CAHT;;AAIA,MAAI,CAACE,WAAL,EAAkB;AAChB,QAAMI,MAAM,GAAGC,wBAAwB,CAACT,WAAD,CAAvC;;AACA,QAAIG,gBAAgB,KAAKD,QAAzB,EAAmC;AACjCZ,MAAAA,OAAO,CAACY,QAAR,GAAmBA,QAAnB;AACD;;AACDtB,IAAAA,kBAAkB,CAAC8B,IAAnB,CAAwB,CAACP,gBAAD,EAAmBD,QAAnB,CAAxB;AACA,WAAO;AAACC,MAAAA,gBAAgB,EAAhBA,gBAAD;AAAmBD,MAAAA,QAAQ,EAARA,QAAnB;AAA6BM,MAAAA,MAAM,EAANA;AAA7B,KAAP;AACD;;AACD,SAAO,IAAP;AACD;;AAQD,SAAST,kBAAT,CACE/B,QADF,EAEE4B,SAFF,EAGEL,mBAHF,EAIE;AACA,MAAOY,gBAAP,GAA6CZ,mBAA7C,CAAOY,gBAAP;AAAA,MAAyBD,QAAzB,GAA6CX,mBAA7C,CAAyBW,QAAzB;AAAA,MAAmCM,MAAnC,GAA6CjB,mBAA7C,CAAmCiB,MAAnC;AACA,MAAMG,gBAAgB,GAAGf,SAAS,CAACgB,UAAV,oBAAiCT,gBAAjC,EAAzB;;AACA,MAAIN,MAAM,CAACC,QAAP,CAAgBa,gBAAhB,CAAJ,EAAuC;AAAA;;AAErC,QAAME,QAAQ,4BAAG7C,QAAQ,CAACO,IAAT,CAAcuC,SAAjB,0DAAG,sBAA0BH,gBAA1B,CAAjB;;AACA,QAAIE,QAAQ,IAAIA,QAAQ,CAACE,UAAzB,EAAqC;AAAA;;AAEnC,UAAMA,UAAU,4BAAG/C,QAAQ,CAACO,IAAT,CAAcyC,WAAjB,0DAAG,sBAA4BH,QAAQ,CAACE,UAArC,CAAnB;;AACA,UAAIA,UAAJ,EAAgB;AAEd,oCAAoD/C,QAAQ,CAACiD,OAAT,CAAiBF,UAAU,CAACG,MAA5B,CAApD;AAAA,YAAOC,WAAP,yBAAOA,WAAP;AAAA,YAAgCC,gBAAhC,yBAAoBC,UAApB;AAEA,YAAMA,UAAU,GACd,CAACD,gBAAgB,IAAI,CAArB,KAA2BP,QAAQ,CAACQ,UAAT,IAAuB,CAAlD,KAAwDN,UAAU,CAACM,UAAX,IAAyB,CAAjF,CADF;;AAGA,oCAA4B,8CAA8BR,QAA9B,EAAwCE,UAAxC,CAA5B;AAAA,YAAOO,SAAP,yBAAOA,SAAP;AAAA,YAAkB7C,MAAlB,yBAAkBA,MAAlB;;AAEA,YAAM8C,KAAK,GAAGC,qBAAMX,QAAQ,CAACY,aAAf,CAAd;AAEA,YAAMC,UAAU,GAAGC,0BAAWd,QAAQ,CAACe,IAApB,CAAnB;AAEA,YAAMC,mBAAmB,GAAGd,UAAU,CAACe,UAAX,IAAyBP,KAAK,GAAGG,UAA7D;AAEA,YAAMK,MAAM,GAAG,IAAIC,YAAJ,CAAiBvD,MAAjB,CAAf;;AACA,aAAK,IAAID,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGqC,QAAQ,CAACoB,KAA7B,EAAoCzD,CAAC,EAArC,EAAyC;AAEvC,cAAM0D,EAAE,GAAG,IAAIZ,SAAJ,CAAcH,WAAd,EAA2BE,UAAU,GAAG7C,CAAC,GAAGqD,mBAA5C,EAAiE,CAAjE,CAAX;AAEAnE,UAAAA,aAAa,CAACyE,GAAd,CAAkBD,EAAE,CAAC,CAAD,CAApB,EAAyBA,EAAE,CAAC,CAAD,CAA3B,EAAgC,CAAhC;AACAxE,UAAAA,aAAa,CAAC0E,kBAAd,CAAiC5B,MAAjC;AAEAuB,UAAAA,MAAM,CAACI,GAAP,CAAW,CAACzE,aAAa,CAAC,CAAD,CAAd,EAAmBA,aAAa,CAAC,CAAD,CAAhC,CAAX,EAAiDc,CAAC,GAAGkD,UAArD;AACD;;AAED,YAAIvB,gBAAgB,KAAKD,QAAzB,EAAmC;AACjCmC,UAAAA,UAAU,CAACxB,QAAD,EAAWE,UAAX,EAAuB/C,QAAQ,CAACiD,OAAhC,EAAyCc,MAAzC,CAAV;AACD,SAFD,MAEO;AAELO,UAAAA,eAAe,CAACpC,QAAD,EAAWW,QAAX,EAAqBjB,SAArB,EAAgC5B,QAAhC,EAA0C+D,MAA1C,CAAf;AACD;AACF;AACF;AACF;AACF;;AASD,SAASM,UAAT,CACExB,QADF,EAEEE,UAFF,EAGEE,OAHF,EAIEsB,gBAJF,EAKQ;AACN1B,EAAAA,QAAQ,CAACY,aAAT,GAAyB,IAAzB;AACAR,EAAAA,OAAO,CAACP,IAAR,CAAa;AACXS,IAAAA,WAAW,EAAEoB,gBAAgB,CAACrB,MADnB;AAEXG,IAAAA,UAAU,EAAE,CAFD;AAGXmB,IAAAA,UAAU,EAAED,gBAAgB,CAACrB,MAAjB,CAAwBsB;AAHzB,GAAb;AAKAzB,EAAAA,UAAU,CAACG,MAAX,GAAoBD,OAAO,CAACxC,MAAR,GAAiB,CAArC;AACAsC,EAAAA,UAAU,CAACyB,UAAX,GAAwBD,gBAAgB,CAACrB,MAAjB,CAAwBsB,UAAhD;AACAzB,EAAAA,UAAU,CAACM,UAAX,GAAwB,CAAxB;AACA,SAAON,UAAU,CAACe,UAAlB;AACD;;AAWD,SAASQ,eAAT,CACE/B,WADF,EAEEkC,gBAFF,EAGE7C,SAHF,EAIE5B,QAJF,EAKEuE,gBALF,EAME;AACAvE,EAAAA,QAAQ,CAACiD,OAAT,CAAiBP,IAAjB,CAAsB;AACpBS,IAAAA,WAAW,EAAEoB,gBAAgB,CAACrB,MADV;AAEpBG,IAAAA,UAAU,EAAE,CAFQ;AAGpBmB,IAAAA,UAAU,EAAED,gBAAgB,CAACrB,MAAjB,CAAwBsB;AAHhB,GAAtB;AAKA,MAAMxB,WAAW,GAAGhD,QAAQ,CAACO,IAAT,CAAcyC,WAAlC;;AACA,MAAI,CAACA,WAAL,EAAkB;AAChB;AACD;;AACDA,EAAAA,WAAW,CAACN,IAAZ,CAAiB;AACfQ,IAAAA,MAAM,EAAElD,QAAQ,CAACiD,OAAT,CAAiBxC,MAAjB,GAA0B,CADnB;AAEf+D,IAAAA,UAAU,EAAED,gBAAgB,CAACrB,MAAjB,CAAwBsB,UAFrB;AAGfnB,IAAAA,UAAU,EAAE;AAHG,GAAjB;AAKA,MAAMP,SAAS,GAAG9C,QAAQ,CAACO,IAAT,CAAcuC,SAAhC;;AACA,MAAI,CAACA,SAAL,EAAgB;AACd;AACD;;AACDA,EAAAA,SAAS,CAACJ,IAAV,CAAe;AACbK,IAAAA,UAAU,EAAE,CAAAC,WAAW,SAAX,IAAAA,WAAW,WAAX,YAAAA,WAAW,CAAEvC,MAAb,IAAsB,CADrB;AAEb4C,IAAAA,UAAU,EAAE,CAFC;AAGbI,IAAAA,aAAa,EAAE,IAHF;AAIbQ,IAAAA,KAAK,EAAEQ,gBAAgB,CAACR,KAJX;AAKbL,IAAAA,IAAI,EAAE;AALO,GAAf;AAOAhC,EAAAA,SAAS,CAACgB,UAAV,oBAAiCL,WAAjC,KAAkDO,SAAS,CAACrC,MAAV,GAAmB,CAArE;AACD;;AAOD,SAASgC,wBAAT,CAAkCiC,aAAlC,EAAuE;AACrE,8BAAwDA,aAAxD,CAAOC,MAAP;AAAA,MAAOA,MAAP,sCAAgB,CAAC,CAAD,EAAI,CAAJ,CAAhB;AAAA,8BAAwDD,aAAxD,CAAwBE,QAAxB;AAAA,MAAwBA,QAAxB,sCAAmC,CAAnC;AAAA,6BAAwDF,aAAxD,CAAsCG,KAAtC;AAAA,MAAsCA,KAAtC,qCAA8C,CAAC,CAAD,EAAI,CAAJ,CAA9C;AACA,MAAMC,iBAAiB,GAAG,IAAIjF,aAAJ,GAAcsE,GAAd,CAAkB,CAAlB,EAAqB,CAArB,EAAwB,CAAxB,EAA2B,CAA3B,EAA8B,CAA9B,EAAiC,CAAjC,EAAoCQ,MAAM,CAAC,CAAD,CAA1C,EAA+CA,MAAM,CAAC,CAAD,CAArD,EAA0D,CAA1D,CAA1B;AACA,MAAMI,cAAc,GAAGnF,qBAAqB,CAACuE,GAAtB,CACrBa,IAAI,CAACC,GAAL,CAASL,QAAT,CADqB,EAErBI,IAAI,CAACE,GAAL,CAASN,QAAT,CAFqB,EAGrB,CAHqB,EAIrB,CAACI,IAAI,CAACE,GAAL,CAASN,QAAT,CAJoB,EAKrBI,IAAI,CAACC,GAAL,CAASL,QAAT,CALqB,EAMrB,CANqB,EAOrB,CAPqB,EAQrB,CARqB,EASrB,CATqB,CAAvB;AAWA,MAAMO,WAAW,GAAGrF,kBAAkB,CAACqE,GAAnB,CAAuBU,KAAK,CAAC,CAAD,CAA5B,EAAiC,CAAjC,EAAoC,CAApC,EAAuC,CAAvC,EAA0CA,KAAK,CAAC,CAAD,CAA/C,EAAoD,CAApD,EAAuD,CAAvD,EAA0D,CAA1D,EAA6D,CAA7D,CAApB;AACA,SAAOC,iBAAiB,CAACM,aAAlB,CAAgCL,cAAhC,EAAgDK,aAAhD,CAA8DD,WAA9D,CAAP;AACD","sourcesContent":["/**\n * https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_texture_transform/README.md\n */\n\nimport {Vector3, Matrix3} from '@math.gl/core';\nimport type {GLTFMeshPrimitive, GLTFWithBuffers} from '../types/gltf-types';\nimport type {GLTFLoaderOptions} from '../../gltf-loader';\nimport {getAccessorArrayTypeAndLength} from '../gltf-utils/gltf-utils';\nimport {BYTES, COMPONENTS} from '../gltf-utils/gltf-constants';\nimport {\n  Accessor,\n  BufferView,\n  MaterialNormalTextureInfo,\n  MaterialOcclusionTextureInfo,\n  TextureInfo as GLTFTextureInfo\n} from '../types/gltf-json-schema';\nimport GLTFScenegraph from '../api/gltf-scenegraph';\n\n/** Extension name */\nconst EXT_MESHOPT_TRANSFORM = 'KHR_texture_transform';\n\nexport const name = EXT_MESHOPT_TRANSFORM;\n\nconst scratchVector = new Vector3();\nconst scratchRotationMatrix = new Matrix3();\nconst scratchScaleMatrix = new Matrix3();\n\n/** Extension textureInfo https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_texture_transform#gltf-schema-updates */\ntype TextureInfo = {\n  /** The offset of the UV coordinate origin as a factor of the texture dimensions. */\n  offset?: [number, number];\n  /** Rotate the UVs by this many radians counter-clockwise around the origin. This is equivalent to a similar rotation of the image clockwise. */\n  rotation?: number;\n  /** The scale factor applied to the components of the UV coordinates. */\n  scale?: [number, number];\n  /** Overrides the textureInfo texCoord value if supplied, and if this extension is supported. */\n  texCoord?: number;\n};\n/** Intersection of all GLTF textures */\ntype CompoundGLTFTextureInfo = GLTFTextureInfo &\n  MaterialNormalTextureInfo &\n  MaterialOcclusionTextureInfo;\n/** Parameters for TEXCOORD transformation */\ntype TransformParameters = {\n  /** Original texCoord value https://www.khronos.org/registry/glTF/specs/2.0/glTF-2.0.html#_textureinfo_texcoord */\n  originalTexCoord: number;\n  /** New texCoord value from extension https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_texture_transform#gltf-schema-updates */\n  texCoord: number;\n  /** Transformation matrix */\n  matrix: Matrix3;\n};\n\n/**\n * The extension entry to process the transformation\n * @param gltfData gltf buffers and json\n * @param options GLTFLoader options\n */\nexport async function decode(gltfData: GLTFWithBuffers, options: GLTFLoaderOptions) {\n  const gltfScenegraph = new GLTFScenegraph(gltfData);\n  const extension = gltfScenegraph.getExtension(EXT_MESHOPT_TRANSFORM);\n  if (!extension) {\n    return;\n  }\n  const materials = gltfData.json.materials || [];\n  for (let i = 0; i < materials.length; i++) {\n    transformTexCoords(i, gltfData);\n  }\n}\n\n/**\n * Transform TEXCOORD by material\n * @param materialIndex processing material index\n * @param gltfData gltf buffers and json\n */\nfunction transformTexCoords(materialIndex: number, gltfData: GLTFWithBuffers): void {\n  // Save processed texCoords in order no to process the same twice\n  const processedTexCoords: [number, number][] = [];\n  const material = gltfData.json.materials?.[materialIndex];\n  const baseColorTexture = material?.pbrMetallicRoughness?.baseColorTexture;\n  if (baseColorTexture) {\n    transformPrimitives(gltfData, materialIndex, baseColorTexture, processedTexCoords);\n  }\n  const emisiveTexture = material?.emissiveTexture;\n  if (emisiveTexture) {\n    transformPrimitives(gltfData, materialIndex, emisiveTexture, processedTexCoords);\n  }\n  const normalTexture = material?.normalTexture;\n  if (normalTexture) {\n    transformPrimitives(gltfData, materialIndex, normalTexture, processedTexCoords);\n  }\n  const occlusionTexture = material?.occlusionTexture;\n  if (occlusionTexture) {\n    transformPrimitives(gltfData, materialIndex, occlusionTexture, processedTexCoords);\n  }\n  const metallicRoughnessTexture = material?.pbrMetallicRoughness?.metallicRoughnessTexture;\n  if (metallicRoughnessTexture) {\n    transformPrimitives(gltfData, materialIndex, metallicRoughnessTexture, processedTexCoords);\n  }\n}\n\n/**\n * Transform primitives of the particular material\n * @param gltfData gltf data\n * @param materialIndex primitives with this material will be transformed\n * @param texture texture object\n * @param processedTexCoords storage to save already processed texCoords\n */\nfunction transformPrimitives(\n  gltfData: GLTFWithBuffers,\n  materialIndex: number,\n  texture: CompoundGLTFTextureInfo,\n  processedTexCoords: [number, number][]\n) {\n  const transformParameters = getTransformParameters(texture, processedTexCoords);\n  if (!transformParameters) {\n    return;\n  }\n  const meshes = gltfData.json.meshes || [];\n  for (const mesh of meshes) {\n    for (const primitive of mesh.primitives) {\n      const material = primitive.material;\n      if (Number.isFinite(material) && materialIndex === material) {\n        transformPrimitive(gltfData, primitive, transformParameters);\n      }\n    }\n  }\n}\n\n/**\n * Get parameters for TEXCOORD transformation\n * @param texture texture object\n * @param processedTexCoords storage to save already processed texCoords\n * @returns texCoord couple and transformation matrix\n */\nfunction getTransformParameters(\n  texture: CompoundGLTFTextureInfo,\n  processedTexCoords: [number, number][]\n): TransformParameters | null {\n  const textureInfo = texture.extensions?.[EXT_MESHOPT_TRANSFORM];\n  const {texCoord: originalTexCoord = 0} = texture;\n  // If texCoord is not set in the extension, original attribute data will be replaced\n  const {texCoord = originalTexCoord} = textureInfo;\n  // Make sure that couple [originalTexCoord, extensionTexCoord] is not processed twice\n  const isProcessed =\n    processedTexCoords.findIndex(\n      ([original, newTexCoord]) => original === originalTexCoord && newTexCoord === texCoord\n    ) !== -1;\n  if (!isProcessed) {\n    const matrix = makeTransformationMatrix(textureInfo);\n    if (originalTexCoord !== texCoord) {\n      texture.texCoord = texCoord;\n    }\n    processedTexCoords.push([originalTexCoord, texCoord]);\n    return {originalTexCoord, texCoord, matrix};\n  }\n  return null;\n}\n\n/**\n * Transform `TEXCOORD_0` attribute in the primitive\n * @param gltfData gltf data\n * @param primitive primitive object\n * @param transformParameters texCoord couple and transformation matrix\n */\nfunction transformPrimitive(\n  gltfData: GLTFWithBuffers,\n  primitive: GLTFMeshPrimitive,\n  transformParameters: TransformParameters\n) {\n  const {originalTexCoord, texCoord, matrix} = transformParameters;\n  const texCoordAccessor = primitive.attributes[`TEXCOORD_${originalTexCoord}`];\n  if (Number.isFinite(texCoordAccessor)) {\n    // Get accessor of the `TEXCOORD_0` attribute\n    const accessor = gltfData.json.accessors?.[texCoordAccessor];\n    if (accessor && accessor.bufferView) {\n      // Get `bufferView` of the `accessor`\n      const bufferView = gltfData.json.bufferViews?.[accessor.bufferView];\n      if (bufferView) {\n        // Get `arrayBuffer` the `bufferView` look at\n        const {arrayBuffer, byteOffset: bufferByteOffset} = gltfData.buffers[bufferView.buffer];\n        // Resulting byteOffset is sum of the buffer, accessor and bufferView byte offsets\n        const byteOffset =\n          (bufferByteOffset || 0) + (accessor.byteOffset || 0) + (bufferView.byteOffset || 0);\n        // Deduce TypedArray type and its length from `accessor` and `bufferView` data\n        const {ArrayType, length} = getAccessorArrayTypeAndLength(accessor, bufferView);\n        // Number of bytes each component occupies\n        const bytes = BYTES[accessor.componentType];\n        // Number of components. For the `TEXCOORD_0` with `VEC2` type, it must return 2\n        const components = COMPONENTS[accessor.type];\n        // Multiplier to calculate the address of the `TEXCOORD_0` element in the arrayBuffer\n        const elementAddressScale = bufferView.byteStride || bytes * components;\n        // Data transform to Float32Array\n        const result = new Float32Array(length);\n        for (let i = 0; i < accessor.count; i++) {\n          // Take [u, v] couple from the arrayBuffer\n          const uv = new ArrayType(arrayBuffer, byteOffset + i * elementAddressScale, 2);\n          // Set and transform Vector3 per https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_texture_transform#overview\n          scratchVector.set(uv[0], uv[1], 1);\n          scratchVector.transformByMatrix3(matrix);\n          // Save result in Float32Array\n          result.set([scratchVector[0], scratchVector[1]], i * components);\n        }\n        // If texCoord the same, replace gltf structural data\n        if (originalTexCoord === texCoord) {\n          updateGltf(accessor, bufferView, gltfData.buffers, result);\n        } else {\n          // If texCoord change, create new attribute\n          createAttribute(texCoord, accessor, primitive, gltfData, result);\n        }\n      }\n    }\n  }\n}\n\n/**\n * Update GLTF structural objects with new data as we create new `Float32Array` for `TEXCOORD_0`.\n * @param accessor accessor to change\n * @param bufferView bufferView to change\n * @param buffers binary buffers\n * @param newTexcoordArray typed array with data after transformation\n */\nfunction updateGltf(\n  accessor: Accessor,\n  bufferView: BufferView,\n  buffers: {arrayBuffer: ArrayBuffer; byteOffset: number; byteLength: number}[],\n  newTexCoordArray: Float32Array\n): void {\n  accessor.componentType = 5126;\n  buffers.push({\n    arrayBuffer: newTexCoordArray.buffer,\n    byteOffset: 0,\n    byteLength: newTexCoordArray.buffer.byteLength\n  });\n  bufferView.buffer = buffers.length - 1;\n  bufferView.byteLength = newTexCoordArray.buffer.byteLength;\n  bufferView.byteOffset = 0;\n  delete bufferView.byteStride;\n}\n\n/**\n *\n * @param newTexCoord new `texCoord` value\n * @param originalAccessor original accessor object, that store data before transformation\n * @param primitive primitive object\n * @param gltfData gltf data\n * @param newTexCoordArray typed array with data after transformation\n * @returns\n */\nfunction createAttribute(\n  newTexCoord: number,\n  originalAccessor: Accessor,\n  primitive: GLTFMeshPrimitive,\n  gltfData: GLTFWithBuffers,\n  newTexCoordArray: Float32Array\n) {\n  gltfData.buffers.push({\n    arrayBuffer: newTexCoordArray.buffer,\n    byteOffset: 0,\n    byteLength: newTexCoordArray.buffer.byteLength\n  });\n  const bufferViews = gltfData.json.bufferViews;\n  if (!bufferViews) {\n    return;\n  }\n  bufferViews.push({\n    buffer: gltfData.buffers.length - 1,\n    byteLength: newTexCoordArray.buffer.byteLength,\n    byteOffset: 0\n  });\n  const accessors = gltfData.json.accessors;\n  if (!accessors) {\n    return;\n  }\n  accessors.push({\n    bufferView: bufferViews?.length - 1,\n    byteOffset: 0,\n    componentType: 5126,\n    count: originalAccessor.count,\n    type: 'VEC2'\n  });\n  primitive.attributes[`TEXCOORD_${newTexCoord}`] = accessors.length - 1;\n}\n\n/**\n * Construct transformation matrix from the extension data (transition, rotation, scale)\n * @param extensionData extension data\n * @returns transformation matrix\n */\nfunction makeTransformationMatrix(extensionData: TextureInfo): Matrix3 {\n  const {offset = [0, 0], rotation = 0, scale = [1, 1]} = extensionData;\n  const translationMatirx = new Matrix3().set(1, 0, 0, 0, 1, 0, offset[0], offset[1], 1);\n  const rotationMatirx = scratchRotationMatrix.set(\n    Math.cos(rotation),\n    Math.sin(rotation),\n    0,\n    -Math.sin(rotation),\n    Math.cos(rotation),\n    0,\n    0,\n    0,\n    1\n  );\n  const scaleMatrix = scratchScaleMatrix.set(scale[0], 0, 0, 0, scale[1], 0, 0, 0, 1);\n  return translationMatirx.multiplyRight(rotationMatirx).multiplyRight(scaleMatrix);\n}\n"],"file":"KHR_texture_transform.js"}

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

@@ -0,0 +1,131 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decode = decode;
+exports.name = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _gltfScenegraph = _interopRequireDefault(require("../../api/gltf-scenegraph"));
+
+var EXT_FEATURE_METADATA = 'EXT_feature_metadata';
+var name = EXT_FEATURE_METADATA;
+exports.name = name;
+
+function decode(_x) {
+  return _decode.apply(this, arguments);
+}
+
+function _decode() {
+  _decode = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(gltfData) {
+    var scenegraph;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            scenegraph = new _gltfScenegraph.default(gltfData);
+            decodeExtFeatureMetadata(scenegraph);
+
+          case 2:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _decode.apply(this, arguments);
+}
+
+function decodeExtFeatureMetadata(scenegraph) {
+  var _extension$schema;
+
+  var extension = scenegraph.getExtension(EXT_FEATURE_METADATA);
+  var schemaClasses = extension === null || extension === void 0 ? void 0 : (_extension$schema = extension.schema) === null || _extension$schema === void 0 ? void 0 : _extension$schema.classes;
+  var featureTables = extension === null || extension === void 0 ? void 0 : extension.featureTables;
+  var 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 (var schemaName in schemaClasses) {
+      var schemaClass = schemaClasses[schemaName];
+      var featureTable = findFeatureTableByName(featureTables, schemaName);
+
+      if (featureTable) {
+        handleFeatureTableProperties(scenegraph, featureTable, schemaClass);
+      }
+    }
+  }
+}
+
+function handleFeatureTableProperties(scenegraph, featureTable, schemaClass) {
+  for (var propertyName in schemaClass.properties) {
+    var _featureTable$propert;
+
+    var schemaProperty = schemaClass.properties[propertyName];
+    var featureTableProperty = featureTable === null || featureTable === void 0 ? void 0 : (_featureTable$propert = featureTable.properties) === null || _featureTable$propert === void 0 ? void 0 : _featureTable$propert[propertyName];
+    var numberOfFeatures = featureTable.count;
+
+    if (featureTableProperty) {
+      var data = getPropertyDataFromBinarySource(scenegraph, schemaProperty, numberOfFeatures, featureTableProperty);
+      featureTableProperty.data = data;
+    }
+  }
+}
+
+function getPropertyDataFromBinarySource(scenegraph, schemaProperty, numberOfFeatures, featureTableProperty) {
+  var bufferView = featureTableProperty.bufferView;
+  var data = scenegraph.getTypedArrayForBufferView(bufferView);
+
+  switch (schemaProperty.type) {
+    case 'STRING':
+      {
+        var stringOffsetBufferView = featureTableProperty.stringOffsetBufferView;
+        var offsetsData = scenegraph.getTypedArrayForBufferView(stringOffsetBufferView);
+        data = getStringAttributes(data, offsetsData, numberOfFeatures);
+        break;
+      }
+
+    default:
+  }
+
+  return data;
+}
+
+function findFeatureTableByName(featureTables, schemaClassName) {
+  for (var featureTableName in featureTables) {
+    var featureTable = featureTables[featureTableName];
+
+    if (featureTable.class === schemaClassName) {
+      return featureTable;
+    }
+  }
+
+  return null;
+}
+
+function getStringAttributes(data, offsetsData, stringsCount) {
+  var stringsArray = [];
+  var textDecoder = new TextDecoder('utf8');
+  var stringOffset = 0;
+  var bytesPerStringSize = 4;
+
+  for (var index = 0; index < stringsCount; index++) {
+    var stringByteSize = offsetsData[(index + 1) * bytesPerStringSize] - offsetsData[index * bytesPerStringSize];
+    var stringData = data.subarray(stringOffset, stringByteSize + stringOffset);
+    var stringAttribute = textDecoder.decode(stringData);
+    stringsArray.push(stringAttribute);
+    stringOffset += stringByteSize;
+  }
+
+  return stringsArray;
+}
+//# sourceMappingURL=EXT_feature_metadata.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/lib/extensions/deprecated/EXT_feature_metadata.ts"],"names":["EXT_FEATURE_METADATA","name","decode","gltfData","scenegraph","GLTFScenegraph","decodeExtFeatureMetadata","extension","getExtension","schemaClasses","schema","classes","featureTables","featureTextures","console","warn","schemaName","schemaClass","featureTable","findFeatureTableByName","handleFeatureTableProperties","propertyName","properties","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"],"mappings":"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","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"],"file":"EXT_feature_metadata.js"}

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

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.getBytesFromComponentType = getBytesFromComponentType;
 exports.getSizeFromAccessorType = getSizeFromAccessorType;
 exports.getGLEnumFromSamplerParameter = getGLEnumFromSamplerParameter;
+exports.BYTES = exports.COMPONENTS = void 0;
 var COMPONENTS = {
   SCALAR: 1,
   VEC2: 2,
@@ -15,6 +16,7 @@ var COMPONENTS = {
   MAT3: 9,
   MAT4: 16
 };
+exports.COMPONENTS = COMPONENTS;
 var BYTES = {
   5120: 1,
   5121: 1,
@@ -23,6 +25,7 @@ var BYTES = {
   5125: 4,
   5126: 4
 };
+exports.BYTES = BYTES;
 
 function getBytesFromComponentType(componentType) {
   return BYTES[componentType];

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/gltf-utils/gltf-constants.ts"],"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"],"mappings":";;;;;;;;AAAA,IAAMA,UAAU,GAAG;AACjBC,EAAAA,MAAM,EAAE,CADS;AAEjBC,EAAAA,IAAI,EAAE,CAFW;AAGjBC,EAAAA,IAAI,EAAE,CAHW;AAIjBC,EAAAA,IAAI,EAAE,CAJW;AAKjBC,EAAAA,IAAI,EAAE,CALW;AAMjBC,EAAAA,IAAI,EAAE,CANW;AAOjBC,EAAAA,IAAI,EAAE;AAPW,CAAnB;AAUA,IAAMC,KAAK,GAAG;AACZ,QAAM,CADM;AAEZ,QAAM,CAFM;AAGZ,QAAM,CAHM;AAIZ,QAAM,CAJM;AAKZ,QAAM,CALM;AAMZ,QAAM;AANM,CAAd;;AAWO,SAASC,yBAAT,CAAmCC,aAAnC,EAAkD;AACvD,SAAOF,KAAK,CAACE,aAAD,CAAZ;AACD;;AAEM,SAASC,uBAAT,CAAiCC,IAAjC,EAAuC;AAC5C,SAAOZ,UAAU,CAACY,IAAD,CAAjB;AACD;;AAEM,SAASC,6BAAT,CAAuCC,SAAvC,EAAkD;AACvD,MAAMC,qBAAqB,GAAG,MAA9B;AACA,MAAMC,qBAAqB,GAAG,MAA9B;AACA,MAAMC,iBAAiB,GAAG,MAA1B;AACA,MAAMC,iBAAiB,GAAG,MAA1B;AAEA,MAAMC,aAAa,GAAG;AACpBC,IAAAA,SAAS,EAAEL,qBADS;AAEpBM,IAAAA,SAAS,EAAEL,qBAFS;AAGpBM,IAAAA,KAAK,EAAEL,iBAHa;AAIpBM,IAAAA,KAAK,EAAEL;AAJa,GAAtB;AAOA,SAAOC,aAAa,CAACL,SAAD,CAApB;AACD","sourcesContent":["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\nconst 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"],"file":"gltf-constants.js"}
+{"version":3,"sources":["../../../../src/lib/gltf-utils/gltf-constants.ts"],"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"],"mappings":";;;;;;;;;AAAO,IAAMA,UAAU,GAAG;AACxBC,EAAAA,MAAM,EAAE,CADgB;AAExBC,EAAAA,IAAI,EAAE,CAFkB;AAGxBC,EAAAA,IAAI,EAAE,CAHkB;AAIxBC,EAAAA,IAAI,EAAE,CAJkB;AAKxBC,EAAAA,IAAI,EAAE,CALkB;AAMxBC,EAAAA,IAAI,EAAE,CANkB;AAOxBC,EAAAA,IAAI,EAAE;AAPkB,CAAnB;;AAUA,IAAMC,KAAK,GAAG;AACnB,QAAM,CADa;AAEnB,QAAM,CAFa;AAGnB,QAAM,CAHa;AAInB,QAAM,CAJa;AAKnB,QAAM,CALa;AAMnB,QAAM;AANa,CAAd;;;AAWA,SAASC,yBAAT,CAAmCC,aAAnC,EAAkD;AACvD,SAAOF,KAAK,CAACE,aAAD,CAAZ;AACD;;AAEM,SAASC,uBAAT,CAAiCC,IAAjC,EAAuC;AAC5C,SAAOZ,UAAU,CAACY,IAAD,CAAjB;AACD;;AAEM,SAASC,6BAAT,CAAuCC,SAAvC,EAAkD;AACvD,MAAMC,qBAAqB,GAAG,MAA9B;AACA,MAAMC,qBAAqB,GAAG,MAA9B;AACA,MAAMC,iBAAiB,GAAG,MAA1B;AACA,MAAMC,iBAAiB,GAAG,MAA1B;AAEA,MAAMC,aAAa,GAAG;AACpBC,IAAAA,SAAS,EAAEL,qBADS;AAEpBM,IAAAA,SAAS,EAAEL,qBAFS;AAGpBM,IAAAA,KAAK,EAAEL,iBAHa;AAIpBM,IAAAA,KAAK,EAAEL;AAJa,GAAtB;AAOA,SAAOC,aAAa,CAACL,SAAD,CAApB;AACD","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"],"file":"gltf-constants.js"}

package/dist/es5/lib/utils/version.js

@@ -4,6 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.VERSION = void 0;
-var VERSION = typeof "3.2.7" !== 'undefined' ? "3.2.7" : 'latest';
+var VERSION = typeof "3.3.0-alpha.3" !== 'undefined' ? "3.3.0-alpha.3" : 'latest';
 exports.VERSION = VERSION;
 //# sourceMappingURL=version.js.map

package/dist/es5/lib/utils/version.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/utils/version.ts"],"names":["VERSION"],"mappings":";;;;;;AAGO,IAAMA,OAAO,GAAG,mBAAuB,WAAvB,aAAmD,QAAnE","sourcesContent":["// Version constant cannot be imported, it needs to correspond to the build version of **this** module.\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nexport const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n"],"file":"version.js"}
+{"version":3,"sources":["../../../../src/lib/utils/version.ts"],"names":["VERSION"],"mappings":";;;;;;AAGO,IAAMA,OAAO,GAAG,2BAAuB,WAAvB,qBAAmD,QAAnE","sourcesContent":["// Version constant cannot be imported, it needs to correspond to the build version of **this** module.\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nexport const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n"],"file":"version.js"}

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"names":["GLTFLoader","GLTFWriter","GLBLoader","GLBWriter","default","GLTFScenegraph","postProcessGLTF"],"mappings":"AA6BA,SAAQA,UAAR,QAAyB,eAAzB;AACA,SAAQC,UAAR,QAAyB,eAAzB;AAGA,SAAQC,SAAR,QAAwB,cAAxB;AACA,SAAQC,SAAR,QAAwB,cAAxB;AAGA,SAAQC,OAAO,IAAIC,cAAnB,QAAwC,2BAAxC;AACA,SAAQC,eAAR,QAA8B,6BAA9B","sourcesContent":["/* eslint-disable camelcase, indent */\nexport type {GLB} from './lib/types/glb-types';\nexport type {\n  GLTF,\n  GLTFAccessor,\n  GLTFBuffer,\n  GLTFBufferView,\n  GLTFMeshPrimitive,\n  GLTFMesh,\n  GLTFNode,\n  GLTFMaterial,\n  GLTFSampler,\n  GLTFScene,\n  GLTFSkin,\n  GLTFTexture,\n  GLTFImage,\n  GLTFPostprocessed,\n  GLTFNodePostprocessed,\n  GLTFMaterialPostprocessed,\n  GLTFImagePostprocessed,\n  // The following extensions are handled by the GLTFLoader and removed from the parsed glTF (disable via options.gltf.excludeExtensions)\n  GLTF_KHR_binary_glTF,\n  GLTF_KHR_draco_mesh_compression,\n  GLTF_KHR_texture_basisu,\n  GLTF_EXT_meshopt_compression,\n  GLTF_EXT_texture_webp\n} from './lib/types/gltf-types';\n\n// glTF loader/writer definition objects\nexport {GLTFLoader} from './gltf-loader';\nexport {GLTFWriter} from './gltf-writer';\n\n// GLB Loader & Writer (for custom formats that want to leverage the GLB binary \"envelope\")\nexport {GLBLoader} from './glb-loader';\nexport {GLBWriter} from './glb-writer';\n\n// glTF Data Access Helper Class\nexport {default as GLTFScenegraph} from './lib/api/gltf-scenegraph';\nexport {postProcessGLTF} from './lib/api/post-process-gltf';\nexport type {Mesh} from './lib/types/gltf-json-schema';\nexport type {GLTFObject} from './lib/types/gltf-types';\n"],"file":"index.js"}
+{"version":3,"sources":["../../src/index.ts"],"names":["GLTFLoader","GLTFWriter","GLBLoader","GLBWriter","default","GLTFScenegraph","postProcessGLTF"],"mappings":"AA8BA,SAAQA,UAAR,QAAyB,eAAzB;AACA,SAAQC,UAAR,QAAyB,eAAzB;AAGA,SAAQC,SAAR,QAAwB,cAAxB;AACA,SAAQC,SAAR,QAAwB,cAAxB;AAGA,SAAQC,OAAO,IAAIC,cAAnB,QAAwC,2BAAxC;AACA,SAAQC,eAAR,QAA8B,6BAA9B","sourcesContent":["/* eslint-disable camelcase, indent */\nexport type {GLB} from './lib/types/glb-types';\nexport type {\n  GLTF,\n  GLTFAccessor,\n  GLTFBuffer,\n  GLTFBufferView,\n  GLTFMeshPrimitive,\n  GLTFMesh,\n  GLTFNode,\n  GLTFMaterial,\n  GLTFSampler,\n  GLTFScene,\n  GLTFSkin,\n  GLTFTexture,\n  GLTFImage,\n  GLTFPostprocessed,\n  GLTFNodePostprocessed,\n  GLTFMaterialPostprocessed,\n  GLTFImagePostprocessed,\n  // The following extensions are handled by the GLTFLoader and removed from the parsed glTF (disable via options.gltf.excludeExtensions)\n  GLTF_KHR_binary_glTF,\n  GLTF_KHR_draco_mesh_compression,\n  GLTF_KHR_texture_basisu,\n  GLTF_EXT_meshopt_compression,\n  GLTF_EXT_texture_webp,\n  GLTF_EXT_feature_metadata\n} from './lib/types/gltf-types';\n\n// glTF loader/writer definition objects\nexport {GLTFLoader} from './gltf-loader';\nexport {GLTFWriter} from './gltf-writer';\n\n// GLB Loader & Writer (for custom formats that want to leverage the GLB binary \"envelope\")\nexport {GLBLoader} from './glb-loader';\nexport {GLBWriter} from './glb-writer';\n\n// glTF Data Access Helper Class\nexport {default as GLTFScenegraph} from './lib/api/gltf-scenegraph';\nexport {postProcessGLTF} from './lib/api/post-process-gltf';\nexport type {Mesh} from './lib/types/gltf-json-schema';\nexport type {GLTFObject} from './lib/types/gltf-types';\n"],"file":"index.js"}