babylonjs-loaders 8.26.0 → 8.26.1

package/babylon.glTF2FileLoader.min.js.map

@@ -1 +1 @@
-{"version":3,"file":"babylon.glTF2FileLoader.min.js","mappings":"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","sources":["webpack://LOADERS/webpack/universalModuleDefinition","webpack://LOADERS/webpack/runtime/create fake namespace object","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_interactivity/flowGraphGLTFDataProvider.ts","webpack://LOADERS/../../../../node_modules/tslib/tslib.es6.mjs","webpack://LOADERS/external umd {\"root\":\"BABYLON\",\"commonjs\":\"babylonjs\",\"commonjs2\":\"babylonjs\",\"amd\":\"babylonjs\"}","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/gltfPathToObjectConverter.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/objectModelMapping.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/glTFLoaderAnimation.ts","webpack://LOADERS/webpack/bootstrap","webpack://LOADERS/webpack/runtime/compat get default export","webpack://LOADERS/webpack/runtime/define property getters","webpack://LOADERS/webpack/runtime/global","webpack://LOADERS/webpack/runtime/hasOwnProperty shorthand","webpack://LOADERS/webpack/runtime/make namespace object","webpack://LOADERS/../../../dev/loaders/src/glTF/glTFValidation.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/glTFFileLoader.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/glTFFileLoader.metadata.ts","webpack://LOADERS/../../../lts/loaders/src/legacy/legacy-glTF.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/glTFLoaderExtensionRegistry.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/glTFLoader.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/EXT_lights_image_based.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/EXT_mesh_gpu_instancing.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/EXT_meshopt_compression.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/EXT_texture_webp.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/EXT_texture_avif.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/EXT_lights_ies.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_draco_mesh_compression.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_lights_punctual.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_pbrSpecularGlossiness.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_unlit.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_clearcoat.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_iridescence.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_anisotropy.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_emissive_strength.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_sheen.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_specular.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_ior.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_variants.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_transmission.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_diffuse_transmission.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_volume.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_dispersion.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/EXT_materials_diffuse_roughness.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_mesh_quantization.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_texture_basisu.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_texture_transform.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_xmp_json_ld.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_animation_pointer.data.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_animation_pointer.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/MSFT_audio_emitter.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/MSFT_lod.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/MSFT_minecraftMesh.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/MSFT_sRGBFactors.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_interactivity/declarationMapper.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_interactivity/interactivityGraphParser.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_interactivity.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_node_visibility.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_node_selectability.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_node_hoverability.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/ExtrasAsMetadata.ts","webpack://LOADERS/../../../lts/loaders/src/legacy/legacy-glTF2.ts","webpack://LOADERS/./src/glTF2FileLoader.ts"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"babylonjs\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"babylonjs-loaders\", [\"babylonjs\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"babylonjs-loaders\"] = factory(require(\"babylonjs\"));\n\telse\n\t\troot[\"LOADERS\"] = factory(root[\"BABYLON\"]);\n})((typeof self !== \"undefined\" ? self : typeof global !== \"undefined\" ? global : this), (__WEBPACK_EXTERNAL_MODULE__597__) => {\nreturn ","var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);\nvar leafPrototypes;\n// create a fake namespace object\n// mode & 1: value is a module id, require it\n// mode & 2: merge all properties of value into the ns\n// mode & 4: return value when already ns object\n// mode & 16: return value when it's Promise-like\n// mode & 8|1: behave like require\n__webpack_require__.t = function(value, mode) {\n\tif(mode & 1) value = this(value);\n\tif(mode & 8) return value;\n\tif(typeof value === 'object' && value) {\n\t\tif((mode & 4) && value.__esModule) return value;\n\t\tif((mode & 16) && typeof value.then === 'function') return value;\n\t}\n\tvar ns = Object.create(null);\n\t__webpack_require__.r(ns);\n\tvar def = {};\n\tleafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];\n\tfor(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {\n\t\tObject.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));\n\t}\n\tdef['default'] = () => (value);\n\t__webpack_require__.d(ns, def);\n\treturn ns;\n};","import type { IFlowGraphBlockConfiguration } from \"core/FlowGraph/flowGraphBlock\";\nimport { FlowGraphBlock } from \"core/FlowGraph/flowGraphBlock\";\nimport type { IGLTF } from \"../../glTFLoaderInterfaces\";\nimport type { FlowGraphDataConnection } from \"core/FlowGraph/flowGraphDataConnection\";\nimport type { AnimationGroup } from \"core/Animations/animationGroup\";\nimport type { TransformNode } from \"core/Meshes/transformNode\";\nimport { RichTypeAny } from \"core/FlowGraph/flowGraphRichTypes\";\n\n/**\n * a configuration interface for this block\n */\nexport interface IFlowGraphGLTFDataProviderBlockConfiguration extends IFlowGraphBlockConfiguration {\n    /**\n     * the glTF object to provide data from\n     */\n    glTF: IGLTF;\n}\n\n/**\n * a glTF-based FlowGraph block that provides arrays with babylon object, based on the glTF tree\n * Can be used, for example, to get animation index from a glTF animation\n */\nexport class FlowGraphGLTFDataProvider extends FlowGraphBlock {\n    /**\n     * Output: an array of animation groups\n     * Corresponds directly to the glTF animations array\n     */\n    public readonly animationGroups: FlowGraphDataConnection<AnimationGroup[]>;\n\n    /**\n     * Output an array of (Transform) nodes\n     * Corresponds directly to the glTF nodes array\n     */\n    public readonly nodes: FlowGraphDataConnection<TransformNode[]>;\n\n    constructor(config: IFlowGraphGLTFDataProviderBlockConfiguration) {\n        super();\n        const glTF = config.glTF;\n        const animationGroups = glTF.animations?.map((a) => a._babylonAnimationGroup) || [];\n        this.animationGroups = this.registerDataOutput(\"animationGroups\", RichTypeAny, animationGroups);\n        const nodes = glTF.nodes?.map((n) => n._babylonTransformNode) || [];\n        this.nodes = this.registerDataOutput(\"nodes\", RichTypeAny, nodes);\n    }\n\n    public override getClassName(): string {\n        return \"FlowGraphGLTFDataProvider\";\n    }\n}\n","/******************************************************************************\nCopyright (c) Microsoft Corporation.\n\nPermission to use, copy, modify, and/or distribute this software for any\npurpose with or without fee is hereby granted.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\nPERFORMANCE OF THIS SOFTWARE.\n***************************************************************************** */\n/* global Reflect, Promise, SuppressedError, Symbol, Iterator */\n\nvar extendStatics = function(d, b) {\n  extendStatics = Object.setPrototypeOf ||\n      ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n      function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n  return extendStatics(d, b);\n};\n\nexport function __extends(d, b) {\n  if (typeof b !== \"function\" && b !== null)\n      throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n  extendStatics(d, b);\n  function __() { this.constructor = d; }\n  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n}\n\nexport var __assign = function() {\n  __assign = Object.assign || function __assign(t) {\n      for (var s, i = 1, n = arguments.length; i < n; i++) {\n          s = arguments[i];\n          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n      }\n      return t;\n  }\n  return __assign.apply(this, arguments);\n}\n\nexport function __rest(s, e) {\n  var t = {};\n  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n      t[p] = s[p];\n  if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n      for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n          if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n              t[p[i]] = s[p[i]];\n      }\n  return t;\n}\n\nexport function __decorate(decorators, target, key, desc) {\n  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n  if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n  return c > 3 && r && Object.defineProperty(target, key, r), r;\n}\n\nexport function __param(paramIndex, decorator) {\n  return function (target, key) { decorator(target, key, paramIndex); }\n}\n\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\n  function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\n  var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\n  var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\n  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\n  var _, done = false;\n  for (var i = decorators.length - 1; i >= 0; i--) {\n      var context = {};\n      for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\n      for (var p in contextIn.access) context.access[p] = contextIn.access[p];\n      context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\n      var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\n      if (kind === \"accessor\") {\n          if (result === void 0) continue;\n          if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\n          if (_ = accept(result.get)) descriptor.get = _;\n          if (_ = accept(result.set)) descriptor.set = _;\n          if (_ = accept(result.init)) initializers.unshift(_);\n      }\n      else if (_ = accept(result)) {\n          if (kind === \"field\") initializers.unshift(_);\n          else descriptor[key] = _;\n      }\n  }\n  if (target) Object.defineProperty(target, contextIn.name, descriptor);\n  done = true;\n};\n\nexport function __runInitializers(thisArg, initializers, value) {\n  var useValue = arguments.length > 2;\n  for (var i = 0; i < initializers.length; i++) {\n      value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\n  }\n  return useValue ? value : void 0;\n};\n\nexport function __propKey(x) {\n  return typeof x === \"symbol\" ? x : \"\".concat(x);\n};\n\nexport function __setFunctionName(f, name, prefix) {\n  if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\n  return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\n};\n\nexport function __metadata(metadataKey, metadataValue) {\n  if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\n}\n\nexport function __awaiter(thisArg, _arguments, P, generator) {\n  function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n  return new (P || (P = Promise))(function (resolve, reject) {\n      function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n      function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n      function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n      step((generator = generator.apply(thisArg, _arguments || [])).next());\n  });\n}\n\nexport function __generator(thisArg, body) {\n  var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === \"function\" ? Iterator : Object).prototype);\n  return g.next = verb(0), g[\"throw\"] = verb(1), g[\"return\"] = verb(2), typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n  function verb(n) { return function (v) { return step([n, v]); }; }\n  function step(op) {\n      if (f) throw new TypeError(\"Generator is already executing.\");\n      while (g && (g = 0, op[0] && (_ = 0)), _) try {\n          if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n          if (y = 0, t) op = [op[0] & 2, t.value];\n          switch (op[0]) {\n              case 0: case 1: t = op; break;\n              case 4: _.label++; return { value: op[1], done: false };\n              case 5: _.label++; y = op[1]; op = [0]; continue;\n              case 7: op = _.ops.pop(); _.trys.pop(); continue;\n              default:\n                  if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                  if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                  if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                  if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                  if (t[2]) _.ops.pop();\n                  _.trys.pop(); continue;\n          }\n          op = body.call(thisArg, _);\n      } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n      if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n  }\n}\n\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  var desc = Object.getOwnPropertyDescriptor(m, k);\n  if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n  }\n  Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  o[k2] = m[k];\n});\n\nexport function __exportStar(m, o) {\n  for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\n}\n\nexport function __values(o) {\n  var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n  if (m) return m.call(o);\n  if (o && typeof o.length === \"number\") return {\n      next: function () {\n          if (o && i >= o.length) o = void 0;\n          return { value: o && o[i++], done: !o };\n      }\n  };\n  throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n}\n\nexport function __read(o, n) {\n  var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n  if (!m) return o;\n  var i = m.call(o), r, ar = [], e;\n  try {\n      while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n  }\n  catch (error) { e = { error: error }; }\n  finally {\n      try {\n          if (r && !r.done && (m = i[\"return\"])) m.call(i);\n      }\n      finally { if (e) throw e.error; }\n  }\n  return ar;\n}\n\n/** @deprecated */\nexport function __spread() {\n  for (var ar = [], i = 0; i < arguments.length; i++)\n      ar = ar.concat(__read(arguments[i]));\n  return ar;\n}\n\n/** @deprecated */\nexport function __spreadArrays() {\n  for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\n  for (var r = Array(s), k = 0, i = 0; i < il; i++)\n      for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\n          r[k] = a[j];\n  return r;\n}\n\nexport function __spreadArray(to, from, pack) {\n  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n      if (ar || !(i in from)) {\n          if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n          ar[i] = from[i];\n      }\n  }\n  return to.concat(ar || Array.prototype.slice.call(from));\n}\n\nexport function __await(v) {\n  return this instanceof __await ? (this.v = v, this) : new __await(v);\n}\n\nexport function __asyncGenerator(thisArg, _arguments, generator) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var g = generator.apply(thisArg, _arguments || []), i, q = [];\n  return i = Object.create((typeof AsyncIterator === \"function\" ? AsyncIterator : Object).prototype), verb(\"next\"), verb(\"throw\"), verb(\"return\", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;\n  function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }\n  function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }\n  function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\n  function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\n  function fulfill(value) { resume(\"next\", value); }\n  function reject(value) { resume(\"throw\", value); }\n  function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\n}\n\nexport function __asyncDelegator(o) {\n  var i, p;\n  return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\n  function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\n}\n\nexport function __asyncValues(o) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var m = o[Symbol.asyncIterator], i;\n  return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\n  function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\n  function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\n}\n\nexport function __makeTemplateObject(cooked, raw) {\n  if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\n  return cooked;\n};\n\nvar __setModuleDefault = Object.create ? (function(o, v) {\n  Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n  o[\"default\"] = v;\n};\n\nvar ownKeys = function(o) {\n  ownKeys = Object.getOwnPropertyNames || function (o) {\n    var ar = [];\n    for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;\n    return ar;\n  };\n  return ownKeys(o);\n};\n\nexport function __importStar(mod) {\n  if (mod && mod.__esModule) return mod;\n  var result = {};\n  if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== \"default\") __createBinding(result, mod, k[i]);\n  __setModuleDefault(result, mod);\n  return result;\n}\n\nexport function __importDefault(mod) {\n  return (mod && mod.__esModule) ? mod : { default: mod };\n}\n\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n  return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n}\n\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\n  if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n  return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n}\n\nexport function __classPrivateFieldIn(state, receiver) {\n  if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\n  return typeof state === \"function\" ? receiver === state : state.has(receiver);\n}\n\nexport function __addDisposableResource(env, value, async) {\n  if (value !== null && value !== void 0) {\n    if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\n    var dispose, inner;\n    if (async) {\n      if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\n      dispose = value[Symbol.asyncDispose];\n    }\n    if (dispose === void 0) {\n      if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\n      dispose = value[Symbol.dispose];\n      if (async) inner = dispose;\n    }\n    if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\n    if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };\n    env.stack.push({ value: value, dispose: dispose, async: async });\n  }\n  else if (async) {\n    env.stack.push({ async: true });\n  }\n  return value;\n}\n\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\n  var e = new Error(message);\n  return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\n};\n\nexport function __disposeResources(env) {\n  function fail(e) {\n    env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\n    env.hasError = true;\n  }\n  var r, s = 0;\n  function next() {\n    while (r = env.stack.pop()) {\n      try {\n        if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);\n        if (r.dispose) {\n          var result = r.dispose.call(r.value);\n          if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\n        }\n        else s |= 1;\n      }\n      catch (e) {\n        fail(e);\n      }\n    }\n    if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();\n    if (env.hasError) throw env.error;\n  }\n  return next();\n}\n\nexport function __rewriteRelativeImportExtension(path, preserveJsx) {\n  if (typeof path === \"string\" && /^\\.\\.?\\//.test(path)) {\n      return path.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+?)?)\\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {\n          return tsx ? preserveJsx ? \".jsx\" : \".js\" : d && (!ext || !cm) ? m : (d + ext + \".\" + cm.toLowerCase() + \"js\");\n      });\n  }\n  return path;\n}\n\nexport default {\n  __extends,\n  __assign,\n  __rest,\n  __decorate,\n  __param,\n  __esDecorate,\n  __runInitializers,\n  __propKey,\n  __setFunctionName,\n  __metadata,\n  __awaiter,\n  __generator,\n  __createBinding,\n  __exportStar,\n  __values,\n  __read,\n  __spread,\n  __spreadArrays,\n  __spreadArray,\n  __await,\n  __asyncGenerator,\n  __asyncDelegator,\n  __asyncValues,\n  __makeTemplateObject,\n  __importStar,\n  __importDefault,\n  __classPrivateFieldGet,\n  __classPrivateFieldSet,\n  __classPrivateFieldIn,\n  __addDisposableResource,\n  __disposeResources,\n  __rewriteRelativeImportExtension,\n};\n","module.exports = __WEBPACK_EXTERNAL_MODULE__597__;","import type { IObjectInfo, IPathToObjectConverter } from \"core/ObjectModel/objectModelInterfaces\";\r\nimport type { IGLTF } from \"../glTFLoaderInterfaces\";\r\nimport type { IObjectAccessor } from \"core/FlowGraph/typeDefinitions\";\r\n\r\n/**\r\n * Adding an exception here will break traversing through the glTF object tree.\r\n * This is used for properties that might not be in the glTF object model, but are optional and have a default value.\r\n * For example, the path /nodes/\\{\\}/extensions/KHR_node_visibility/visible is optional - the object can be deferred without the object fully existing.\r\n */\r\nexport const OptionalPathExceptionsList: {\r\n    regex: RegExp;\r\n}[] = [\r\n    {\r\n        // get the node as object when reading an extension\r\n        regex: new RegExp(`^/nodes/\\\\d+/extensions/`),\r\n    },\r\n];\r\n\r\n/**\r\n * A converter that takes a glTF Object Model JSON Pointer\r\n * and transforms it into an ObjectAccessorContainer, allowing\r\n * objects referenced in the glTF to be associated with their\r\n * respective Babylon.js objects.\r\n */\r\nexport class GLTFPathToObjectConverter<T, BabylonType, BabylonValue> implements IPathToObjectConverter<IObjectAccessor<T, BabylonType, BabylonValue>> {\r\n    public constructor(\r\n        private _gltf: IGLTF,\r\n        private _infoTree: any\r\n    ) {}\r\n\r\n    /**\r\n     * The pointer string is represented by a [JSON pointer](https://datatracker.ietf.org/doc/html/rfc6901).\r\n     * See also https://github.com/KhronosGroup/glTF/blob/main/specification/2.0/ObjectModel.adoc#core-pointers\r\n     * <animationPointer> := /<rootNode>/<assetIndex>/<propertyPath>\r\n     * <rootNode> := \"nodes\" | \"materials\" | \"meshes\" | \"cameras\" | \"extensions\"\r\n     * <assetIndex> := <digit> | <name>\r\n     * <propertyPath> := <extensionPath> | <standardPath>\r\n     * <extensionPath> := \"extensions\"/<name>/<standardPath>\r\n     * <standardPath> := <name> | <name>/<standardPath>\r\n     * <name> := W+\r\n     * <digit> := D+\r\n     *\r\n     * Examples:\r\n     *  - \"/nodes/0/rotation\"\r\n     * - \"/nodes.length\"\r\n     *  - \"/materials/2/emissiveFactor\"\r\n     *  - \"/materials/2/pbrMetallicRoughness/baseColorFactor\"\r\n     *  - \"/materials/2/extensions/KHR_materials_emissive_strength/emissiveStrength\"\r\n     *\r\n     * @param path The path to convert\r\n     * @returns The object and info associated with the path\r\n     */\r\n    public convert(path: string): IObjectInfo<IObjectAccessor<T, BabylonType, BabylonValue>> {\r\n        let objectTree: any = this._gltf;\r\n        let infoTree: any = this._infoTree;\r\n        let target: any = undefined;\r\n\r\n        if (!path.startsWith(\"/\")) {\r\n            throw new Error(\"Path must start with a /\");\r\n        }\r\n        const parts = path.split(\"/\");\r\n        parts.shift();\r\n\r\n        //if the last part has \".length\" in it, separate that as an extra part\r\n        if (parts[parts.length - 1].includes(\".length\")) {\r\n            const lastPart = parts[parts.length - 1];\r\n            const split = lastPart.split(\".\");\r\n            parts.pop();\r\n            parts.push(...split);\r\n        }\r\n\r\n        let ignoreObjectTree = false;\r\n\r\n        for (const part of parts) {\r\n            const isLength = part === \"length\";\r\n            if (isLength && !infoTree.__array__) {\r\n                throw new Error(`Path ${path} is invalid`);\r\n            }\r\n            if (infoTree.__ignoreObjectTree__) {\r\n                ignoreObjectTree = true;\r\n            }\r\n            if (infoTree.__array__ && !isLength) {\r\n                infoTree = infoTree.__array__;\r\n            } else {\r\n                infoTree = infoTree[part];\r\n                if (!infoTree) {\r\n                    throw new Error(`Path ${path} is invalid`);\r\n                }\r\n            }\r\n            if (!ignoreObjectTree) {\r\n                if (objectTree === undefined) {\r\n                    // check if the path is in the exception list. If it is, break and return the last object that was found\r\n                    const exception = OptionalPathExceptionsList.find((e) => e.regex.test(path));\r\n                    if (!exception) {\r\n                        throw new Error(`Path ${path} is invalid`);\r\n                    }\r\n                } else if (!isLength) {\r\n                    objectTree = objectTree?.[part];\r\n                }\r\n            }\r\n\r\n            if (infoTree.__target__ || isLength) {\r\n                target = objectTree;\r\n            }\r\n        }\r\n\r\n        return {\r\n            object: target,\r\n            info: infoTree,\r\n        };\r\n    }\r\n}\r\n","/* eslint-disable @typescript-eslint/naming-convention */\n\nimport type { TransformNode } from \"core/Meshes/transformNode\";\nimport type { IAnimation, ICamera, IGLTF, IKHRLightsPunctual_Light, IMaterial, IMesh, INode } from \"../glTFLoaderInterfaces\";\nimport type { Vector3 } from \"core/Maths/math.vector\";\nimport { Matrix, Quaternion, Vector2 } from \"core/Maths/math.vector\";\nimport { Constants } from \"core/Engines/constants\";\nimport type { Color3 } from \"core/Maths/math.color\";\nimport { Color4 } from \"core/Maths/math.color\";\nimport type { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\nimport type { Light } from \"core/Lights/light\";\nimport type { Nullable } from \"core/types\";\nimport { SpotLight } from \"core/Lights/spotLight\";\nimport type { IEXTLightsImageBased_LightImageBased } from \"babylonjs-gltf2interface\";\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\nimport type { IInterpolationPropertyInfo, IObjectAccessor } from \"core/FlowGraph/typeDefinitions\";\nimport { GLTFPathToObjectConverter } from \"./gltfPathToObjectConverter\";\nimport type { AnimationGroup } from \"core/Animations/animationGroup\";\nimport type { Mesh } from \"core/Meshes/mesh\";\n\nexport interface IGLTFObjectModelTree {\n    cameras: IGLTFObjectModelTreeCamerasObject;\n    nodes: IGLTFObjectModelTreeNodesObject;\n    materials: IGLTFObjectModelTreeMaterialsObject;\n    extensions: IGLTFObjectModelTreeExtensionsObject;\n    animations: {\n        length: IObjectAccessor<IAnimation[], AnimationGroup[], number>;\n        __array__: {};\n    };\n    meshes: {\n        length: IObjectAccessor<IMesh[], (Mesh | undefined)[], number>;\n        __array__: {};\n    };\n}\n\nexport interface IGLTFObjectModelTreeNodesObject<GLTFTargetType = INode, BabylonTargetType = TransformNode> {\n    length: IObjectAccessor<GLTFTargetType[], BabylonTargetType[], number>;\n    __array__: {\n        __target__: boolean;\n        translation: IObjectAccessor<GLTFTargetType, BabylonTargetType, Vector3>;\n        rotation: IObjectAccessor<GLTFTargetType, BabylonTargetType, Quaternion>;\n        scale: IObjectAccessor<GLTFTargetType, BabylonTargetType, Vector3>;\n        matrix: IObjectAccessor<GLTFTargetType, BabylonTargetType, Matrix>;\n        globalMatrix: IObjectAccessor<GLTFTargetType, BabylonTargetType, Matrix>;\n        weights: {\n            length: IObjectAccessor<GLTFTargetType, BabylonTargetType, number>;\n            __array__: { __target__: boolean } & IObjectAccessor<GLTFTargetType, BabylonTargetType, number>;\n        } & IObjectAccessor<GLTFTargetType, BabylonTargetType, number[]>;\n        extensions: {\n            EXT_lights_ies?: {\n                multiplier: IObjectAccessor<INode, Light, number>;\n                color: IObjectAccessor<INode, Light, Color3>;\n            };\n        };\n    };\n}\n\nexport interface IGLTFObjectModelTreeCamerasObject {\n    __array__: {\n        __target__: boolean;\n        orthographic: {\n            xmag: IObjectAccessor<ICamera, ICamera, Vector2>;\n            ymag: IObjectAccessor<ICamera, ICamera, Vector2>;\n            zfar: IObjectAccessor<ICamera, ICamera, number>;\n            znear: IObjectAccessor<ICamera, ICamera, number>;\n        };\n        perspective: {\n            yfov: IObjectAccessor<ICamera, ICamera, number>;\n            zfar: IObjectAccessor<ICamera, ICamera, number>;\n            znear: IObjectAccessor<ICamera, ICamera, number>;\n            aspectRatio: IObjectAccessor<ICamera, ICamera, Nullable<number>>;\n        };\n    };\n}\n\nexport interface IGLTFObjectModelTreeMaterialsObject {\n    __array__: {\n        __target__: boolean;\n        pbrMetallicRoughness: {\n            baseColorFactor: IObjectAccessor<IMaterial, PBRMaterial, Color4>;\n            metallicFactor: IObjectAccessor<IMaterial, PBRMaterial, Nullable<number>>;\n            roughnessFactor: IObjectAccessor<IMaterial, PBRMaterial, Nullable<number>>;\n            baseColorTexture: {\n                extensions: {\n                    KHR_texture_transform: ITextureDefinition;\n                };\n            };\n            metallicRoughnessTexture: {\n                extensions: {\n                    KHR_texture_transform: ITextureDefinition;\n                };\n            };\n        };\n        emissiveFactor: IObjectAccessor<IMaterial, PBRMaterial, Color3>;\n        normalTexture: {\n            scale: IObjectAccessor<IMaterial, PBRMaterial, number>;\n            extensions: {\n                KHR_texture_transform: ITextureDefinition;\n            };\n        };\n        occlusionTexture: {\n            strength: IObjectAccessor<IMaterial, PBRMaterial, number>;\n            extensions: {\n                KHR_texture_transform: ITextureDefinition;\n            };\n        };\n        emissiveTexture: {\n            extensions: {\n                KHR_texture_transform: ITextureDefinition;\n            };\n        };\n        extensions: {\n            KHR_materials_anisotropy: {\n                anisotropyStrength: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                anisotropyRotation: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                anisotropyTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n            };\n            KHR_materials_clearcoat: {\n                clearcoatFactor: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                clearcoatRoughnessFactor: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                clearcoatTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n                clearcoatNormalTexture: {\n                    scale: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n                clearcoatRoughnessTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n            };\n            KHR_materials_dispersion: {\n                dispersion: IObjectAccessor<IMaterial, PBRMaterial, number>;\n            };\n            KHR_materials_emissive_strength: {\n                emissiveStrength: IObjectAccessor<IMaterial, PBRMaterial, number>;\n            };\n            KHR_materials_ior: {\n                ior: IObjectAccessor<IMaterial, PBRMaterial, number>;\n            };\n            KHR_materials_iridescence: {\n                iridescenceFactor: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                iridescenceIor: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                iridescenceThicknessMinimum: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                iridescenceThicknessMaximum: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                iridescenceTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n                iridescenceThicknessTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n            };\n            KHR_materials_sheen: {\n                sheenColorFactor: IObjectAccessor<IMaterial, PBRMaterial, Color3>;\n                sheenRoughnessFactor: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                sheenColorTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n                sheenRoughnessTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n            };\n            KHR_materials_specular: {\n                specularFactor: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                specularColorFactor: IObjectAccessor<IMaterial, PBRMaterial, Color3>;\n                specularTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n                specularColorTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n            };\n            KHR_materials_transmission: {\n                transmissionFactor: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                transmissionTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n            };\n            KHR_materials_diffuse_transmission: {\n                diffuseTransmissionFactor: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                diffuseTransmissionTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n                diffuseTransmissionColorFactor: IObjectAccessor<IMaterial, PBRMaterial, Nullable<Color3>>;\n                diffuseTransmissionColorTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n            };\n            KHR_materials_volume: {\n                thicknessFactor: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                attenuationColor: IObjectAccessor<IMaterial, PBRMaterial, Color3>;\n                attenuationDistance: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                thicknessTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n            };\n        };\n    };\n}\n\ninterface ITextureDefinition {\n    offset: IObjectAccessor<IMaterial, PBRMaterial, Vector2>;\n    rotation: IObjectAccessor<IMaterial, PBRMaterial, number>;\n    scale: IObjectAccessor<IMaterial, PBRMaterial, Vector2>;\n}\n\nexport interface IGLTFObjectModelTreeMeshesObject {}\n\nexport interface IGLTFObjectModelTreeExtensionsObject {\n    KHR_lights_punctual: {\n        lights: {\n            length: IObjectAccessor<IKHRLightsPunctual_Light[], Light[], number>;\n            __array__: {\n                __target__: boolean;\n                color: IObjectAccessor<IKHRLightsPunctual_Light, Light, Color3>;\n                intensity: IObjectAccessor<IKHRLightsPunctual_Light, Light, number>;\n                range: IObjectAccessor<IKHRLightsPunctual_Light, Light, number>;\n                spot: {\n                    innerConeAngle: IObjectAccessor<IKHRLightsPunctual_Light, Light, number>;\n                    outerConeAngle: IObjectAccessor<IKHRLightsPunctual_Light, Light, number>;\n                };\n            };\n        };\n    };\n    EXT_lights_ies: {\n        lights: {\n            length: IObjectAccessor<IKHRLightsPunctual_Light[], Light[], number>;\n        };\n    };\n    EXT_lights_image_based: {\n        lights: {\n            __array__: {\n                __target__: boolean;\n                intensity: IObjectAccessor<IEXTLightsImageBased_LightImageBased, BaseTexture, number>;\n                rotation: IObjectAccessor<IEXTLightsImageBased_LightImageBased, BaseTexture, Quaternion>;\n            };\n            length: IObjectAccessor<IEXTLightsImageBased_LightImageBased[], BaseTexture[], number>;\n        };\n    };\n}\n\nconst nodesTree: IGLTFObjectModelTreeNodesObject = {\n    length: {\n        type: \"number\",\n        get: (nodes: INode[]) => nodes.length,\n        getTarget: (nodes: INode[]) => nodes.map((node) => node._babylonTransformNode!),\n        getPropertyName: [() => \"length\"],\n    },\n    __array__: {\n        __target__: true,\n        translation: {\n            type: \"Vector3\",\n            get: (node: INode) => node._babylonTransformNode?.position,\n            set: (value: Vector3, node: INode) => node._babylonTransformNode?.position.copyFrom(value),\n            getTarget: (node: INode) => node._babylonTransformNode,\n            getPropertyName: [() => \"position\"],\n        },\n        rotation: {\n            type: \"Quaternion\",\n            get: (node: INode) => node._babylonTransformNode?.rotationQuaternion!,\n            set: (value: Quaternion, node: INode) => node._babylonTransformNode?.rotationQuaternion?.copyFrom(value),\n            getTarget: (node: INode) => node._babylonTransformNode,\n            getPropertyName: [() => \"rotationQuaternion\"],\n        },\n        scale: {\n            type: \"Vector3\",\n            get: (node: INode) => node._babylonTransformNode?.scaling,\n            set: (value: Vector3, node: INode) => node._babylonTransformNode?.scaling.copyFrom(value),\n            getTarget: (node: INode) => node._babylonTransformNode,\n            getPropertyName: [() => \"scaling\"],\n        },\n        weights: {\n            length: {\n                type: \"number\",\n                get: (node: INode) => node._numMorphTargets,\n                getTarget: (node: INode) => node._babylonTransformNode,\n                getPropertyName: [() => \"influence\"],\n            },\n            __array__: {\n                __target__: true,\n                type: \"number\",\n                get: (node: INode, index?: number) => (index !== undefined ? node._primitiveBabylonMeshes?.[0].morphTargetManager?.getTarget(index).influence : undefined),\n                // set: (value: number, node: INode, index?: number) => node._babylonTransformNode?.getMorphTargetManager()?.getTarget(index)?.setInfluence(value),\n                getTarget: (node: INode) => node._babylonTransformNode,\n                getPropertyName: [() => \"influence\"],\n            },\n            type: \"number[]\",\n            get: (node: INode, index?: number) => [0], // TODO: get the weights correctly\n            // set: (value: number, node: INode, index?: number) => node._babylonTransformNode?.getMorphTargetManager()?.getTarget(index)?.setInfluence(value),\n            getTarget: (node: INode) => node._babylonTransformNode,\n            getPropertyName: [() => \"influence\"],\n        },\n        // readonly!\n        matrix: {\n            type: \"Matrix\",\n            get: (node: INode) => Matrix.Compose(node._babylonTransformNode?.scaling!, node._babylonTransformNode?.rotationQuaternion!, node._babylonTransformNode?.position!),\n            getTarget: (node: INode) => node._babylonTransformNode,\n            isReadOnly: true,\n        },\n        globalMatrix: {\n            type: \"Matrix\",\n            get: (node: INode) => {\n                const matrix = Matrix.Identity();\n                // RHS/LHS support\n                let rootNode = node.parent;\n                while (rootNode && rootNode.parent) {\n                    rootNode = rootNode.parent;\n                }\n                const forceUpdate =\n                    node._babylonTransformNode?.position._isDirty || node._babylonTransformNode?.rotationQuaternion?._isDirty || node._babylonTransformNode?.scaling._isDirty;\n                if (rootNode) {\n                    // take the parent root node's world matrix, invert it, and multiply it with the current node's world matrix\n                    // This will provide the global matrix, ignoring the RHS->LHS conversion\n                    const rootMatrix = rootNode._babylonTransformNode?.computeWorldMatrix(true).invert();\n                    if (rootMatrix) {\n                        node._babylonTransformNode?.computeWorldMatrix(forceUpdate)?.multiplyToRef(rootMatrix, matrix);\n                    }\n                } else if (node._babylonTransformNode) {\n                    matrix.copyFrom(node._babylonTransformNode.computeWorldMatrix(forceUpdate));\n                }\n                return matrix;\n            },\n            getTarget: (node: INode) => node._babylonTransformNode,\n            isReadOnly: true,\n        },\n        extensions: {\n            EXT_lights_ies: {\n                multiplier: {\n                    type: \"number\",\n                    get: (node: INode) => {\n                        return node._babylonTransformNode?.getChildren((child) => child instanceof SpotLight, true)[0]?.intensity;\n                    },\n                    getTarget: (node: INode) => node._babylonTransformNode?.getChildren((child) => child instanceof SpotLight, true)[0],\n                    set: (value, node) => {\n                        if (node._babylonTransformNode) {\n                            const light = node._babylonTransformNode.getChildren((child) => child instanceof SpotLight, true)[0];\n                            if (light) {\n                                light.intensity = value;\n                            }\n                        }\n                    },\n                },\n                color: {\n                    type: \"Color3\",\n                    get: (node: INode) => {\n                        return node._babylonTransformNode?.getChildren((child) => child instanceof SpotLight, true)[0]?.diffuse;\n                    },\n                    getTarget: (node: INode) => node._babylonTransformNode?.getChildren((child) => child instanceof SpotLight, true)[0],\n                    set: (value, node: INode) => {\n                        if (node._babylonTransformNode) {\n                            const light = node._babylonTransformNode.getChildren((child) => child instanceof SpotLight, true)[0];\n                            if (light) {\n                                light.diffuse = value;\n                            }\n                        }\n                    },\n                },\n            },\n        },\n    },\n};\n\nconst animationsTree = {\n    length: {\n        type: \"number\",\n        get: (animations: IAnimation[]) => animations.length,\n        getTarget: (animations: IAnimation[]) => animations.map((animation) => animation._babylonAnimationGroup!),\n        getPropertyName: [() => \"length\"],\n    },\n    __array__: {},\n};\n\nconst meshesTree = {\n    length: {\n        type: \"number\",\n        get: (meshes: IMesh[]) => meshes.length,\n        getTarget: (meshes: IMesh[]) => meshes.map((mesh) => mesh.primitives[0]._instanceData?.babylonSourceMesh),\n        getPropertyName: [() => \"length\"],\n    },\n    __array__: {},\n};\n\nconst camerasTree: IGLTFObjectModelTreeCamerasObject = {\n    __array__: {\n        __target__: true,\n        orthographic: {\n            xmag: {\n                componentsCount: 2,\n                type: \"Vector2\",\n                get: (camera) => new Vector2(camera._babylonCamera?.orthoLeft ?? 0, camera._babylonCamera?.orthoRight ?? 0),\n                set: (value, camera) => {\n                    if (camera._babylonCamera) {\n                        camera._babylonCamera.orthoLeft = value.x;\n                        camera._babylonCamera.orthoRight = value.y;\n                    }\n                },\n                getTarget: (camera) => camera,\n                getPropertyName: [() => \"orthoLeft\", () => \"orthoRight\"],\n            },\n            ymag: {\n                componentsCount: 2,\n                type: \"Vector2\",\n                get: (camera: ICamera) => new Vector2(camera._babylonCamera?.orthoBottom ?? 0, camera._babylonCamera?.orthoTop ?? 0),\n                set: (value: Vector2, camera: ICamera) => {\n                    if (camera._babylonCamera) {\n                        camera._babylonCamera.orthoBottom = value.x;\n                        camera._babylonCamera.orthoTop = value.y;\n                    }\n                },\n                getTarget: (camera) => camera,\n                getPropertyName: [() => \"orthoBottom\", () => \"orthoTop\"],\n            },\n            zfar: {\n                type: \"number\",\n                get: (camera: ICamera) => camera._babylonCamera?.maxZ,\n                set: (value: number, camera: ICamera) => {\n                    if (camera._babylonCamera) {\n                        camera._babylonCamera.maxZ = value;\n                    }\n                },\n                getTarget: (camera: ICamera) => camera,\n                getPropertyName: [() => \"maxZ\"],\n            },\n            znear: {\n                type: \"number\",\n                get: (camera: ICamera) => camera._babylonCamera?.minZ,\n                set: (value: number, camera: ICamera) => {\n                    if (camera._babylonCamera) {\n                        camera._babylonCamera.minZ = value;\n                    }\n                },\n                getTarget: (camera: ICamera) => camera,\n                getPropertyName: [() => \"minZ\"],\n            },\n        },\n        perspective: {\n            aspectRatio: {\n                type: \"number\",\n                get: (camera: ICamera) => camera._babylonCamera?.getEngine().getAspectRatio(camera._babylonCamera),\n                getTarget: (camera: ICamera) => camera,\n                getPropertyName: [() => \"aspectRatio\"],\n                isReadOnly: true, // might not be the case for glTF?\n            },\n            yfov: {\n                type: \"number\",\n                get: (camera: ICamera) => camera._babylonCamera?.fov,\n                set: (value: number, camera: ICamera) => {\n                    if (camera._babylonCamera) {\n                        camera._babylonCamera.fov = value;\n                    }\n                },\n                getTarget: (camera: ICamera) => camera,\n                getPropertyName: [() => \"fov\"],\n            },\n            zfar: {\n                type: \"number\",\n                get: (camera: ICamera) => camera._babylonCamera?.maxZ,\n                set: (value: number, camera: ICamera) => {\n                    if (camera._babylonCamera) {\n                        camera._babylonCamera.maxZ = value;\n                    }\n                },\n                getTarget: (camera: ICamera) => camera,\n                getPropertyName: [() => \"maxZ\"],\n            },\n            znear: {\n                type: \"number\",\n                get: (camera: ICamera) => camera._babylonCamera?.minZ,\n                set: (value: number, camera: ICamera) => {\n                    if (camera._babylonCamera) {\n                        camera._babylonCamera.minZ = value;\n                    }\n                },\n                getTarget: (camera: ICamera) => camera,\n                getPropertyName: [() => \"minZ\"],\n            },\n        },\n    },\n};\n\nconst materialsTree: IGLTFObjectModelTreeMaterialsObject = {\n    __array__: {\n        __target__: true,\n        emissiveFactor: {\n            type: \"Color3\",\n            get: (material, index?, payload?) => GetMaterial(material, index, payload).emissiveColor,\n            set: (value: Color3, material, index?, payload?) => GetMaterial(material, index, payload).emissiveColor.copyFrom(value),\n            getTarget: (material, index?, payload?) => GetMaterial(material, index, payload),\n            getPropertyName: [() => \"emissiveColor\"],\n        },\n        emissiveTexture: {\n            extensions: {\n                KHR_texture_transform: GenerateTextureMap(\"emissiveTexture\"),\n            },\n        },\n        normalTexture: {\n            scale: {\n                type: \"number\",\n                get: (material, index?, payload?) => GetTexture(material, payload, \"bumpTexture\")?.level,\n                set: (value: number, material, index?, payload?) => {\n                    const texture = GetTexture(material, payload, \"bumpTexture\");\n                    if (texture) {\n                        texture.level = value;\n                    }\n                },\n                getTarget: (material, index?, payload?) => GetMaterial(material, index, payload),\n                getPropertyName: [() => \"level\"],\n            },\n            extensions: {\n                KHR_texture_transform: GenerateTextureMap(\"bumpTexture\"),\n            },\n        },\n        occlusionTexture: {\n            strength: {\n                type: \"number\",\n                get: (material, index?, payload?) => GetMaterial(material, index, payload).ambientTextureStrength,\n                set: (value: number, material, index?, payload?) => {\n                    const mat = GetMaterial(material, index, payload);\n                    if (mat) {\n                        mat.ambientTextureStrength = value;\n                    }\n                },\n                getTarget: (material, index?, payload?) => GetMaterial(material, index, payload),\n                getPropertyName: [() => \"ambientTextureStrength\"],\n            },\n            extensions: {\n                KHR_texture_transform: GenerateTextureMap(\"ambientTexture\"),\n            },\n        },\n        pbrMetallicRoughness: {\n            baseColorFactor: {\n                type: \"Color4\",\n                get: (material, index?, payload?) => {\n                    const mat = GetMaterial(material, index, payload);\n                    return Color4.FromColor3(mat.albedoColor, mat.alpha);\n                },\n                set: (value: Color4, material, index?, payload?) => {\n                    const mat = GetMaterial(material, index, payload);\n                    mat.albedoColor.set(value.r, value.g, value.b);\n                    mat.alpha = value.a;\n                },\n                getTarget: (material, index?, payload?) => GetMaterial(material, index, payload),\n                // This is correct on the animation level, but incorrect as a single property of a type Color4\n                getPropertyName: [() => \"albedoColor\", () => \"alpha\"],\n            },\n            baseColorTexture: {\n                extensions: {\n                    KHR_texture_transform: GenerateTextureMap(\"albedoTexture\"),\n                },\n            },\n            metallicFactor: {\n                type: \"number\",\n                get: (material, index?, payload?) => GetMaterial(material, index, payload).metallic,\n                set: (value, material, index?, payload?) => {\n                    const mat = GetMaterial(material, index, payload);\n                    if (mat) {\n                        mat.metallic = value;\n                    }\n                },\n                getTarget: (material, index?, payload?) => GetMaterial(material, index, payload),\n                getPropertyName: [() => \"metallic\"],\n            },\n            roughnessFactor: {\n                type: \"number\",\n                get: (material, index?, payload?) => GetMaterial(material, index, payload).roughness,\n                set: (value, material, index?, payload?) => {\n                    const mat = GetMaterial(material, index, payload);\n                    if (mat) {\n                        mat.roughness = value;\n                    }\n                },\n                getTarget: (material, index?, payload?) => GetMaterial(material, index, payload),\n                getPropertyName: [() => \"roughness\"],\n            },\n            metallicRoughnessTexture: {\n                extensions: {\n                    KHR_texture_transform: GenerateTextureMap(\"metallicTexture\"),\n                },\n            },\n        },\n        extensions: {\n            KHR_materials_anisotropy: {\n                anisotropyStrength: {\n                    type: \"number\",\n                    get: (material, index?, payload?) => GetMaterial(material, index, payload).anisotropy.intensity,\n                    set: (value: number, material, index?, payload?) => {\n                        GetMaterial(material, index, payload).anisotropy.intensity = value;\n                    },\n                    getTarget: (material, index?, payload?) => GetMaterial(material, index, payload),\n                    getPropertyName: [() => \"anisotropy.intensity\"],\n                },\n                anisotropyRotation: {\n                    type: \"number\",\n                    get: (material, index?, payload?) => GetMaterial(material, index, payload).anisotropy.angle,\n                    set: (value: number, material, index?, payload?) => {\n                        GetMaterial(material, index, payload).anisotropy.angle = value;\n                    },\n                    getTarget: (material, index?, payload?) => GetMaterial(material, index, payload),\n                    getPropertyName: [() => \"anisotropy.angle\"],\n                },\n                anisotropyTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"anisotropy\", \"texture\"),\n                    },\n                },\n            },\n            KHR_materials_clearcoat: {\n                clearcoatFactor: {\n                    type: \"number\",\n                    get: (material, index?, payload?) => GetMaterial(material, index, payload).clearCoat.intensity,\n                    set: (value, material, index?, payload?) => {\n                        GetMaterial(material, index, payload).clearCoat.intensity = value;\n                    },\n                    getTarget: (material, index?, payload?) => GetMaterial(material, index, payload),\n                    getPropertyName: [() => \"clearCoat.intensity\"],\n                },\n                clearcoatRoughnessFactor: {\n                    type: \"number\",\n                    get: (material, index?, payload?) => GetMaterial(material, index, payload).clearCoat.roughness,\n                    set: (value, material, index?, payload?) => {\n                        GetMaterial(material, index, payload).clearCoat.roughness = value;\n                    },\n                    getTarget: (material, index?, payload?) => GetMaterial(material, index, payload),\n                    getPropertyName: [() => \"clearCoat.roughness\"],\n                },\n                clearcoatTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"clearCoat\", \"texture\"),\n                    },\n                },\n                clearcoatNormalTexture: {\n                    scale: {\n                        type: \"number\",\n                        get: (material, index, payload) => GetMaterial(material, index, payload).clearCoat.bumpTexture?.level,\n                        getTarget: GetMaterial,\n                        set: (value, material, index, payload) => (GetMaterial(material, index, payload).clearCoat.bumpTexture!.level = value),\n                    },\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"clearCoat\", \"bumpTexture\"),\n                    },\n                },\n                clearcoatRoughnessTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"clearCoat\", \"textureRoughness\"),\n                    },\n                },\n            },\n            KHR_materials_dispersion: {\n                dispersion: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).subSurface.dispersion,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).subSurface.dispersion = value),\n                },\n            },\n            KHR_materials_emissive_strength: {\n                emissiveStrength: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).emissiveIntensity,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).emissiveIntensity = value),\n                },\n            },\n            KHR_materials_ior: {\n                ior: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).indexOfRefraction,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).indexOfRefraction = value),\n                },\n            },\n            KHR_materials_iridescence: {\n                iridescenceFactor: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).iridescence.intensity,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).iridescence.intensity = value),\n                },\n                iridescenceIor: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).iridescence.indexOfRefraction,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).iridescence.indexOfRefraction = value),\n                },\n                iridescenceTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"iridescence\", \"texture\"),\n                    },\n                },\n                iridescenceThicknessMaximum: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).iridescence.maximumThickness,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).iridescence.maximumThickness = value),\n                },\n                iridescenceThicknessMinimum: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).iridescence.minimumThickness,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).iridescence.minimumThickness = value),\n                },\n                iridescenceThicknessTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"iridescence\", \"thicknessTexture\"),\n                    },\n                },\n            },\n            KHR_materials_sheen: {\n                sheenColorFactor: {\n                    type: \"Color3\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).sheen.color,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => GetMaterial(material, index, payload).sheen.color.copyFrom(value),\n                },\n                sheenColorTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"sheen\", \"texture\"),\n                    },\n                },\n                sheenRoughnessFactor: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).sheen.intensity,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).sheen.intensity = value),\n                },\n                sheenRoughnessTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"sheen\", \"thicknessTexture\"),\n                    },\n                },\n            },\n            KHR_materials_specular: {\n                specularFactor: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).metallicF0Factor,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).metallicF0Factor = value),\n                    getPropertyName: [() => \"metallicF0Factor\"],\n                },\n                specularColorFactor: {\n                    type: \"Color3\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).metallicReflectanceColor,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => GetMaterial(material, index, payload).metallicReflectanceColor.copyFrom(value),\n                    getPropertyName: [() => \"metallicReflectanceColor\"],\n                },\n                specularTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"metallicReflectanceTexture\"),\n                    },\n                },\n                specularColorTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"reflectanceTexture\"),\n                    },\n                },\n            },\n            KHR_materials_transmission: {\n                transmissionFactor: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).subSurface.refractionIntensity,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).subSurface.refractionIntensity = value),\n                    getPropertyName: [() => \"subSurface.refractionIntensity\"],\n                },\n                transmissionTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"subSurface\", \"refractionIntensityTexture\"),\n                    },\n                },\n            },\n            KHR_materials_diffuse_transmission: {\n                diffuseTransmissionFactor: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).subSurface.translucencyIntensity,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).subSurface.translucencyIntensity = value),\n                },\n                diffuseTransmissionTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"subSurface\", \"translucencyIntensityTexture\"),\n                    },\n                },\n                diffuseTransmissionColorFactor: {\n                    type: \"Color3\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).subSurface.translucencyColor,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => value && GetMaterial(material, index, payload).subSurface.translucencyColor?.copyFrom(value),\n                },\n                diffuseTransmissionColorTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"subSurface\", \"translucencyColorTexture\"),\n                    },\n                },\n            },\n            KHR_materials_volume: {\n                attenuationColor: {\n                    type: \"Color3\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).subSurface.tintColor,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => GetMaterial(material, index, payload).subSurface.tintColor.copyFrom(value),\n                },\n                attenuationDistance: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).subSurface.tintColorAtDistance,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).subSurface.tintColorAtDistance = value),\n                },\n                thicknessFactor: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).subSurface.maximumThickness,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).subSurface.maximumThickness = value),\n                },\n                thicknessTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"subSurface\", \"thicknessTexture\"),\n                    },\n                },\n            },\n        },\n    },\n};\n\nconst extensionsTree: IGLTFObjectModelTreeExtensionsObject = {\n    KHR_lights_punctual: {\n        lights: {\n            length: {\n                type: \"number\",\n                get: (lights: IKHRLightsPunctual_Light[]) => lights.length,\n                getTarget: (lights: IKHRLightsPunctual_Light[]) => lights.map((light) => light._babylonLight!),\n                getPropertyName: [(_lights: IKHRLightsPunctual_Light[]) => \"length\"],\n            },\n            __array__: {\n                __target__: true,\n                color: {\n                    type: \"Color3\",\n                    get: (light: IKHRLightsPunctual_Light) => light._babylonLight?.diffuse,\n                    set: (value: Color3, light: IKHRLightsPunctual_Light) => light._babylonLight?.diffuse.copyFrom(value),\n                    getTarget: (light: IKHRLightsPunctual_Light) => light._babylonLight,\n                    getPropertyName: [(_light: IKHRLightsPunctual_Light) => \"diffuse\"],\n                },\n                intensity: {\n                    type: \"number\",\n                    get: (light: IKHRLightsPunctual_Light) => light._babylonLight?.intensity,\n                    set: (value: number, light: IKHRLightsPunctual_Light) => (light._babylonLight ? (light._babylonLight.intensity = value) : undefined),\n                    getTarget: (light: IKHRLightsPunctual_Light) => light._babylonLight,\n                    getPropertyName: [(_light: IKHRLightsPunctual_Light) => \"intensity\"],\n                },\n                range: {\n                    type: \"number\",\n                    get: (light: IKHRLightsPunctual_Light) => light._babylonLight?.range,\n                    set: (value: number, light: IKHRLightsPunctual_Light) => (light._babylonLight ? (light._babylonLight.range = value) : undefined),\n                    getTarget: (light: IKHRLightsPunctual_Light) => light._babylonLight,\n                    getPropertyName: [(_light: IKHRLightsPunctual_Light) => \"range\"],\n                },\n                spot: {\n                    innerConeAngle: {\n                        type: \"number\",\n                        get: (light: IKHRLightsPunctual_Light) => (light._babylonLight as SpotLight)?.innerAngle,\n                        set: (value: number, light: IKHRLightsPunctual_Light) => (light._babylonLight ? ((light._babylonLight as SpotLight).innerAngle = value) : undefined),\n                        getTarget: (light: IKHRLightsPunctual_Light) => light._babylonLight,\n                        getPropertyName: [(_light: IKHRLightsPunctual_Light) => \"innerConeAngle\"],\n                    },\n                    outerConeAngle: {\n                        type: \"number\",\n                        get: (light: IKHRLightsPunctual_Light) => (light._babylonLight as SpotLight)?.angle,\n                        set: (value: number, light: IKHRLightsPunctual_Light) => (light._babylonLight ? ((light._babylonLight as SpotLight).angle = value) : undefined),\n                        getTarget: (light: IKHRLightsPunctual_Light) => light._babylonLight,\n                        getPropertyName: [(_light: IKHRLightsPunctual_Light) => \"outerConeAngle\"],\n                    },\n                },\n            },\n        },\n    },\n    EXT_lights_ies: {\n        lights: {\n            length: {\n                type: \"number\",\n                get: (lights: IKHRLightsPunctual_Light[]) => lights.length,\n                getTarget: (lights: IKHRLightsPunctual_Light[]) => lights.map((light) => light._babylonLight!),\n                getPropertyName: [(_lights: IKHRLightsPunctual_Light[]) => \"length\"],\n            },\n        },\n    },\n    EXT_lights_image_based: {\n        lights: {\n            length: {\n                type: \"number\",\n                get: (lights) => lights.length,\n                getTarget: (lights) => lights.map((light) => light._babylonTexture!),\n                getPropertyName: [(_lights) => \"length\"],\n            },\n            __array__: {\n                __target__: true,\n                intensity: {\n                    type: \"number\",\n                    get: (light) => light._babylonTexture?.level,\n                    set: (value, light) => {\n                        if (light._babylonTexture) {\n                            light._babylonTexture.level = value;\n                        }\n                    },\n\n                    getTarget: (light) => light._babylonTexture,\n                },\n                rotation: {\n                    type: \"Quaternion\",\n                    get: (light) => light._babylonTexture && Quaternion.FromRotationMatrix(light._babylonTexture?.getReflectionTextureMatrix()),\n                    set: (value, light) => {\n                        if (!light._babylonTexture) {\n                            return;\n                        }\n                        // Invert the rotation so that positive rotation is counter-clockwise.\n                        if (!light._babylonTexture.getScene()?.useRightHandedSystem) {\n                            value = Quaternion.Inverse(value);\n                        }\n\n                        Matrix.FromQuaternionToRef(value, light._babylonTexture.getReflectionTextureMatrix());\n                    },\n                    getTarget: (light) => light._babylonTexture,\n                },\n            },\n        },\n    },\n};\n\nfunction GetTexture(material: IMaterial, payload: any, textureType: keyof PBRMaterial, textureInObject?: string) {\n    const babylonMaterial = GetMaterial(material, payload);\n    return textureInObject ? babylonMaterial[textureType][textureInObject] : babylonMaterial[textureType];\n}\nfunction GetMaterial(material: IMaterial, _index?: number, payload?: any) {\n    return material._data?.[payload?.fillMode ?? Constants.MATERIAL_TriangleFillMode]?.babylonMaterial as PBRMaterial;\n}\nfunction GenerateTextureMap(textureType: keyof PBRMaterial, textureInObject?: string): ITextureDefinition {\n    return {\n        offset: {\n            componentsCount: 2,\n            // assuming two independent values for u and v, and NOT a Vector2\n            type: \"Vector2\",\n            get: (material, _index?, payload?) => {\n                const texture = GetTexture(material, payload, textureType, textureInObject);\n                return new Vector2(texture?.uOffset, texture?.vOffset);\n            },\n            getTarget: GetMaterial,\n            set: (value, material, _index?, payload?) => {\n                const texture = GetTexture(material, payload, textureType, textureInObject);\n                (texture.uOffset = value.x), (texture.vOffset = value.y);\n            },\n            getPropertyName: [\n                () => `${textureType}${textureInObject ? \".\" + textureInObject : \"\"}.uOffset`,\n                () => `${textureType}${textureInObject ? \".\" + textureInObject : \"\"}.vOffset`,\n            ],\n        },\n        rotation: {\n            type: \"number\",\n            get: (material, _index?, payload?) => GetTexture(material, payload, textureType, textureInObject)?.wAng,\n            getTarget: GetMaterial,\n            set: (value, material, _index?, payload?) => (GetTexture(material, payload, textureType, textureInObject).wAng = value),\n            getPropertyName: [() => `${textureType}${textureInObject ? \".\" + textureInObject : \"\"}.wAng`],\n        },\n        scale: {\n            componentsCount: 2,\n            type: \"Vector2\",\n            get: (material, _index?, payload?) => {\n                const texture = GetTexture(material, payload, textureType, textureInObject);\n                return new Vector2(texture?.uScale, texture?.vScale);\n            },\n            getTarget: GetMaterial,\n            set: (value, material, index?, payload?) => {\n                const texture = GetTexture(material, payload, textureType, textureInObject);\n                (texture.uScale = value.x), (texture.vScale = value.y);\n            },\n            getPropertyName: [\n                () => `${textureType}${textureInObject ? \".\" + textureInObject : \"\"}.uScale`,\n                () => `${textureType}${textureInObject ? \".\" + textureInObject : \"\"}.vScale`,\n            ],\n        },\n    };\n}\n\nconst objectModelMapping: IGLTFObjectModelTree = {\n    cameras: camerasTree,\n    nodes: nodesTree,\n    materials: materialsTree,\n    extensions: extensionsTree,\n    animations: animationsTree,\n    meshes: meshesTree,\n};\n\n/**\n * get a path-to-object converter for the given glTF tree\n * @param gltf the glTF tree to use\n * @returns a path-to-object converter for the given glTF tree\n */\nexport function GetPathToObjectConverter(gltf: IGLTF) {\n    return new GLTFPathToObjectConverter(gltf, objectModelMapping);\n}\n\n/**\n * This function will return the object accessor for the given key in the object model\n * If the key is not found, it will return undefined\n * @param key the key to get the mapping for, for example /materials/\\{\\}/emissiveFactor\n * @returns an object accessor for the given key, or undefined if the key is not found\n */\nexport function GetMappingForKey(key: string): IObjectAccessor | undefined {\n    // replace every `{}` in key with __array__ to match the object model\n    const keyParts = key.split(\"/\").map((part) => part.replace(/{}/g, \"__array__\"));\n    let current = objectModelMapping as any;\n    for (const part of keyParts) {\n        // make sure part is not empty\n        if (!part) {\n            continue;\n        }\n        current = current[part];\n    }\n    // validate that current is an object accessor\n    if (current && current.type && current.get) {\n        return current;\n    }\n    return undefined;\n}\n\n/**\n * Set interpolation for a specific key in the object model\n * @param key the key to set, for example /materials/\\{\\}/emissiveFactor\n * @param interpolation the interpolation elements array\n */\nexport function SetInterpolationForKey(key: string, interpolation?: IInterpolationPropertyInfo[]): void {\n    // replace every `{}` in key with __array__ to match the object model\n    const keyParts = key.split(\"/\").map((part) => part.replace(/{}/g, \"__array__\"));\n    let current = objectModelMapping as any;\n    for (const part of keyParts) {\n        // make sure part is not empty\n        if (!part) {\n            continue;\n        }\n        current = current[part];\n    }\n    // validate that the current object is an object accessor\n    if (current && current.type && current.get) {\n        (current as IObjectAccessor).interpolation = interpolation;\n    }\n}\n\n/**\n * This will ad a new object accessor in the object model at the given key.\n * Note that this will NOT change the typescript types. To do that you will need to change the interface itself (extending it in the module that uses it)\n * @param key the key to add the object accessor at. For example /cameras/\\{\\}/perspective/aspectRatio\n * @param accessor the object accessor to add\n */\nexport function AddObjectAccessorToKey<GLTFTargetType = any, BabylonTargetType = any, BabylonValueType = any>(\n    key: string,\n    accessor: IObjectAccessor<GLTFTargetType, BabylonTargetType, BabylonValueType>\n): void {\n    // replace every `{}` in key with __array__ to match the object model\n    const keyParts = key.split(\"/\").map((part) => part.replace(/{}/g, \"__array__\"));\n    let current = objectModelMapping as any;\n    for (const part of keyParts) {\n        // make sure part is not empty\n        if (!part) {\n            continue;\n        }\n        if (!current[part]) {\n            if (part === \"?\") {\n                current.__ignoreObjectTree__ = true;\n                continue;\n            }\n            current[part] = {};\n            // if the part is __array__ then add the __target__ property\n            if (part === \"__array__\") {\n                current[part].__target__ = true;\n            }\n        }\n        current = current[part];\n    }\n    Object.assign(current, accessor);\n}\n","import { Animation } from \"core/Animations/animation\";\r\nimport { Quaternion, Vector3 } from \"core/Maths/math.vector\";\r\nimport type { INode } from \"./glTFLoaderInterfaces\";\r\nimport type { IAnimatable } from \"core/Animations/animatable.interface\";\r\nimport { SetInterpolationForKey } from \"./Extensions/objectModelMapping\";\r\n\r\n/** @internal */\r\nexport type GetValueFn = (target: any, source: Float32Array, offset: number, scale: number) => any;\r\n\r\n/** @internal */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport function getVector3(_target: any, source: Float32Array, offset: number, scale: number): Vector3 {\r\n    return Vector3.FromArray(source, offset).scaleInPlace(scale);\r\n}\r\n\r\n/** @internal */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport function getQuaternion(_target: any, source: Float32Array, offset: number, scale: number): Quaternion {\r\n    return Quaternion.FromArray(source, offset).scaleInPlace(scale);\r\n}\r\n\r\n/** @internal */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport function getWeights(target: INode, source: Float32Array, offset: number, scale: number): Array<number> {\r\n    const value = new Array<number>(target._numMorphTargets!);\r\n    for (let i = 0; i < value.length; i++) {\r\n        value[i] = source[offset++] * scale;\r\n    }\r\n\r\n    return value;\r\n}\r\n\r\n/** @internal */\r\nexport abstract class AnimationPropertyInfo {\r\n    /** @internal */\r\n    public constructor(\r\n        public readonly type: number,\r\n        public readonly name: string,\r\n        public readonly getValue: GetValueFn,\r\n        public readonly getStride: (target: any) => number\r\n    ) {}\r\n\r\n    protected _buildAnimation(name: string, fps: number, keys: any[]): Animation {\r\n        const babylonAnimation = new Animation(name, this.name, fps, this.type);\r\n        babylonAnimation.setKeys(keys);\r\n        return babylonAnimation;\r\n    }\r\n\r\n    /** @internal */\r\n    public abstract buildAnimations(target: any, name: string, fps: number, keys: any[]): { babylonAnimatable: IAnimatable; babylonAnimation: Animation }[];\r\n}\r\n\r\n/** @internal */\r\nexport class TransformNodeAnimationPropertyInfo extends AnimationPropertyInfo {\r\n    /** @internal */\r\n    public buildAnimations(target: INode, name: string, fps: number, keys: any[]) {\r\n        const babylonAnimations: { babylonAnimatable: IAnimatable; babylonAnimation: Animation }[] = [];\r\n        babylonAnimations.push({ babylonAnimatable: target._babylonTransformNode!, babylonAnimation: this._buildAnimation(name, fps, keys) });\r\n        return babylonAnimations;\r\n    }\r\n}\r\n\r\n/** @internal */\r\nexport class WeightAnimationPropertyInfo extends AnimationPropertyInfo {\r\n    public buildAnimations(target: INode, name: string, fps: number, keys: any[]) {\r\n        const babylonAnimations: { babylonAnimatable: IAnimatable; babylonAnimation: Animation }[] = [];\r\n        if (target._numMorphTargets) {\r\n            for (let targetIndex = 0; targetIndex < target._numMorphTargets; targetIndex++) {\r\n                const babylonAnimation = new Animation(`${name}_${targetIndex}`, this.name, fps, this.type);\r\n                babylonAnimation.setKeys(\r\n                    keys.map((key) => ({\r\n                        frame: key.frame,\r\n                        inTangent: key.inTangent ? key.inTangent[targetIndex] : undefined,\r\n                        value: key.value[targetIndex],\r\n                        outTangent: key.outTangent ? key.outTangent[targetIndex] : undefined,\r\n                        interpolation: key.interpolation,\r\n                    }))\r\n                );\r\n\r\n                if (target._primitiveBabylonMeshes) {\r\n                    for (const babylonMesh of target._primitiveBabylonMeshes) {\r\n                        if (babylonMesh.morphTargetManager) {\r\n                            const morphTarget = babylonMesh.morphTargetManager.getTarget(targetIndex);\r\n                            const babylonAnimationClone = babylonAnimation.clone();\r\n                            morphTarget.animations.push(babylonAnimationClone);\r\n                            babylonAnimations.push({ babylonAnimatable: morphTarget, babylonAnimation: babylonAnimationClone });\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        return babylonAnimations;\r\n    }\r\n}\r\n\r\nSetInterpolationForKey(\"/nodes/{}/translation\", [new TransformNodeAnimationPropertyInfo(Animation.ANIMATIONTYPE_VECTOR3, \"position\", getVector3, () => 3)]);\r\nSetInterpolationForKey(\"/nodes/{}/rotation\", [new TransformNodeAnimationPropertyInfo(Animation.ANIMATIONTYPE_QUATERNION, \"rotationQuaternion\", getQuaternion, () => 4)]);\r\nSetInterpolationForKey(\"/nodes/{}/scale\", [new TransformNodeAnimationPropertyInfo(Animation.ANIMATIONTYPE_VECTOR3, \"scaling\", getVector3, () => 3)]);\r\nSetInterpolationForKey(\"/nodes/{}/weights\", [new WeightAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"influence\", getWeights, (target) => target._numMorphTargets!)]);\r\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","/* eslint-disable github/no-then */\r\n/* eslint-disable no-restricted-syntax */\r\n/* eslint-disable @typescript-eslint/promise-function-async */\r\nimport type * as GLTF2 from \"babylonjs-gltf2interface\";\r\nimport { Tools } from \"core/Misc/tools\";\r\n\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\ndeclare let GLTFValidator: GLTF2.IGLTFValidator;\r\n\r\n// WorkerGlobalScope\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\ndeclare function importScripts(...urls: string[]): void;\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\ndeclare function postMessage(message: any, transfer?: any[]): void;\r\n\r\nfunction ValidateAsync(\r\n    data: string | Uint8Array,\r\n    rootUrl: string,\r\n    fileName: string,\r\n    getExternalResource: (uri: string) => Promise<Uint8Array>\r\n): Promise<GLTF2.IGLTFValidationResults> {\r\n    const options: GLTF2.IGLTFValidationOptions = {\r\n        externalResourceFunction: getExternalResource,\r\n    };\r\n\r\n    if (fileName) {\r\n        options.uri = rootUrl === \"file:\" ? fileName : rootUrl + fileName;\r\n    }\r\n\r\n    return ArrayBuffer.isView(data) ? GLTFValidator.validateBytes(data, options) : GLTFValidator.validateString(data, options);\r\n}\r\n\r\n/**\r\n * The worker function that gets converted to a blob url to pass into a worker.\r\n */\r\nfunction WorkerFunc(): void {\r\n    const pendingExternalResources: Array<{ resolve: (data: any) => void; reject: (reason: any) => void }> = [];\r\n\r\n    onmessage = (message) => {\r\n        const data = message.data;\r\n        switch (data.id) {\r\n            case \"init\": {\r\n                importScripts(data.url);\r\n                break;\r\n            }\r\n            case \"validate\": {\r\n                ValidateAsync(\r\n                    data.data,\r\n                    data.rootUrl,\r\n                    data.fileName,\r\n                    (uri) =>\r\n                        new Promise((resolve, reject) => {\r\n                            const index = pendingExternalResources.length;\r\n                            pendingExternalResources.push({ resolve, reject });\r\n                            postMessage({ id: \"getExternalResource\", index: index, uri: uri });\r\n                        })\r\n                ).then(\r\n                    (value) => {\r\n                        postMessage({ id: \"validate.resolve\", value: value });\r\n                    },\r\n                    (reason) => {\r\n                        postMessage({ id: \"validate.reject\", reason: reason });\r\n                    }\r\n                );\r\n                break;\r\n            }\r\n            case \"getExternalResource.resolve\": {\r\n                pendingExternalResources[data.index].resolve(data.value);\r\n                break;\r\n            }\r\n            case \"getExternalResource.reject\": {\r\n                pendingExternalResources[data.index].reject(data.reason);\r\n                break;\r\n            }\r\n        }\r\n    };\r\n}\r\n\r\n/**\r\n * Configuration for glTF validation\r\n */\r\nexport interface IGLTFValidationConfiguration {\r\n    /**\r\n     * The url of the glTF validator.\r\n     */\r\n    url: string;\r\n}\r\n\r\n/**\r\n * glTF validation\r\n */\r\nexport class GLTFValidation {\r\n    /**\r\n     * The configuration. Defaults to `{ url: \"https://cdn.babylonjs.com/gltf_validator.js\" }`.\r\n     */\r\n    public static Configuration: IGLTFValidationConfiguration = {\r\n        url: `${Tools._DefaultCdnUrl}/gltf_validator.js`,\r\n    };\r\n\r\n    private static _LoadScriptPromise: Promise<void>;\r\n\r\n    /**\r\n     * Validate a glTF asset using the glTF-Validator.\r\n     * @param data The JSON of a glTF or the array buffer of a binary glTF\r\n     * @param rootUrl The root url for the glTF\r\n     * @param fileName The file name for the glTF\r\n     * @param getExternalResource The callback to get external resources for the glTF validator\r\n     * @returns A promise that resolves with the glTF validation results once complete\r\n     */\r\n    public static ValidateAsync(\r\n        data: string | Uint8Array,\r\n        rootUrl: string,\r\n        fileName: string,\r\n        getExternalResource: (uri: string) => Promise<Uint8Array>\r\n    ): Promise<GLTF2.IGLTFValidationResults> {\r\n        if (typeof Worker === \"function\") {\r\n            return new Promise((resolve, reject) => {\r\n                const workerContent = `${ValidateAsync}(${WorkerFunc})()`;\r\n                const workerBlobUrl = URL.createObjectURL(new Blob([workerContent], { type: \"application/javascript\" }));\r\n                const worker = new Worker(workerBlobUrl);\r\n\r\n                const onError = (error: ErrorEvent) => {\r\n                    worker.removeEventListener(\"error\", onError);\r\n                    worker.removeEventListener(\"message\", onMessage);\r\n                    // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors\r\n                    reject(error);\r\n                };\r\n\r\n                const onMessage = (message: MessageEvent) => {\r\n                    const data = message.data;\r\n                    switch (data.id) {\r\n                        case \"getExternalResource\": {\r\n                            getExternalResource(data.uri).then(\r\n                                (value) => {\r\n                                    worker.postMessage({ id: \"getExternalResource.resolve\", index: data.index, value: value }, [value.buffer]);\r\n                                },\r\n                                (reason) => {\r\n                                    worker.postMessage({ id: \"getExternalResource.reject\", index: data.index, reason: reason });\r\n                                }\r\n                            );\r\n                            break;\r\n                        }\r\n                        case \"validate.resolve\": {\r\n                            worker.removeEventListener(\"error\", onError);\r\n                            worker.removeEventListener(\"message\", onMessage);\r\n                            resolve(data.value);\r\n                            worker.terminate();\r\n                            break;\r\n                        }\r\n                        case \"validate.reject\": {\r\n                            worker.removeEventListener(\"error\", onError);\r\n                            worker.removeEventListener(\"message\", onMessage);\r\n                            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors\r\n                            reject(data.reason);\r\n                            worker.terminate();\r\n                        }\r\n                    }\r\n                };\r\n\r\n                worker.addEventListener(\"error\", onError);\r\n                worker.addEventListener(\"message\", onMessage);\r\n\r\n                worker.postMessage({ id: \"init\", url: Tools.GetBabylonScriptURL(this.Configuration.url) });\r\n\r\n                if (ArrayBuffer.isView(data)) {\r\n                    // Slice the data to avoid copying the whole array buffer.\r\n                    const slicedData = data.slice();\r\n                    worker.postMessage({ id: \"validate\", data: slicedData, rootUrl: rootUrl, fileName: fileName }, [slicedData.buffer]);\r\n                } else {\r\n                    worker.postMessage({ id: \"validate\", data: data, rootUrl: rootUrl, fileName: fileName });\r\n                }\r\n            });\r\n        } else {\r\n            if (!this._LoadScriptPromise) {\r\n                this._LoadScriptPromise = Tools.LoadBabylonScriptAsync(this.Configuration.url);\r\n            }\r\n\r\n            return this._LoadScriptPromise.then(() => {\r\n                return ValidateAsync(data, rootUrl, fileName, getExternalResource);\r\n            });\r\n        }\r\n    }\r\n}\r\n","/* eslint-disable github/no-then */\r\n/* eslint-disable @typescript-eslint/no-floating-promises */\r\n/* eslint-disable @typescript-eslint/prefer-promise-reject-errors */\r\n/* eslint-disable no-restricted-syntax */\r\n/* eslint-disable @typescript-eslint/promise-function-async */\r\n/* eslint-disable @typescript-eslint/no-unused-vars */\r\n/* eslint-disable @typescript-eslint/naming-convention */\r\nimport type * as GLTF2 from \"babylonjs-gltf2interface\";\r\nimport type { Nullable } from \"core/types\";\r\nimport type { Observer } from \"core/Misc/observable\";\r\nimport { Observable } from \"core/Misc/observable\";\r\nimport { Tools } from \"core/Misc/tools\";\r\nimport type { Camera } from \"core/Cameras/camera\";\r\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\r\nimport type { Material } from \"core/Materials/material\";\r\nimport type { AbstractMesh } from \"core/Meshes/abstractMesh\";\r\nimport type { ISceneLoaderPluginFactory, ISceneLoaderPluginAsync, ISceneLoaderProgressEvent, ISceneLoaderAsyncResult, SceneLoaderPluginOptions } from \"core/Loading/sceneLoader\";\r\nimport { RegisterSceneLoaderPlugin } from \"core/Loading/sceneLoader\";\r\nimport { AssetContainer } from \"core/assetContainer\";\r\nimport type { Scene, IDisposable } from \"core/scene\";\r\nimport type { WebRequest } from \"core/Misc/webRequest\";\r\nimport type { IFileRequest } from \"core/Misc/fileRequest\";\r\nimport { Logger } from \"core/Misc/logger\";\r\nimport type { IDataBuffer } from \"core/Misc/dataReader\";\r\nimport { DataReader } from \"core/Misc/dataReader\";\r\nimport { GLTFValidation } from \"./glTFValidation\";\r\nimport { GLTFFileLoaderMetadata, GLTFMagicBase64Encoded } from \"./glTFFileLoader.metadata\";\r\nimport type { LoadFileError } from \"core/Misc/fileTools\";\r\nimport { DecodeBase64UrlToBinary } from \"core/Misc/fileTools\";\r\nimport { RuntimeError, ErrorCodes } from \"core/Misc/error\";\r\nimport type { TransformNode } from \"core/Meshes/transformNode\";\r\nimport type { MorphTargetManager } from \"core/Morph/morphTargetManager\";\r\n\r\n/**\r\n * Defines options for glTF loader extensions. This interface is extended by specific extensions.\r\n */\r\nexport interface GLTFLoaderExtensionOptions extends Record<string, Record<string, unknown> | undefined> {}\r\n\r\ndeclare module \"core/Loading/sceneLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc\r\n    export interface SceneLoaderPluginOptions {\r\n        /**\r\n         * Defines options for the glTF loader.\r\n         */\r\n        [GLTFFileLoaderMetadata.name]: Partial<GLTFLoaderOptions>;\r\n    }\r\n}\r\n\r\ninterface IFileRequestInfo extends IFileRequest {\r\n    _lengthComputable?: boolean;\r\n    _loaded?: number;\r\n    _total?: number;\r\n}\r\n\r\nfunction readAsync(arrayBuffer: ArrayBuffer, byteOffset: number, byteLength: number): Promise<Uint8Array> {\r\n    try {\r\n        return Promise.resolve(new Uint8Array(arrayBuffer, byteOffset, byteLength));\r\n    } catch (e) {\r\n        return Promise.reject(e);\r\n    }\r\n}\r\n\r\nfunction readViewAsync(arrayBufferView: ArrayBufferView, byteOffset: number, byteLength: number): Promise<Uint8Array> {\r\n    try {\r\n        if (byteOffset < 0 || byteOffset >= arrayBufferView.byteLength) {\r\n            throw new RangeError(\"Offset is out of range.\");\r\n        }\r\n\r\n        if (byteOffset + byteLength > arrayBufferView.byteLength) {\r\n            throw new RangeError(\"Length is out of range.\");\r\n        }\r\n\r\n        return Promise.resolve(new Uint8Array(arrayBufferView.buffer, arrayBufferView.byteOffset + byteOffset, byteLength));\r\n    } catch (e) {\r\n        return Promise.reject(e);\r\n    }\r\n}\r\n\r\n/**\r\n * Mode that determines the coordinate system to use.\r\n */\r\nexport enum GLTFLoaderCoordinateSystemMode {\r\n    /**\r\n     * Automatically convert the glTF right-handed data to the appropriate system based on the current coordinate system mode of the scene.\r\n     */\r\n    AUTO,\r\n\r\n    /**\r\n     * Sets the useRightHandedSystem flag on the scene.\r\n     */\r\n    FORCE_RIGHT_HANDED,\r\n}\r\n\r\n/**\r\n * Mode that determines what animations will start.\r\n */\r\nexport enum GLTFLoaderAnimationStartMode {\r\n    /**\r\n     * No animation will start.\r\n     */\r\n    NONE,\r\n\r\n    /**\r\n     * The first animation will start.\r\n     */\r\n    FIRST,\r\n\r\n    /**\r\n     * All animations will start.\r\n     */\r\n    ALL,\r\n}\r\n\r\n/**\r\n * Interface that contains the data for the glTF asset.\r\n */\r\nexport interface IGLTFLoaderData {\r\n    /**\r\n     * The object that represents the glTF JSON.\r\n     */\r\n    json: object;\r\n\r\n    /**\r\n     * The BIN chunk of a binary glTF.\r\n     */\r\n    bin: Nullable<IDataBuffer>;\r\n}\r\n\r\n/**\r\n * Interface for extending the loader.\r\n */\r\nexport interface IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    readonly name: string;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    enabled: boolean;\r\n\r\n    /**\r\n     * Defines the order of this extension.\r\n     * The loader sorts the extensions using these values when loading.\r\n     */\r\n    order?: number;\r\n}\r\n\r\n/**\r\n * Loader state.\r\n */\r\nexport enum GLTFLoaderState {\r\n    /**\r\n     * The asset is loading.\r\n     */\r\n    LOADING,\r\n\r\n    /**\r\n     * The asset is ready for rendering.\r\n     */\r\n    READY,\r\n\r\n    /**\r\n     * The asset is completely loaded.\r\n     */\r\n    COMPLETE,\r\n}\r\n\r\n/** @internal */\r\nexport interface IGLTFLoader extends IDisposable {\r\n    importMeshAsync: (\r\n        meshesNames: string | readonly string[] | null | undefined,\r\n        scene: Scene,\r\n        container: Nullable<AssetContainer>,\r\n        data: IGLTFLoaderData,\r\n        rootUrl: string,\r\n        onProgress?: (event: ISceneLoaderProgressEvent) => void,\r\n        fileName?: string\r\n    ) => Promise<ISceneLoaderAsyncResult>;\r\n    loadAsync: (scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string) => Promise<void>;\r\n}\r\n\r\n/**\r\n * Adds default/implicit options to extension specific options.\r\n */\r\ntype DefaultExtensionOptions<BaseExtensionOptions> = {\r\n    /**\r\n     * Defines if the extension is enabled\r\n     */\r\n    enabled?: boolean;\r\n} & BaseExtensionOptions;\r\n\r\nabstract class GLTFLoaderOptions {\r\n    // eslint-disable-next-line babylonjs/available\r\n    protected copyFrom(options?: Partial<Readonly<GLTFLoaderOptions>>) {\r\n        if (options) {\r\n            this.alwaysComputeBoundingBox = options.alwaysComputeBoundingBox ?? this.alwaysComputeBoundingBox;\r\n            this.alwaysComputeSkeletonRootNode = options.alwaysComputeSkeletonRootNode ?? this.alwaysComputeSkeletonRootNode;\r\n            this.animationStartMode = options.animationStartMode ?? this.animationStartMode;\r\n            this.capturePerformanceCounters = options.capturePerformanceCounters ?? this.capturePerformanceCounters;\r\n            this.compileMaterials = options.compileMaterials ?? this.compileMaterials;\r\n            this.compileShadowGenerators = options.compileShadowGenerators ?? this.compileShadowGenerators;\r\n            this.coordinateSystemMode = options.coordinateSystemMode ?? this.coordinateSystemMode;\r\n            this.createInstances = options.createInstances ?? this.createInstances;\r\n            this.customRootNode = options.customRootNode;\r\n            this.extensionOptions = options.extensionOptions ?? this.extensionOptions;\r\n            this.loadAllMaterials = options.loadAllMaterials ?? this.loadAllMaterials;\r\n            this.loadMorphTargets = options.loadMorphTargets ?? this.loadMorphTargets;\r\n            this.loadNodeAnimations = options.loadNodeAnimations ?? this.loadNodeAnimations;\r\n            this.loadOnlyMaterials = options.loadOnlyMaterials ?? this.loadOnlyMaterials;\r\n            this.loadSkins = options.loadSkins ?? this.loadSkins;\r\n            this.loggingEnabled = options.loggingEnabled ?? this.loggingEnabled;\r\n            this.onCameraLoaded = options.onCameraLoaded;\r\n            this.onMaterialLoaded = options.onMaterialLoaded;\r\n            this.onMeshLoaded = options.onMeshLoaded;\r\n            this.onParsed = options.onParsed;\r\n            this.onSkinLoaded = options.onSkinLoaded;\r\n            this.onTextureLoaded = options.onTextureLoaded;\r\n            this.onValidated = options.onValidated;\r\n            this.preprocessUrlAsync = options.preprocessUrlAsync ?? this.preprocessUrlAsync;\r\n            this.skipMaterials = options.skipMaterials ?? this.skipMaterials;\r\n            this.targetFps = options.targetFps ?? this.targetFps;\r\n            this.transparencyAsCoverage = options.transparencyAsCoverage ?? this.transparencyAsCoverage;\r\n            this.useClipPlane = options.useClipPlane ?? this.useClipPlane;\r\n            this.useGltfTextureNames = options.useGltfTextureNames ?? this.useGltfTextureNames;\r\n            this.useRangeRequests = options.useRangeRequests ?? this.useRangeRequests;\r\n            this.useSRGBBuffers = options.useSRGBBuffers ?? this.useSRGBBuffers;\r\n            this.validate = options.validate ?? this.validate;\r\n        }\r\n    }\r\n\r\n    // --------------\r\n    // Common options\r\n    // --------------\r\n\r\n    /**\r\n     * Raised when the asset has been parsed\r\n     */\r\n    public abstract onParsed?: ((loaderData: IGLTFLoaderData) => void) | undefined;\r\n\r\n    // ----------\r\n    // V2 options\r\n    // ----------\r\n\r\n    /**\r\n     * Defines if the loader should always compute the bounding boxes of meshes and not use the min/max values from the position accessor. Defaults to false.\r\n     */\r\n    public alwaysComputeBoundingBox = false;\r\n\r\n    /**\r\n     * Defines if the loader should always compute the nearest common ancestor of the skeleton joints instead of using `skin.skeleton`. Defaults to false.\r\n     * Set this to true if loading assets with invalid `skin.skeleton` values.\r\n     */\r\n    public alwaysComputeSkeletonRootNode = false;\r\n\r\n    /**\r\n     * The animation start mode. Defaults to FIRST.\r\n     */\r\n    public animationStartMode = GLTFLoaderAnimationStartMode.FIRST;\r\n\r\n    /**\r\n     * Defines if the loader should capture performance counters.\r\n     */\r\n    public abstract capturePerformanceCounters: boolean;\r\n\r\n    /**\r\n     * Defines if the loader should compile materials before raising the success callback. Defaults to false.\r\n     */\r\n    public compileMaterials = false;\r\n\r\n    /**\r\n     * Defines if the loader should compile shadow generators before raising the success callback. Defaults to false.\r\n     */\r\n    public compileShadowGenerators = false;\r\n\r\n    /**\r\n     * The coordinate system mode. Defaults to AUTO.\r\n     */\r\n    public coordinateSystemMode = GLTFLoaderCoordinateSystemMode.AUTO;\r\n\r\n    /**\r\n     * Defines if the loader should create instances when multiple glTF nodes point to the same glTF mesh. Defaults to true.\r\n     */\r\n    public createInstances = true;\r\n\r\n    /**\r\n     * Defines the node to use as the root of the hierarchy when loading the scene (default: undefined). If not defined, a root node will be automatically created.\r\n     * You can also pass null if you don't want a root node to be created.\r\n     */\r\n    public customRootNode?: Nullable<TransformNode>;\r\n\r\n    /**\r\n     * Defines options for glTF extensions.\r\n     */\r\n    public extensionOptions: {\r\n        // NOTE: This type is doing two things:\r\n        // 1. Adding an implicit 'enabled' property to the options for each extension.\r\n        // 2. Creating a mapped type of all the options of all the extensions to make it just look like a consolidated plain object in intellisense for the user.\r\n        [Extension in keyof GLTFLoaderExtensionOptions]?: {\r\n            [Option in keyof DefaultExtensionOptions<GLTFLoaderExtensionOptions[Extension]>]: DefaultExtensionOptions<GLTFLoaderExtensionOptions[Extension]>[Option];\r\n        };\r\n    } = {};\r\n\r\n    /**\r\n     * If true, load all materials defined in the file, even if not used by any mesh. Defaults to false.\r\n     */\r\n    public loadAllMaterials = false;\r\n\r\n    /**\r\n     * Defines if the loader should load morph targets. Defaults to true.\r\n     */\r\n    public loadMorphTargets = true;\r\n\r\n    /**\r\n     * Defines if the loader should load node animations. Defaults to true.\r\n     * NOTE: The animation of this node will still load if the node is also a joint of a skin and `loadSkins` is true.\r\n     */\r\n    public loadNodeAnimations = true;\r\n\r\n    /**\r\n     * If true, load only the materials defined in the file. Defaults to false.\r\n     */\r\n    public loadOnlyMaterials = false;\r\n\r\n    /**\r\n     * Defines if the loader should load skins. Defaults to true.\r\n     */\r\n    public loadSkins = true;\r\n\r\n    /**\r\n     * If true, enable logging for the loader. Defaults to false.\r\n     */\r\n    public abstract loggingEnabled: boolean;\r\n\r\n    /**\r\n     * Callback raised when the loader creates a camera after parsing the glTF properties of the camera.\r\n     */\r\n    public abstract onCameraLoaded?: (camera: Camera) => void;\r\n\r\n    /**\r\n     * Callback raised when the loader creates a material after parsing the glTF properties of the material.\r\n     */\r\n    public abstract onMaterialLoaded?: (material: Material) => void;\r\n\r\n    /**\r\n     * Callback raised when the loader creates a mesh after parsing the glTF properties of the mesh.\r\n     * Note that the callback is called as soon as the mesh object is created, meaning some data may not have been setup yet for this mesh (vertex data, morph targets, material, ...)\r\n     */\r\n    public abstract onMeshLoaded?: (mesh: AbstractMesh) => void;\r\n\r\n    /**\r\n     * Callback raised when the loader creates a skin after parsing the glTF properties of the skin node.\r\n     * @see https://doc.babylonjs.com/features/featuresDeepDive/importers/glTF/glTFSkinning#ignoring-the-transform-of-the-skinned-mesh\r\n     */\r\n    public abstract onSkinLoaded?: (node: TransformNode, skinnedNode: TransformNode) => void;\r\n\r\n    /**\r\n     * Callback raised when the loader creates a texture after parsing the glTF properties of the texture.\r\n     */\r\n    public abstract onTextureLoaded?: (texture: BaseTexture) => void;\r\n\r\n    /**\r\n     * Callback raised after the asset is validated.\r\n     */\r\n    public abstract onValidated?: (results: GLTF2.IGLTFValidationResults) => void;\r\n\r\n    /**\r\n     * Function called before loading a url referenced by the asset.\r\n     * @param url url referenced by the asset\r\n     * @returns Async url to load\r\n     */\r\n    public preprocessUrlAsync = (url: string) => Promise.resolve(url);\r\n\r\n    /**\r\n     * If true, do not load any materials defined in the file. Defaults to false.\r\n     */\r\n    public skipMaterials = false;\r\n\r\n    /**\r\n     * When loading glTF animations, which are defined in seconds, target them to this FPS. Defaults to 60.\r\n     */\r\n    public targetFps = 60;\r\n\r\n    /**\r\n     * Defines if the Alpha blended materials are only applied as coverage.\r\n     * If false, (default) The luminance of each pixel will reduce its opacity to simulate the behaviour of most physical materials.\r\n     * If true, no extra effects are applied to transparent pixels.\r\n     */\r\n    public transparencyAsCoverage = false;\r\n\r\n    /**\r\n     * Defines if the loader should also compile materials with clip planes. Defaults to false.\r\n     */\r\n    public useClipPlane = false;\r\n\r\n    /**\r\n     * If true, the loader will derive the name for Babylon textures from the glTF texture name, image name, or image url. Defaults to false.\r\n     * Note that it is possible for multiple Babylon textures to share the same name when the Babylon textures load from the same glTF texture or image.\r\n     */\r\n    public useGltfTextureNames = false;\r\n\r\n    /**\r\n     * Defines if the loader should use range requests when load binary glTF files from HTTP.\r\n     * Enabling will disable offline support and glTF validator.\r\n     * Defaults to false.\r\n     */\r\n    public useRangeRequests = false;\r\n\r\n    /**\r\n     * If true, load the color (gamma encoded) textures into sRGB buffers (if supported by the GPU), which will yield more accurate results when sampling the texture. Defaults to true.\r\n     */\r\n    public useSRGBBuffers = true;\r\n\r\n    /**\r\n     * Defines if the loader should validate the asset.\r\n     */\r\n    public validate = false;\r\n}\r\n\r\n/**\r\n * File loader for loading glTF files into a scene.\r\n */\r\nexport class GLTFFileLoader extends GLTFLoaderOptions implements IDisposable, ISceneLoaderPluginAsync, ISceneLoaderPluginFactory {\r\n    /** @internal */\r\n    public static _CreateGLTF1Loader: (parent: GLTFFileLoader) => IGLTFLoader;\r\n\r\n    /** @internal */\r\n    public static _CreateGLTF2Loader: (parent: GLTFFileLoader) => IGLTFLoader;\r\n\r\n    /**\r\n     * Creates a new glTF file loader.\r\n     * @param options The options for the loader\r\n     */\r\n    public constructor(options?: Partial<Readonly<GLTFLoaderOptions>>) {\r\n        super();\r\n        this.copyFrom(options);\r\n    }\r\n\r\n    // --------------------\r\n    // Begin Common options\r\n    // --------------------\r\n\r\n    /**\r\n     * Raised when the asset has been parsed\r\n     */\r\n    public onParsedObservable = new Observable<IGLTFLoaderData>();\r\n\r\n    private _onParsedObserver: Nullable<Observer<IGLTFLoaderData>>;\r\n\r\n    /**\r\n     * Raised when the asset has been parsed\r\n     */\r\n    public set onParsed(callback: ((loaderData: IGLTFLoaderData) => void) | undefined) {\r\n        if (this._onParsedObserver) {\r\n            this.onParsedObservable.remove(this._onParsedObserver);\r\n        }\r\n        if (callback) {\r\n            this._onParsedObserver = this.onParsedObservable.add(callback);\r\n        }\r\n    }\r\n\r\n    // ------------------\r\n    // End Common options\r\n    // ------------------\r\n\r\n    // ----------------\r\n    // Begin V1 options\r\n    // ----------------\r\n\r\n    /**\r\n     * Set this property to false to disable incremental loading which delays the loader from calling the success callback until after loading the meshes and shaders.\r\n     * Textures always loads asynchronously. For example, the success callback can compute the bounding information of the loaded meshes when incremental loading is disabled.\r\n     * Defaults to true.\r\n     * @internal\r\n     */\r\n    public static IncrementalLoading = true;\r\n\r\n    /**\r\n     * Set this property to true in order to work with homogeneous coordinates, available with some converters and exporters.\r\n     * Defaults to false. See https://en.wikipedia.org/wiki/Homogeneous_coordinates.\r\n     * @internal\r\n     */\r\n    public static HomogeneousCoordinates = false;\r\n\r\n    // --------------\r\n    // End V1 options\r\n    // --------------\r\n\r\n    /**\r\n     * Observable raised when the loader creates a mesh after parsing the glTF properties of the mesh.\r\n     * Note that the observable is raised as soon as the mesh object is created, meaning some data may not have been setup yet for this mesh (vertex data, morph targets, material, ...)\r\n     */\r\n    public readonly onMeshLoadedObservable = new Observable<AbstractMesh>();\r\n\r\n    private _onMeshLoadedObserver: Nullable<Observer<AbstractMesh>>;\r\n\r\n    /**\r\n     * Callback raised when the loader creates a mesh after parsing the glTF properties of the mesh.\r\n     * Note that the callback is called as soon as the mesh object is created, meaning some data may not have been setup yet for this mesh (vertex data, morph targets, material, ...)\r\n     */\r\n    public set onMeshLoaded(callback: ((mesh: AbstractMesh) => void) | undefined) {\r\n        if (this._onMeshLoadedObserver) {\r\n            this.onMeshLoadedObservable.remove(this._onMeshLoadedObserver);\r\n        }\r\n        if (callback) {\r\n            this._onMeshLoadedObserver = this.onMeshLoadedObservable.add(callback);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Observable raised when the loader creates a skin after parsing the glTF properties of the skin node.\r\n     * @see https://doc.babylonjs.com/features/featuresDeepDive/importers/glTF/glTFSkinning#ignoring-the-transform-of-the-skinned-mesh\r\n     * @param node - the transform node that corresponds to the original glTF skin node used for animations\r\n     * @param skinnedNode - the transform node that is the skinned mesh itself or the parent of the skinned meshes\r\n     */\r\n    public readonly onSkinLoadedObservable = new Observable<{ node: TransformNode; skinnedNode: TransformNode }>();\r\n\r\n    private _onSkinLoadedObserver: Nullable<Observer<{ node: TransformNode; skinnedNode: TransformNode }>>;\r\n\r\n    /**\r\n     * Callback raised when the loader creates a skin after parsing the glTF properties of the skin node.\r\n     * @see https://doc.babylonjs.com/features/featuresDeepDive/importers/glTF/glTFSkinning#ignoring-the-transform-of-the-skinned-mesh\r\n     */\r\n    public set onSkinLoaded(callback: ((node: TransformNode, skinnedNode: TransformNode) => void) | undefined) {\r\n        if (this._onSkinLoadedObserver) {\r\n            this.onSkinLoadedObservable.remove(this._onSkinLoadedObserver);\r\n        }\r\n        if (callback) {\r\n            this._onSkinLoadedObserver = this.onSkinLoadedObservable.add((data) => callback(data.node, data.skinnedNode));\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Observable raised when the loader creates a texture after parsing the glTF properties of the texture.\r\n     */\r\n    public readonly onTextureLoadedObservable = new Observable<BaseTexture>();\r\n\r\n    private _onTextureLoadedObserver: Nullable<Observer<BaseTexture>>;\r\n\r\n    /**\r\n     * Callback raised when the loader creates a texture after parsing the glTF properties of the texture.\r\n     */\r\n    public set onTextureLoaded(callback: ((texture: BaseTexture) => void) | undefined) {\r\n        if (this._onTextureLoadedObserver) {\r\n            this.onTextureLoadedObservable.remove(this._onTextureLoadedObserver);\r\n        }\r\n        if (callback) {\r\n            this._onTextureLoadedObserver = this.onTextureLoadedObservable.add(callback);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Observable raised when the loader creates a material after parsing the glTF properties of the material.\r\n     */\r\n    public readonly onMaterialLoadedObservable = new Observable<Material>();\r\n\r\n    private _onMaterialLoadedObserver: Nullable<Observer<Material>>;\r\n\r\n    /**\r\n     * Callback raised when the loader creates a material after parsing the glTF properties of the material.\r\n     */\r\n    public set onMaterialLoaded(callback: ((material: Material) => void) | undefined) {\r\n        if (this._onMaterialLoadedObserver) {\r\n            this.onMaterialLoadedObservable.remove(this._onMaterialLoadedObserver);\r\n        }\r\n        if (callback) {\r\n            this._onMaterialLoadedObserver = this.onMaterialLoadedObservable.add(callback);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Observable raised when the loader creates a camera after parsing the glTF properties of the camera.\r\n     */\r\n    public readonly onCameraLoadedObservable = new Observable<Camera>();\r\n\r\n    private _onCameraLoadedObserver: Nullable<Observer<Camera>>;\r\n\r\n    /**\r\n     * Callback raised when the loader creates a camera after parsing the glTF properties of the camera.\r\n     */\r\n    public set onCameraLoaded(callback: ((camera: Camera) => void) | undefined) {\r\n        if (this._onCameraLoadedObserver) {\r\n            this.onCameraLoadedObservable.remove(this._onCameraLoadedObserver);\r\n        }\r\n        if (callback) {\r\n            this._onCameraLoadedObserver = this.onCameraLoadedObservable.add(callback);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Observable raised when the asset is completely loaded, immediately before the loader is disposed.\r\n     * For assets with LODs, raised when all of the LODs are complete.\r\n     * For assets without LODs, raised when the model is complete, immediately after the loader resolves the returned promise.\r\n     */\r\n    public readonly onCompleteObservable = new Observable<void>();\r\n\r\n    private _onCompleteObserver: Nullable<Observer<void>>;\r\n\r\n    /**\r\n     * Callback raised when the asset is completely loaded, immediately before the loader is disposed.\r\n     * For assets with LODs, raised when all of the LODs are complete.\r\n     * For assets without LODs, raised when the model is complete, immediately after the loader resolves the returned promise.\r\n     */\r\n    public set onComplete(callback: () => void) {\r\n        if (this._onCompleteObserver) {\r\n            this.onCompleteObservable.remove(this._onCompleteObserver);\r\n        }\r\n        this._onCompleteObserver = this.onCompleteObservable.add(callback);\r\n    }\r\n\r\n    /**\r\n     * Observable raised when an error occurs.\r\n     */\r\n    public readonly onErrorObservable = new Observable<any>();\r\n\r\n    private _onErrorObserver: Nullable<Observer<any>>;\r\n\r\n    /**\r\n     * Callback raised when an error occurs.\r\n     */\r\n    public set onError(callback: (reason: any) => void) {\r\n        if (this._onErrorObserver) {\r\n            this.onErrorObservable.remove(this._onErrorObserver);\r\n        }\r\n        this._onErrorObserver = this.onErrorObservable.add(callback);\r\n    }\r\n\r\n    /**\r\n     * Observable raised after the loader is disposed.\r\n     */\r\n    public readonly onDisposeObservable = new Observable<void>();\r\n\r\n    private _onDisposeObserver: Nullable<Observer<void>>;\r\n\r\n    /**\r\n     * Callback raised after the loader is disposed.\r\n     */\r\n    public set onDispose(callback: () => void) {\r\n        if (this._onDisposeObserver) {\r\n            this.onDisposeObservable.remove(this._onDisposeObserver);\r\n        }\r\n        this._onDisposeObserver = this.onDisposeObservable.add(callback);\r\n    }\r\n\r\n    /**\r\n     * Observable raised after a loader extension is created.\r\n     * Set additional options for a loader extension in this event.\r\n     */\r\n    public readonly onExtensionLoadedObservable = new Observable<IGLTFLoaderExtension>();\r\n\r\n    private _onExtensionLoadedObserver: Nullable<Observer<IGLTFLoaderExtension>>;\r\n\r\n    /**\r\n     * Callback raised after a loader extension is created.\r\n     */\r\n    public set onExtensionLoaded(callback: (extension: IGLTFLoaderExtension) => void) {\r\n        if (this._onExtensionLoadedObserver) {\r\n            this.onExtensionLoadedObservable.remove(this._onExtensionLoadedObserver);\r\n        }\r\n        this._onExtensionLoadedObserver = this.onExtensionLoadedObservable.add(callback);\r\n    }\r\n\r\n    /**\r\n     * Defines if the loader logging is enabled.\r\n     */\r\n    public get loggingEnabled(): boolean {\r\n        return this._loggingEnabled;\r\n    }\r\n\r\n    public set loggingEnabled(value: boolean) {\r\n        if (this._loggingEnabled === value) {\r\n            return;\r\n        }\r\n\r\n        this._loggingEnabled = value;\r\n\r\n        if (this._loggingEnabled) {\r\n            this._log = this._logEnabled;\r\n        } else {\r\n            this._log = this._logDisabled;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Defines if the loader should capture performance counters.\r\n     */\r\n    public get capturePerformanceCounters(): boolean {\r\n        return this._capturePerformanceCounters;\r\n    }\r\n\r\n    public set capturePerformanceCounters(value: boolean) {\r\n        if (this._capturePerformanceCounters === value) {\r\n            return;\r\n        }\r\n\r\n        this._capturePerformanceCounters = value;\r\n\r\n        if (this._capturePerformanceCounters) {\r\n            this._startPerformanceCounter = this._startPerformanceCounterEnabled;\r\n            this._endPerformanceCounter = this._endPerformanceCounterEnabled;\r\n        } else {\r\n            this._startPerformanceCounter = this._startPerformanceCounterDisabled;\r\n            this._endPerformanceCounter = this._endPerformanceCounterDisabled;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Observable raised after validation when validate is set to true. The event data is the result of the validation.\r\n     */\r\n    public readonly onValidatedObservable = new Observable<GLTF2.IGLTFValidationResults>();\r\n\r\n    private _onValidatedObserver: Nullable<Observer<GLTF2.IGLTFValidationResults>>;\r\n\r\n    /**\r\n     * Callback raised after the asset is validated.\r\n     */\r\n    public set onValidated(callback: (results: GLTF2.IGLTFValidationResults) => void) {\r\n        if (this._onValidatedObserver) {\r\n            this.onValidatedObservable.remove(this._onValidatedObserver);\r\n        }\r\n        this._onValidatedObserver = this.onValidatedObservable.add(callback);\r\n    }\r\n\r\n    private _loader: Nullable<IGLTFLoader> = null;\r\n    private _state: Nullable<GLTFLoaderState> = null;\r\n    private _progressCallback?: (event: ISceneLoaderProgressEvent) => void;\r\n    private _requests = new Array<IFileRequestInfo>();\r\n\r\n    /**\r\n     * Name of the loader (\"gltf\")\r\n     */\r\n    public readonly name = GLTFFileLoaderMetadata.name;\r\n\r\n    /** @internal */\r\n    public readonly extensions = GLTFFileLoaderMetadata.extensions;\r\n\r\n    /**\r\n     * Disposes the loader, releases resources during load, and cancels any outstanding requests.\r\n     */\r\n    public dispose(): void {\r\n        if (this._loader) {\r\n            this._loader.dispose();\r\n            this._loader = null;\r\n        }\r\n\r\n        for (const request of this._requests) {\r\n            request.abort();\r\n        }\r\n\r\n        this._requests.length = 0;\r\n\r\n        delete this._progressCallback;\r\n\r\n        this.preprocessUrlAsync = (url) => Promise.resolve(url);\r\n\r\n        this.onMeshLoadedObservable.clear();\r\n        this.onSkinLoadedObservable.clear();\r\n        this.onTextureLoadedObservable.clear();\r\n        this.onMaterialLoadedObservable.clear();\r\n        this.onCameraLoadedObservable.clear();\r\n        this.onCompleteObservable.clear();\r\n        this.onExtensionLoadedObservable.clear();\r\n\r\n        this.onDisposeObservable.notifyObservers(undefined);\r\n        this.onDisposeObservable.clear();\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public loadFile(\r\n        scene: Scene,\r\n        fileOrUrl: File | string | ArrayBufferView,\r\n        rootUrl: string,\r\n        onSuccess: (data: unknown, responseURL?: string) => void,\r\n        onProgress?: (ev: ISceneLoaderProgressEvent) => void,\r\n        useArrayBuffer?: boolean,\r\n        onError?: (request?: WebRequest, exception?: LoadFileError) => void,\r\n        name?: string\r\n    ): Nullable<IFileRequest> {\r\n        if (ArrayBuffer.isView(fileOrUrl)) {\r\n            this._loadBinary(scene, fileOrUrl, rootUrl, onSuccess, onError, name);\r\n            return null;\r\n        }\r\n\r\n        this._progressCallback = onProgress;\r\n\r\n        const fileName = (fileOrUrl as File).name || Tools.GetFilename(fileOrUrl as string);\r\n\r\n        if (useArrayBuffer) {\r\n            if (this.useRangeRequests) {\r\n                if (this.validate) {\r\n                    Logger.Warn(\"glTF validation is not supported when range requests are enabled\");\r\n                }\r\n\r\n                const fileRequest: IFileRequest = {\r\n                    abort: () => {},\r\n                    onCompleteObservable: new Observable<IFileRequest>(),\r\n                };\r\n\r\n                const dataBuffer = {\r\n                    readAsync: (byteOffset: number, byteLength: number) => {\r\n                        return new Promise<ArrayBufferView>((resolve, reject) => {\r\n                            this._loadFile(\r\n                                scene,\r\n                                fileOrUrl,\r\n                                (data) => {\r\n                                    resolve(new Uint8Array(data as ArrayBuffer));\r\n                                },\r\n                                true,\r\n                                (error) => {\r\n                                    reject(error);\r\n                                },\r\n                                (webRequest) => {\r\n                                    webRequest.setRequestHeader(\"Range\", `bytes=${byteOffset}-${byteOffset + byteLength - 1}`);\r\n                                }\r\n                            );\r\n                        });\r\n                    },\r\n                    byteLength: 0,\r\n                };\r\n\r\n                this._unpackBinaryAsync(new DataReader(dataBuffer)).then(\r\n                    (loaderData) => {\r\n                        fileRequest.onCompleteObservable.notifyObservers(fileRequest);\r\n                        onSuccess(loaderData);\r\n                    },\r\n                    onError ? (error) => onError(undefined, error) : undefined\r\n                );\r\n\r\n                return fileRequest;\r\n            }\r\n\r\n            return this._loadFile(\r\n                scene,\r\n                fileOrUrl,\r\n                (data) => {\r\n                    this._validate(scene, new Uint8Array(data as ArrayBuffer, 0, (data as ArrayBuffer).byteLength), rootUrl, fileName);\r\n                    this._unpackBinaryAsync(\r\n                        new DataReader({\r\n                            readAsync: (byteOffset, byteLength) => readAsync(data as ArrayBuffer, byteOffset, byteLength),\r\n                            byteLength: (data as ArrayBuffer).byteLength,\r\n                        })\r\n                    ).then(\r\n                        (loaderData) => {\r\n                            onSuccess(loaderData);\r\n                        },\r\n                        onError ? (error) => onError(undefined, error) : undefined\r\n                    );\r\n                },\r\n                true,\r\n                onError\r\n            );\r\n        } else {\r\n            return this._loadFile(\r\n                scene,\r\n                fileOrUrl,\r\n                (data) => {\r\n                    try {\r\n                        this._validate(scene, data as string, rootUrl, fileName);\r\n                        onSuccess({ json: this._parseJson(data as string) });\r\n                    } catch {\r\n                        if (onError) {\r\n                            onError();\r\n                        }\r\n                    }\r\n                },\r\n                false,\r\n                onError\r\n            );\r\n        }\r\n    }\r\n\r\n    private _loadBinary(\r\n        scene: Scene,\r\n        data: ArrayBufferView,\r\n        rootUrl: string,\r\n        onSuccess: (data: unknown, responseURL?: string) => void,\r\n        onError?: (request?: WebRequest, exception?: LoadFileError) => void,\r\n        fileName?: string\r\n    ): void {\r\n        this._validate(scene, new Uint8Array(data.buffer, data.byteOffset, data.byteLength), rootUrl, fileName);\r\n        this._unpackBinaryAsync(\r\n            new DataReader({\r\n                readAsync: (byteOffset, byteLength) => readViewAsync(data, byteOffset, byteLength),\r\n                byteLength: data.byteLength,\r\n            })\r\n        ).then(\r\n            (loaderData) => {\r\n                onSuccess(loaderData);\r\n            },\r\n            onError ? (error) => onError(undefined, error) : undefined\r\n        );\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public importMeshAsync(\r\n        meshesNames: string | readonly string[] | null | undefined,\r\n        scene: Scene,\r\n        data: IGLTFLoaderData,\r\n        rootUrl: string,\r\n        onProgress?: (event: ISceneLoaderProgressEvent) => void,\r\n        fileName?: string\r\n    ): Promise<ISceneLoaderAsyncResult> {\r\n        return Promise.resolve().then(() => {\r\n            this.onParsedObservable.notifyObservers(data);\r\n            this.onParsedObservable.clear();\r\n\r\n            this._log(`Loading ${fileName || \"\"}`);\r\n            this._loader = this._getLoader(data);\r\n            return this._loader.importMeshAsync(meshesNames, scene, null, data, rootUrl, onProgress, fileName);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public loadAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<void> {\r\n        return Promise.resolve().then(() => {\r\n            this.onParsedObservable.notifyObservers(data);\r\n            this.onParsedObservable.clear();\r\n\r\n            this._log(`Loading ${fileName || \"\"}`);\r\n            this._loader = this._getLoader(data);\r\n            return this._loader.loadAsync(scene, data, rootUrl, onProgress, fileName);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public loadAssetContainerAsync(\r\n        scene: Scene,\r\n        data: IGLTFLoaderData,\r\n        rootUrl: string,\r\n        onProgress?: (event: ISceneLoaderProgressEvent) => void,\r\n        fileName?: string\r\n    ): Promise<AssetContainer> {\r\n        return Promise.resolve().then(() => {\r\n            this.onParsedObservable.notifyObservers(data);\r\n            this.onParsedObservable.clear();\r\n\r\n            this._log(`Loading ${fileName || \"\"}`);\r\n            this._loader = this._getLoader(data);\r\n\r\n            // Prepare the asset container.\r\n            const container = new AssetContainer(scene);\r\n\r\n            // Get materials/textures when loading to add to container\r\n            const materials: Array<Material> = [];\r\n            this.onMaterialLoadedObservable.add((material) => {\r\n                materials.push(material);\r\n            });\r\n            const textures: Array<BaseTexture> = [];\r\n            this.onTextureLoadedObservable.add((texture) => {\r\n                textures.push(texture);\r\n            });\r\n            const cameras: Array<Camera> = [];\r\n            this.onCameraLoadedObservable.add((camera) => {\r\n                cameras.push(camera);\r\n            });\r\n\r\n            const morphTargetManagers: Array<MorphTargetManager> = [];\r\n            this.onMeshLoadedObservable.add((mesh) => {\r\n                if (mesh.morphTargetManager) {\r\n                    morphTargetManagers.push(mesh.morphTargetManager);\r\n                }\r\n            });\r\n\r\n            return this._loader.importMeshAsync(null, scene, container, data, rootUrl, onProgress, fileName).then((result) => {\r\n                Array.prototype.push.apply(container.geometries, result.geometries);\r\n                Array.prototype.push.apply(container.meshes, result.meshes);\r\n                Array.prototype.push.apply(container.particleSystems, result.particleSystems);\r\n                Array.prototype.push.apply(container.skeletons, result.skeletons);\r\n                Array.prototype.push.apply(container.animationGroups, result.animationGroups);\r\n                Array.prototype.push.apply(container.materials, materials);\r\n                Array.prototype.push.apply(container.textures, textures);\r\n                Array.prototype.push.apply(container.lights, result.lights);\r\n                Array.prototype.push.apply(container.transformNodes, result.transformNodes);\r\n                Array.prototype.push.apply(container.cameras, cameras);\r\n                Array.prototype.push.apply(container.morphTargetManagers, morphTargetManagers);\r\n                return container;\r\n            });\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public canDirectLoad(data: string): boolean {\r\n        return GLTFFileLoaderMetadata.canDirectLoad(data);\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public directLoad(scene: Scene, data: string): Promise<object> {\r\n        if (\r\n            data.startsWith(\"base64,\" + GLTFMagicBase64Encoded) || // this is technically incorrect, but will continue to support for backcompat.\r\n            data.startsWith(\";base64,\" + GLTFMagicBase64Encoded) ||\r\n            data.startsWith(\"application/octet-stream;base64,\" + GLTFMagicBase64Encoded) ||\r\n            data.startsWith(\"model/gltf-binary;base64,\" + GLTFMagicBase64Encoded)\r\n        ) {\r\n            const arrayBuffer = DecodeBase64UrlToBinary(data);\r\n\r\n            this._validate(scene, new Uint8Array(arrayBuffer, 0, arrayBuffer.byteLength));\r\n            return this._unpackBinaryAsync(\r\n                new DataReader({\r\n                    readAsync: (byteOffset, byteLength) => readAsync(arrayBuffer, byteOffset, byteLength),\r\n                    byteLength: arrayBuffer.byteLength,\r\n                })\r\n            );\r\n        }\r\n\r\n        this._validate(scene, data);\r\n        return Promise.resolve({ json: this._parseJson(data) });\r\n    }\r\n\r\n    /**\r\n     * The callback that allows custom handling of the root url based on the response url.\r\n     * @param rootUrl the original root url\r\n     * @param responseURL the response url if available\r\n     * @returns the new root url\r\n     */\r\n    public rewriteRootURL?(rootUrl: string, responseURL?: string): string;\r\n\r\n    /** @internal */\r\n    public createPlugin(options: SceneLoaderPluginOptions): ISceneLoaderPluginAsync {\r\n        return new GLTFFileLoader(options[GLTFFileLoaderMetadata.name]);\r\n    }\r\n\r\n    /**\r\n     * The loader state or null if the loader is not active.\r\n     */\r\n    public get loaderState(): Nullable<GLTFLoaderState> {\r\n        return this._state;\r\n    }\r\n\r\n    /**\r\n     * Observable raised when the loader state changes.\r\n     */\r\n    public onLoaderStateChangedObservable = new Observable<Nullable<GLTFLoaderState>>();\r\n\r\n    /**\r\n     * Returns a promise that resolves when the asset is completely loaded.\r\n     * @returns a promise that resolves when the asset is completely loaded.\r\n     */\r\n    public whenCompleteAsync(): Promise<void> {\r\n        return new Promise((resolve, reject) => {\r\n            this.onCompleteObservable.addOnce(() => {\r\n                resolve();\r\n            });\r\n            this.onErrorObservable.addOnce((reason) => {\r\n                reject(reason);\r\n            });\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public _setState(state: GLTFLoaderState): void {\r\n        if (this._state === state) {\r\n            return;\r\n        }\r\n\r\n        this._state = state;\r\n        this.onLoaderStateChangedObservable.notifyObservers(this._state);\r\n        this._log(GLTFLoaderState[this._state]);\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public _loadFile(\r\n        scene: Scene,\r\n        fileOrUrl: File | string,\r\n        onSuccess: (data: string | ArrayBuffer) => void,\r\n        useArrayBuffer?: boolean,\r\n        onError?: (request?: WebRequest) => void,\r\n        onOpened?: (request: WebRequest) => void\r\n    ): IFileRequest {\r\n        const request = scene._loadFile(\r\n            fileOrUrl,\r\n            onSuccess,\r\n            (event) => {\r\n                this._onProgress(event, request);\r\n            },\r\n            true,\r\n            useArrayBuffer,\r\n            onError,\r\n            onOpened\r\n        ) as IFileRequestInfo;\r\n        request.onCompleteObservable.add(() => {\r\n            // Force the length computable to be true since we can guarantee the data is loaded.\r\n            request._lengthComputable = true;\r\n            request._total = request._loaded;\r\n        });\r\n        this._requests.push(request);\r\n        return request;\r\n    }\r\n\r\n    private _onProgress(event: ProgressEvent, request: IFileRequestInfo): void {\r\n        if (!this._progressCallback) {\r\n            return;\r\n        }\r\n\r\n        request._lengthComputable = event.lengthComputable;\r\n        request._loaded = event.loaded;\r\n        request._total = event.total;\r\n\r\n        let lengthComputable = true;\r\n        let loaded = 0;\r\n        let total = 0;\r\n        for (const request of this._requests) {\r\n            if (request._lengthComputable === undefined || request._loaded === undefined || request._total === undefined) {\r\n                return;\r\n            }\r\n\r\n            lengthComputable = lengthComputable && request._lengthComputable;\r\n            loaded += request._loaded;\r\n            total += request._total;\r\n        }\r\n\r\n        this._progressCallback({\r\n            lengthComputable: lengthComputable,\r\n            loaded: loaded,\r\n            total: lengthComputable ? total : 0,\r\n        });\r\n    }\r\n\r\n    private _validate(scene: Scene, data: string | Uint8Array, rootUrl = \"\", fileName = \"\"): void {\r\n        if (!this.validate) {\r\n            return;\r\n        }\r\n\r\n        this._startPerformanceCounter(\"Validate JSON\");\r\n        GLTFValidation.ValidateAsync(data, rootUrl, fileName, (uri) => {\r\n            return this.preprocessUrlAsync(rootUrl + uri).then((url) => {\r\n                return scene._loadFileAsync(url, undefined, true, true).then((data) => {\r\n                    return new Uint8Array(data, 0, data.byteLength);\r\n                });\r\n            });\r\n        }).then(\r\n            (result) => {\r\n                this._endPerformanceCounter(\"Validate JSON\");\r\n                this.onValidatedObservable.notifyObservers(result);\r\n                this.onValidatedObservable.clear();\r\n            },\r\n            (reason) => {\r\n                this._endPerformanceCounter(\"Validate JSON\");\r\n                Tools.Warn(`Failed to validate: ${reason.message}`);\r\n                this.onValidatedObservable.clear();\r\n            }\r\n        );\r\n    }\r\n\r\n    private _getLoader(loaderData: IGLTFLoaderData): IGLTFLoader {\r\n        const asset = (<any>loaderData.json).asset || {};\r\n\r\n        this._log(`Asset version: ${asset.version}`);\r\n        asset.minVersion && this._log(`Asset minimum version: ${asset.minVersion}`);\r\n        asset.generator && this._log(`Asset generator: ${asset.generator}`);\r\n\r\n        const version = GLTFFileLoader._parseVersion(asset.version);\r\n        if (!version) {\r\n            throw new Error(\"Invalid version: \" + asset.version);\r\n        }\r\n\r\n        if (asset.minVersion !== undefined) {\r\n            const minVersion = GLTFFileLoader._parseVersion(asset.minVersion);\r\n            if (!minVersion) {\r\n                throw new Error(\"Invalid minimum version: \" + asset.minVersion);\r\n            }\r\n\r\n            if (GLTFFileLoader._compareVersion(minVersion, { major: 2, minor: 0 }) > 0) {\r\n                throw new Error(\"Incompatible minimum version: \" + asset.minVersion);\r\n            }\r\n        }\r\n\r\n        const createLoaders: { [key: number]: (parent: GLTFFileLoader) => IGLTFLoader } = {\r\n            1: GLTFFileLoader._CreateGLTF1Loader,\r\n            2: GLTFFileLoader._CreateGLTF2Loader,\r\n        };\r\n\r\n        const createLoader = createLoaders[version.major];\r\n        if (!createLoader) {\r\n            throw new Error(\"Unsupported version: \" + asset.version);\r\n        }\r\n\r\n        return createLoader(this);\r\n    }\r\n\r\n    private _parseJson(json: string): object {\r\n        this._startPerformanceCounter(\"Parse JSON\");\r\n        this._log(`JSON length: ${json.length}`);\r\n        const parsed = JSON.parse(json);\r\n        this._endPerformanceCounter(\"Parse JSON\");\r\n        return parsed;\r\n    }\r\n\r\n    private _unpackBinaryAsync(dataReader: DataReader): Promise<IGLTFLoaderData> {\r\n        this._startPerformanceCounter(\"Unpack Binary\");\r\n\r\n        // Read magic + version + length + json length + json format\r\n        return dataReader.loadAsync(20).then(() => {\r\n            const Binary = {\r\n                Magic: 0x46546c67,\r\n            };\r\n\r\n            const magic = dataReader.readUint32();\r\n            if (magic !== Binary.Magic) {\r\n                throw new RuntimeError(\"Unexpected magic: \" + magic, ErrorCodes.GLTFLoaderUnexpectedMagicError);\r\n            }\r\n\r\n            const version = dataReader.readUint32();\r\n\r\n            if (this.loggingEnabled) {\r\n                this._log(`Binary version: ${version}`);\r\n            }\r\n\r\n            const length = dataReader.readUint32();\r\n            if (!this.useRangeRequests && length !== dataReader.buffer.byteLength) {\r\n                Logger.Warn(`Length in header does not match actual data length: ${length} != ${dataReader.buffer.byteLength}`);\r\n            }\r\n\r\n            let unpacked: Promise<IGLTFLoaderData>;\r\n            switch (version) {\r\n                case 1: {\r\n                    unpacked = this._unpackBinaryV1Async(dataReader, length);\r\n                    break;\r\n                }\r\n                case 2: {\r\n                    unpacked = this._unpackBinaryV2Async(dataReader, length);\r\n                    break;\r\n                }\r\n                default: {\r\n                    throw new Error(\"Unsupported version: \" + version);\r\n                }\r\n            }\r\n\r\n            this._endPerformanceCounter(\"Unpack Binary\");\r\n\r\n            return unpacked;\r\n        });\r\n    }\r\n\r\n    private _unpackBinaryV1Async(dataReader: DataReader, length: number): Promise<IGLTFLoaderData> {\r\n        const ContentFormat = {\r\n            JSON: 0,\r\n        };\r\n\r\n        const contentLength = dataReader.readUint32();\r\n        const contentFormat = dataReader.readUint32();\r\n\r\n        if (contentFormat !== ContentFormat.JSON) {\r\n            throw new Error(`Unexpected content format: ${contentFormat}`);\r\n        }\r\n\r\n        const bodyLength = length - dataReader.byteOffset;\r\n\r\n        const data: IGLTFLoaderData = { json: this._parseJson(dataReader.readString(contentLength)), bin: null };\r\n        if (bodyLength !== 0) {\r\n            const startByteOffset = dataReader.byteOffset;\r\n            data.bin = {\r\n                readAsync: (byteOffset, byteLength) => dataReader.buffer.readAsync(startByteOffset + byteOffset, byteLength),\r\n                byteLength: bodyLength,\r\n            };\r\n        }\r\n\r\n        return Promise.resolve(data);\r\n    }\r\n\r\n    private _unpackBinaryV2Async(dataReader: DataReader, length: number): Promise<IGLTFLoaderData> {\r\n        const ChunkFormat = {\r\n            JSON: 0x4e4f534a,\r\n            BIN: 0x004e4942,\r\n        };\r\n\r\n        // Read the JSON chunk header.\r\n        const chunkLength = dataReader.readUint32();\r\n        const chunkFormat = dataReader.readUint32();\r\n        if (chunkFormat !== ChunkFormat.JSON) {\r\n            throw new Error(\"First chunk format is not JSON\");\r\n        }\r\n\r\n        // Bail if there are no other chunks.\r\n        if (dataReader.byteOffset + chunkLength === length) {\r\n            return dataReader.loadAsync(chunkLength).then(() => {\r\n                return { json: this._parseJson(dataReader.readString(chunkLength)), bin: null };\r\n            });\r\n        }\r\n\r\n        // Read the JSON chunk and the length and type of the next chunk.\r\n        return dataReader.loadAsync(chunkLength + 8).then(() => {\r\n            const data: IGLTFLoaderData = { json: this._parseJson(dataReader.readString(chunkLength)), bin: null };\r\n\r\n            const readAsync = (): Promise<IGLTFLoaderData> => {\r\n                const chunkLength = dataReader.readUint32();\r\n                const chunkFormat = dataReader.readUint32();\r\n\r\n                switch (chunkFormat) {\r\n                    case ChunkFormat.JSON: {\r\n                        throw new Error(\"Unexpected JSON chunk\");\r\n                    }\r\n                    case ChunkFormat.BIN: {\r\n                        const startByteOffset = dataReader.byteOffset;\r\n                        data.bin = {\r\n                            readAsync: (byteOffset, byteLength) => dataReader.buffer.readAsync(startByteOffset + byteOffset, byteLength),\r\n                            byteLength: chunkLength,\r\n                        };\r\n                        dataReader.skipBytes(chunkLength);\r\n                        break;\r\n                    }\r\n                    default: {\r\n                        // ignore unrecognized chunkFormat\r\n                        dataReader.skipBytes(chunkLength);\r\n                        break;\r\n                    }\r\n                }\r\n\r\n                if (dataReader.byteOffset !== length) {\r\n                    return dataReader.loadAsync(8).then(readAsync);\r\n                }\r\n\r\n                return Promise.resolve(data);\r\n            };\r\n\r\n            return readAsync();\r\n        });\r\n    }\r\n\r\n    private static _parseVersion(version: string): Nullable<{ major: number; minor: number }> {\r\n        if (version === \"1.0\" || version === \"1.0.1\") {\r\n            return {\r\n                major: 1,\r\n                minor: 0,\r\n            };\r\n        }\r\n\r\n        const match = (version + \"\").match(/^(\\d+)\\.(\\d+)/);\r\n        if (!match) {\r\n            return null;\r\n        }\r\n\r\n        return {\r\n            major: parseInt(match[1]),\r\n            minor: parseInt(match[2]),\r\n        };\r\n    }\r\n\r\n    private static _compareVersion(a: { major: number; minor: number }, b: { major: number; minor: number }): number {\r\n        if (a.major > b.major) {\r\n            return 1;\r\n        }\r\n        if (a.major < b.major) {\r\n            return -1;\r\n        }\r\n        if (a.minor > b.minor) {\r\n            return 1;\r\n        }\r\n        if (a.minor < b.minor) {\r\n            return -1;\r\n        }\r\n        return 0;\r\n    }\r\n\r\n    private static readonly _logSpaces = \"                                \";\r\n    private _logIndentLevel = 0;\r\n    private _loggingEnabled = false;\r\n\r\n    /** @internal */\r\n    public _log = this._logDisabled;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public _logOpen(message: string): void {\r\n        this._log(message);\r\n        this._logIndentLevel++;\r\n    }\r\n\r\n    /** @internal */\r\n    public _logClose(): void {\r\n        --this._logIndentLevel;\r\n    }\r\n\r\n    private _logEnabled(message: string): void {\r\n        const spaces = GLTFFileLoader._logSpaces.substring(0, this._logIndentLevel * 2);\r\n        Logger.Log(`${spaces}${message}`);\r\n    }\r\n\r\n    private _logDisabled(message: string): void {}\r\n\r\n    private _capturePerformanceCounters = false;\r\n\r\n    /** @internal */\r\n    public _startPerformanceCounter = this._startPerformanceCounterDisabled;\r\n\r\n    /** @internal */\r\n    public _endPerformanceCounter = this._endPerformanceCounterDisabled;\r\n\r\n    private _startPerformanceCounterEnabled(counterName: string): void {\r\n        Tools.StartPerformanceCounter(counterName);\r\n    }\r\n\r\n    private _startPerformanceCounterDisabled(counterName: string): void {}\r\n\r\n    private _endPerformanceCounterEnabled(counterName: string): void {\r\n        Tools.EndPerformanceCounter(counterName);\r\n    }\r\n\r\n    private _endPerformanceCounterDisabled(counterName: string): void {}\r\n}\r\n\r\nRegisterSceneLoaderPlugin(new GLTFFileLoader());\r\n","import type { ISceneLoaderPluginExtensions, ISceneLoaderPluginMetadata } from \"core/index\";\r\n\r\nexport const GLTFMagicBase64Encoded = \"Z2xURg\"; // \"glTF\" base64 encoded (without the quotes!)\r\n\r\nexport const GLTFFileLoaderMetadata = {\r\n    name: \"gltf\",\r\n\r\n    extensions: {\r\n        // eslint-disable-next-line @typescript-eslint/naming-convention\r\n        \".gltf\": { isBinary: false, mimeType: \"model/gltf+json\" },\r\n        // eslint-disable-next-line @typescript-eslint/naming-convention\r\n        \".glb\": { isBinary: true, mimeType: \"model/gltf-binary\" },\r\n    } as const satisfies ISceneLoaderPluginExtensions,\r\n\r\n    canDirectLoad(data: string): boolean {\r\n        return (\r\n            (data.indexOf(\"asset\") !== -1 && data.indexOf(\"version\") !== -1) ||\r\n            data.startsWith(\"data:base64,\" + GLTFMagicBase64Encoded) || // this is technically incorrect, but will continue to support for backcompat.\r\n            data.startsWith(\"data:;base64,\" + GLTFMagicBase64Encoded) ||\r\n            data.startsWith(\"data:application/octet-stream;base64,\" + GLTFMagicBase64Encoded) ||\r\n            data.startsWith(\"data:model/gltf-binary;base64,\" + GLTFMagicBase64Encoded)\r\n        );\r\n    },\r\n} as const satisfies ISceneLoaderPluginMetadata;\r\n","import * as FileLoader from \"loaders/glTF/glTFFileLoader\";\r\nimport * as Validation from \"loaders/glTF/glTFValidation\";\r\n\r\n/**\r\n * This is the entry point for the UMD module.\r\n * The entry point for a future ESM package should be index.ts\r\n */\r\nconst GlobalObject = typeof global !== \"undefined\" ? global : typeof window !== \"undefined\" ? window : undefined;\r\nif (typeof GlobalObject !== \"undefined\") {\r\n    (<any>GlobalObject).BABYLON = (<any>GlobalObject).BABYLON || {};\r\n    for (const key in FileLoader) {\r\n        (<any>GlobalObject).BABYLON[key] = (<any>FileLoader)[key];\r\n    }\r\n    for (const key in Validation) {\r\n        (<any>GlobalObject).BABYLON[key] = (<any>Validation)[key];\r\n    }\r\n}\r\n\r\nexport * from \"loaders/glTF/glTFFileLoader\";\r\nexport * from \"loaders/glTF/glTFValidation\";\r\n","import type { GLTFLoader } from \"./glTFLoader\";\r\nimport type { IGLTFLoaderExtension } from \"./glTFLoaderExtension\";\r\n\r\nimport { Logger } from \"core/Misc/logger\";\r\n\r\ninterface IRegisteredGLTFExtension {\r\n    isGLTFExtension: boolean;\r\n    factory: GLTFExtensionFactory;\r\n}\r\n\r\nexport type GLTFExtensionFactory = (loader: GLTFLoader) => IGLTFLoaderExtension | Promise<IGLTFLoaderExtension>;\r\n\r\nconst RegisteredGLTFExtensions = new Map<string, IRegisteredGLTFExtension>();\r\n\r\n/**\r\n * All currently registered glTF 2.0 loader extensions.\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport const registeredGLTFExtensions: ReadonlyMap<string, Readonly<IRegisteredGLTFExtension>> = RegisteredGLTFExtensions;\r\n\r\n/**\r\n * Registers a loader extension.\r\n * @param name The name of the loader extension.\r\n * @param isGLTFExtension If the loader extension is a glTF extension, then it will only be used for glTF files that use the corresponding glTF extension. Otherwise, it will be used for all loaded glTF files.\r\n * @param factory The factory function that creates the loader extension.\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport function registerGLTFExtension(name: string, isGLTFExtension: boolean, factory: GLTFExtensionFactory): void {\r\n    if (unregisterGLTFExtension(name)) {\r\n        Logger.Warn(`Extension with the name '${name}' already exists`);\r\n    }\r\n\r\n    RegisteredGLTFExtensions.set(name, {\r\n        isGLTFExtension,\r\n        factory,\r\n    });\r\n}\r\n\r\n/**\r\n * Unregisters a loader extension.\r\n * @param name The name of the loader extension.\r\n * @returns A boolean indicating whether the extension has been unregistered\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport function unregisterGLTFExtension(name: string): boolean {\r\n    return RegisteredGLTFExtensions.delete(name);\r\n}\r\n","/* eslint-disable @typescript-eslint/promise-function-async */\r\n/* eslint-disable no-restricted-syntax */\r\n/* eslint-disable github/no-then */\r\nimport type { IndicesArray, Nullable, TypedArray, TypedArrayConstructor } from \"core/types\";\r\nimport { Deferred } from \"core/Misc/deferred\";\r\nimport { Quaternion, Vector3, Matrix, TmpVectors } from \"core/Maths/math.vector\";\r\nimport { Color3 } from \"core/Maths/math.color\";\r\nimport { Tools } from \"core/Misc/tools\";\r\nimport { Camera } from \"core/Cameras/camera\";\r\nimport { FreeCamera } from \"core/Cameras/freeCamera\";\r\nimport type { Animation } from \"core/Animations/animation\";\r\nimport type { IAnimatable } from \"core/Animations/animatable.interface\";\r\nimport type { IAnimationKey } from \"core/Animations/animationKey\";\r\nimport { AnimationKeyInterpolation } from \"core/Animations/animationKey\";\r\nimport type { AnimationGroup } from \"core/Animations/animationGroup\";\r\nimport { Bone } from \"core/Bones/bone\";\r\nimport { Skeleton } from \"core/Bones/skeleton\";\r\nimport { Material } from \"core/Materials/material\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\r\nimport type { ITextureCreationOptions } from \"core/Materials/Textures/texture\";\r\nimport { Texture } from \"core/Materials/Textures/texture\";\r\nimport { TransformNode } from \"core/Meshes/transformNode\";\r\nimport { Buffer, VertexBuffer } from \"core/Buffers/buffer\";\r\nimport { Geometry } from \"core/Meshes/geometry\";\r\nimport { AbstractMesh } from \"core/Meshes/abstractMesh\";\r\nimport { Mesh } from \"core/Meshes/mesh\";\r\nimport { MorphTarget } from \"core/Morph/morphTarget\";\r\nimport { MorphTargetManager } from \"core/Morph/morphTargetManager\";\r\nimport type { ISceneLoaderAsyncResult, ISceneLoaderProgressEvent } from \"core/Loading/sceneLoader\";\r\nimport type { Scene } from \"core/scene\";\r\nimport type { IProperty } from \"babylonjs-gltf2interface\";\r\nimport {\r\n    AnimationChannelTargetPath,\r\n    AnimationSamplerInterpolation,\r\n    AccessorType,\r\n    CameraType,\r\n    AccessorComponentType,\r\n    MaterialAlphaMode,\r\n    TextureMinFilter,\r\n    TextureWrapMode,\r\n    TextureMagFilter,\r\n    MeshPrimitiveMode,\r\n} from \"babylonjs-gltf2interface\";\r\nimport type {\r\n    IGLTF,\r\n    ISampler,\r\n    INode,\r\n    IScene,\r\n    IMesh,\r\n    IAccessor,\r\n    ISkin,\r\n    ICamera,\r\n    IAnimation,\r\n    IBuffer,\r\n    IBufferView,\r\n    IMaterialPbrMetallicRoughness,\r\n    IMaterial,\r\n    ITextureInfo,\r\n    ITexture,\r\n    IImage,\r\n    IMeshPrimitive,\r\n    IArrayItem,\r\n    _ISamplerData,\r\n    IAnimationChannel,\r\n    IAnimationSampler,\r\n    _IAnimationSamplerData,\r\n} from \"./glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"./glTFLoaderExtension\";\r\nimport type { IGLTFLoader, IGLTFLoaderData } from \"../glTFFileLoader\";\r\nimport { GLTFFileLoader, GLTFLoaderState, GLTFLoaderCoordinateSystemMode, GLTFLoaderAnimationStartMode } from \"../glTFFileLoader\";\r\nimport type { IDataBuffer } from \"core/Misc/dataReader\";\r\nimport { DecodeBase64UrlToBinary, GetMimeType, IsBase64DataUrl, LoadFileError } from \"core/Misc/fileTools\";\r\nimport { Logger } from \"core/Misc/logger\";\r\nimport type { Light } from \"core/Lights/light\";\r\nimport { BoundingInfo } from \"core/Culling/boundingInfo\";\r\nimport type { AssetContainer } from \"core/assetContainer\";\r\nimport type { AnimationPropertyInfo } from \"./glTFLoaderAnimation\";\r\nimport type { IObjectInfo } from \"core/ObjectModel/objectModelInterfaces\";\r\nimport { registeredGLTFExtensions, registerGLTFExtension, unregisterGLTFExtension } from \"./glTFLoaderExtensionRegistry\";\r\nimport type { GLTFExtensionFactory } from \"./glTFLoaderExtensionRegistry\";\r\nimport type { IInterpolationPropertyInfo } from \"core/FlowGraph/typeDefinitions\";\r\nimport { GetMappingForKey } from \"./Extensions/objectModelMapping\";\r\nimport { deepMerge } from \"core/Misc/deepMerger\";\r\nimport { GetTypedArrayConstructor } from \"core/Buffers/bufferUtils\";\r\nimport { Lazy } from \"core/Misc/lazy\";\r\n\r\n// Caching these dynamic imports gives a surprising perf boost (compared to importing them directly each time).\r\nconst LazyAnimationGroupModulePromise = new Lazy(() => import(\"core/Animations/animationGroup\"));\r\nconst LazyLoaderAnimationModulePromise = new Lazy(() => import(\"./glTFLoaderAnimation\"));\r\n\r\nexport { GLTFFileLoader };\r\n\r\ninterface ILoaderProperty extends IProperty {\r\n    _activeLoaderExtensionFunctions: {\r\n        [id: string]: boolean;\r\n    };\r\n}\r\n\r\ninterface IWithMetadata {\r\n    metadata: any;\r\n    _internalMetadata: any;\r\n}\r\n\r\n/**\r\n * Helper class for working with arrays when loading the glTF asset\r\n */\r\nexport class ArrayItem {\r\n    /**\r\n     * Gets an item from the given array.\r\n     * @param context The context when loading the asset\r\n     * @param array The array to get the item from\r\n     * @param index The index to the array\r\n     * @returns The array item\r\n     */\r\n    public static Get<T>(context: string, array: ArrayLike<T> | undefined, index: number | undefined): T {\r\n        if (!array || index == undefined || !array[index]) {\r\n            throw new Error(`${context}: Failed to find index (${index})`);\r\n        }\r\n\r\n        return array[index];\r\n    }\r\n\r\n    /**\r\n     * Gets an item from the given array or returns null if not available.\r\n     * @param array The array to get the item from\r\n     * @param index The index to the array\r\n     * @returns The array item or null\r\n     */\r\n    public static TryGet<T>(array: ArrayLike<T> | undefined, index: number | undefined): Nullable<T> {\r\n        if (!array || index == undefined || !array[index]) {\r\n            return null;\r\n        }\r\n\r\n        return array[index];\r\n    }\r\n\r\n    /**\r\n     * Assign an `index` field to each item of the given array.\r\n     * @param array The array of items\r\n     */\r\n    public static Assign(array?: IArrayItem[]): void {\r\n        if (array) {\r\n            for (let index = 0; index < array.length; index++) {\r\n                array[index].index = index;\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\n/** @internal */\r\nexport interface IAnimationTargetInfo {\r\n    /** @internal */\r\n    target: unknown;\r\n\r\n    /** @internal */\r\n    properties: Array<AnimationPropertyInfo>;\r\n}\r\n\r\n/** @internal */\r\nexport function LoadBoundingInfoFromPositionAccessor(accessor: IAccessor): Nullable<BoundingInfo> {\r\n    if (accessor.min && accessor.max) {\r\n        const minArray = accessor.min as [number, number, number];\r\n        const maxArray = accessor.max as [number, number, number];\r\n        const minVector = TmpVectors.Vector3[0].copyFromFloats(minArray[0], minArray[1], minArray[2]);\r\n        const maxVector = TmpVectors.Vector3[1].copyFromFloats(maxArray[0], maxArray[1], maxArray[2]);\r\n        if (accessor.normalized && accessor.componentType !== AccessorComponentType.FLOAT) {\r\n            let divider = 1;\r\n            switch (accessor.componentType) {\r\n                case AccessorComponentType.BYTE:\r\n                    divider = 127.0;\r\n                    break;\r\n                case AccessorComponentType.UNSIGNED_BYTE:\r\n                    divider = 255.0;\r\n                    break;\r\n                case AccessorComponentType.SHORT:\r\n                    divider = 32767.0;\r\n                    break;\r\n                case AccessorComponentType.UNSIGNED_SHORT:\r\n                    divider = 65535.0;\r\n                    break;\r\n            }\r\n            const oneOverDivider = 1 / divider;\r\n            minVector.scaleInPlace(oneOverDivider);\r\n            maxVector.scaleInPlace(oneOverDivider);\r\n        }\r\n        return new BoundingInfo(minVector, maxVector);\r\n    }\r\n    return null;\r\n}\r\n\r\n/**\r\n * The glTF 2.0 loader\r\n */\r\nexport class GLTFLoader implements IGLTFLoader {\r\n    /** @internal */\r\n    public readonly _completePromises = new Array<Promise<unknown>>();\r\n\r\n    /** @internal */\r\n    public _assetContainer: Nullable<AssetContainer> = null;\r\n\r\n    /** Storage */\r\n    public _babylonLights: Light[] = [];\r\n\r\n    /** @internal */\r\n    public _disableInstancedMesh = 0;\r\n\r\n    /** @internal */\r\n    public _allMaterialsDirtyRequired = false;\r\n\r\n    /** @internal */\r\n    public _skipStartAnimationStep = false;\r\n\r\n    private readonly _parent: GLTFFileLoader;\r\n    private readonly _extensions = new Array<IGLTFLoaderExtension>();\r\n    private _disposed = false;\r\n    private _rootUrl: Nullable<string> = null;\r\n    private _fileName: Nullable<string> = null;\r\n    private _uniqueRootUrl: Nullable<string> = null;\r\n    private _gltf: IGLTF;\r\n    private _bin: Nullable<IDataBuffer> = null;\r\n    private _babylonScene: Scene;\r\n    private _rootBabylonMesh: Nullable<TransformNode> = null;\r\n    private _defaultBabylonMaterialData: { [drawMode: number]: Material } = {};\r\n    private readonly _postSceneLoadActions = new Array<() => void>();\r\n\r\n    /**\r\n     * The default glTF sampler.\r\n     */\r\n    public static readonly DefaultSampler: ISampler = { index: -1 };\r\n\r\n    /**\r\n     * Registers a loader extension.\r\n     * @param name The name of the loader extension.\r\n     * @param factory The factory function that creates the loader extension.\r\n     * @deprecated Please use registerGLTFExtension instead.\r\n     */\r\n    public static RegisterExtension(name: string, factory: GLTFExtensionFactory): void {\r\n        registerGLTFExtension(name, false, factory);\r\n    }\r\n\r\n    /**\r\n     * Unregisters a loader extension.\r\n     * @param name The name of the loader extension.\r\n     * @returns A boolean indicating whether the extension has been unregistered\r\n     * @deprecated Please use unregisterGLTFExtension instead.\r\n     */\r\n    public static UnregisterExtension(name: string): boolean {\r\n        return unregisterGLTFExtension(name);\r\n    }\r\n\r\n    /**\r\n     * The object that represents the glTF JSON.\r\n     */\r\n    public get gltf(): IGLTF {\r\n        if (!this._gltf) {\r\n            throw new Error(\"glTF JSON is not available\");\r\n        }\r\n\r\n        return this._gltf;\r\n    }\r\n\r\n    /**\r\n     * The BIN chunk of a binary glTF.\r\n     */\r\n    public get bin(): Nullable<IDataBuffer> {\r\n        return this._bin;\r\n    }\r\n\r\n    /**\r\n     * The parent file loader.\r\n     */\r\n    public get parent(): GLTFFileLoader {\r\n        return this._parent;\r\n    }\r\n\r\n    /**\r\n     * The Babylon scene when loading the asset.\r\n     */\r\n    public get babylonScene(): Scene {\r\n        if (!this._babylonScene) {\r\n            throw new Error(\"Scene is not available\");\r\n        }\r\n\r\n        return this._babylonScene;\r\n    }\r\n\r\n    /**\r\n     * The root Babylon node when loading the asset.\r\n     */\r\n    public get rootBabylonMesh(): Nullable<TransformNode> {\r\n        return this._rootBabylonMesh;\r\n    }\r\n\r\n    /**\r\n     * The root url when loading the asset.\r\n     */\r\n    public get rootUrl(): Nullable<string> {\r\n        return this._rootUrl;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(parent: GLTFFileLoader) {\r\n        this._parent = parent;\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose(): void {\r\n        if (this._disposed) {\r\n            return;\r\n        }\r\n\r\n        this._disposed = true;\r\n\r\n        this._completePromises.length = 0;\r\n\r\n        this._extensions.forEach((extension) => extension.dispose && extension.dispose());\r\n        this._extensions.length = 0;\r\n\r\n        (this._gltf as Nullable<IGLTF>) = null; // TODO\r\n        this._bin = null;\r\n        (this._babylonScene as Nullable<Scene>) = null; // TODO\r\n        this._rootBabylonMesh = null;\r\n        this._defaultBabylonMaterialData = {};\r\n        this._postSceneLoadActions.length = 0;\r\n\r\n        this._parent.dispose();\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public async importMeshAsync(\r\n        meshesNames: string | readonly string[] | null | undefined,\r\n        scene: Scene,\r\n        container: Nullable<AssetContainer>,\r\n        data: IGLTFLoaderData,\r\n        rootUrl: string,\r\n        onProgress?: (event: ISceneLoaderProgressEvent) => void,\r\n        fileName = \"\"\r\n    ): Promise<ISceneLoaderAsyncResult> {\r\n        // eslint-disable-next-line github/no-then\r\n        return await Promise.resolve().then(async () => {\r\n            this._babylonScene = scene;\r\n            this._assetContainer = container;\r\n            this._loadData(data);\r\n\r\n            let nodes: Nullable<Array<number>> = null;\r\n\r\n            if (meshesNames) {\r\n                const nodeMap: { [name: string]: number } = {};\r\n                if (this._gltf.nodes) {\r\n                    for (const node of this._gltf.nodes) {\r\n                        if (node.name) {\r\n                            nodeMap[node.name] = node.index;\r\n                        }\r\n                    }\r\n                }\r\n\r\n                const names = meshesNames instanceof Array ? meshesNames : [meshesNames];\r\n                nodes = names.map((name) => {\r\n                    const node = nodeMap[name];\r\n                    if (node === undefined) {\r\n                        throw new Error(`Failed to find node '${name}'`);\r\n                    }\r\n\r\n                    return node;\r\n                });\r\n            }\r\n\r\n            return await this._loadAsync(rootUrl, fileName, nodes, () => {\r\n                return {\r\n                    meshes: this._getMeshes(),\r\n                    particleSystems: [],\r\n                    skeletons: this._getSkeletons(),\r\n                    animationGroups: this._getAnimationGroups(),\r\n                    lights: this._babylonLights,\r\n                    transformNodes: this._getTransformNodes(),\r\n                    geometries: this._getGeometries(),\r\n                    spriteManagers: [],\r\n                };\r\n            });\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public async loadAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName = \"\"): Promise<void> {\r\n        this._babylonScene = scene;\r\n        this._loadData(data);\r\n        return await this._loadAsync(rootUrl, fileName, null, () => undefined);\r\n    }\r\n\r\n    private async _loadAsync<T>(rootUrl: string, fileName: string, nodes: Nullable<Array<number>>, resultFunc: () => T): Promise<T> {\r\n        return await Promise.resolve()\r\n            .then(async () => {\r\n                this._rootUrl = rootUrl;\r\n                this._uniqueRootUrl = !rootUrl.startsWith(\"file:\") && fileName ? rootUrl : `${rootUrl}${Date.now()}/`;\r\n                this._fileName = fileName;\r\n                this._allMaterialsDirtyRequired = false;\r\n\r\n                await this._loadExtensionsAsync();\r\n\r\n                const loadingToReadyCounterName = `${GLTFLoaderState[GLTFLoaderState.LOADING]} => ${GLTFLoaderState[GLTFLoaderState.READY]}`;\r\n                const loadingToCompleteCounterName = `${GLTFLoaderState[GLTFLoaderState.LOADING]} => ${GLTFLoaderState[GLTFLoaderState.COMPLETE]}`;\r\n\r\n                this._parent._startPerformanceCounter(loadingToReadyCounterName);\r\n                this._parent._startPerformanceCounter(loadingToCompleteCounterName);\r\n\r\n                this._parent._setState(GLTFLoaderState.LOADING);\r\n                this._extensionsOnLoading();\r\n\r\n                const promises = new Array<Promise<unknown>>();\r\n\r\n                // Block the marking of materials dirty until the scene is loaded.\r\n                const oldBlockMaterialDirtyMechanism = this._babylonScene.blockMaterialDirtyMechanism;\r\n                this._babylonScene.blockMaterialDirtyMechanism = true;\r\n\r\n                if (!this.parent.loadOnlyMaterials) {\r\n                    if (nodes) {\r\n                        promises.push(this.loadSceneAsync(\"/nodes\", { nodes: nodes, index: -1 }));\r\n                    } else if (this._gltf.scene != undefined || (this._gltf.scenes && this._gltf.scenes[0])) {\r\n                        const scene = ArrayItem.Get(`/scene`, this._gltf.scenes, this._gltf.scene || 0);\r\n                        promises.push(this.loadSceneAsync(`/scenes/${scene.index}`, scene));\r\n                    }\r\n                }\r\n\r\n                if (!this.parent.skipMaterials && this.parent.loadAllMaterials && this._gltf.materials) {\r\n                    for (let m = 0; m < this._gltf.materials.length; ++m) {\r\n                        const material = this._gltf.materials[m];\r\n                        const context = \"/materials/\" + m;\r\n                        const babylonDrawMode = Material.TriangleFillMode;\r\n\r\n                        promises.push(this._loadMaterialAsync(context, material, null, babylonDrawMode, () => {}));\r\n                    }\r\n                }\r\n\r\n                // Restore the blocking of material dirty.\r\n                if (this._allMaterialsDirtyRequired) {\r\n                    // This can happen if we add a light for instance as it will impact the whole scene.\r\n                    // This automatically resets everything if needed.\r\n                    this._babylonScene.blockMaterialDirtyMechanism = oldBlockMaterialDirtyMechanism;\r\n                } else {\r\n                    // By default a newly created material is dirty so there is no need to flag the full scene as dirty.\r\n                    // For perf reasons, we then bypass blockMaterialDirtyMechanism as this would \"dirty\" the entire scene.\r\n                    this._babylonScene._forceBlockMaterialDirtyMechanism(oldBlockMaterialDirtyMechanism);\r\n                }\r\n\r\n                if (this._parent.compileMaterials) {\r\n                    promises.push(this._compileMaterialsAsync());\r\n                }\r\n\r\n                if (this._parent.compileShadowGenerators) {\r\n                    promises.push(this._compileShadowGeneratorsAsync());\r\n                }\r\n\r\n                const resultPromise = Promise.all(promises).then(() => {\r\n                    if (this._rootBabylonMesh && this._rootBabylonMesh !== this._parent.customRootNode) {\r\n                        this._rootBabylonMesh.setEnabled(true);\r\n                    }\r\n\r\n                    // Making sure we enable enough lights to have all lights together\r\n                    for (const material of this._babylonScene.materials) {\r\n                        const mat = material as any;\r\n\r\n                        if (mat.maxSimultaneousLights !== undefined) {\r\n                            mat.maxSimultaneousLights = Math.max(mat.maxSimultaneousLights, this._babylonScene.lights.length);\r\n                        }\r\n                    }\r\n\r\n                    this._extensionsOnReady();\r\n                    this._parent._setState(GLTFLoaderState.READY);\r\n                    if (!this._skipStartAnimationStep) {\r\n                        this._startAnimations();\r\n                    }\r\n\r\n                    return resultFunc();\r\n                });\r\n\r\n                return await resultPromise.then((result) => {\r\n                    this._parent._endPerformanceCounter(loadingToReadyCounterName);\r\n\r\n                    Tools.SetImmediate(() => {\r\n                        if (!this._disposed) {\r\n                            Promise.all(this._completePromises).then(\r\n                                () => {\r\n                                    this._parent._endPerformanceCounter(loadingToCompleteCounterName);\r\n\r\n                                    this._parent._setState(GLTFLoaderState.COMPLETE);\r\n\r\n                                    this._parent.onCompleteObservable.notifyObservers(undefined);\r\n                                    this._parent.onCompleteObservable.clear();\r\n\r\n                                    this.dispose();\r\n                                },\r\n                                (error) => {\r\n                                    this._parent.onErrorObservable.notifyObservers(error);\r\n                                    this._parent.onErrorObservable.clear();\r\n\r\n                                    this.dispose();\r\n                                }\r\n                            );\r\n                        }\r\n                    });\r\n\r\n                    return result;\r\n                });\r\n            })\r\n            .catch((error) => {\r\n                if (!this._disposed) {\r\n                    this._parent.onErrorObservable.notifyObservers(error);\r\n                    this._parent.onErrorObservable.clear();\r\n\r\n                    this.dispose();\r\n                }\r\n\r\n                throw error;\r\n            });\r\n    }\r\n\r\n    private _loadData(data: IGLTFLoaderData): void {\r\n        this._gltf = data.json as IGLTF;\r\n        this._setupData();\r\n\r\n        if (data.bin) {\r\n            const buffers = this._gltf.buffers;\r\n            if (buffers && buffers[0] && !buffers[0].uri) {\r\n                const binaryBuffer = buffers[0];\r\n                if (binaryBuffer.byteLength < data.bin.byteLength - 3 || binaryBuffer.byteLength > data.bin.byteLength) {\r\n                    Logger.Warn(`Binary buffer length (${binaryBuffer.byteLength}) from JSON does not match chunk length (${data.bin.byteLength})`);\r\n                }\r\n\r\n                this._bin = data.bin;\r\n            } else {\r\n                Logger.Warn(\"Unexpected BIN chunk\");\r\n            }\r\n        }\r\n    }\r\n\r\n    private _setupData(): void {\r\n        ArrayItem.Assign(this._gltf.accessors);\r\n        ArrayItem.Assign(this._gltf.animations);\r\n        ArrayItem.Assign(this._gltf.buffers);\r\n        ArrayItem.Assign(this._gltf.bufferViews);\r\n        ArrayItem.Assign(this._gltf.cameras);\r\n        ArrayItem.Assign(this._gltf.images);\r\n        ArrayItem.Assign(this._gltf.materials);\r\n        ArrayItem.Assign(this._gltf.meshes);\r\n        ArrayItem.Assign(this._gltf.nodes);\r\n        ArrayItem.Assign(this._gltf.samplers);\r\n        ArrayItem.Assign(this._gltf.scenes);\r\n        ArrayItem.Assign(this._gltf.skins);\r\n        ArrayItem.Assign(this._gltf.textures);\r\n\r\n        if (this._gltf.nodes) {\r\n            const nodeParents: { [index: number]: number } = {};\r\n            for (const node of this._gltf.nodes) {\r\n                if (node.children) {\r\n                    for (const index of node.children) {\r\n                        nodeParents[index] = node.index;\r\n                    }\r\n                }\r\n            }\r\n\r\n            const rootNode = this._createRootNode();\r\n            for (const node of this._gltf.nodes) {\r\n                const parentIndex = nodeParents[node.index];\r\n                node.parent = parentIndex === undefined ? rootNode : this._gltf.nodes[parentIndex];\r\n            }\r\n        }\r\n    }\r\n\r\n    private async _loadExtensionsAsync() {\r\n        const extensionPromises: Promise<IGLTFLoaderExtension>[] = [];\r\n\r\n        registeredGLTFExtensions.forEach((registeredExtension, name) => {\r\n            // Don't load explicitly disabled extensions.\r\n            if (this.parent.extensionOptions[name]?.enabled === false) {\r\n                // But warn if the disabled extension is used by the model.\r\n                if (registeredExtension.isGLTFExtension && this.isExtensionUsed(name)) {\r\n                    Logger.Warn(`Extension ${name} is used but has been explicitly disabled.`);\r\n                }\r\n            }\r\n            // Load loader extensions that are not a glTF extension, as well as extensions that are glTF extensions and are used by the model.\r\n            else if (!registeredExtension.isGLTFExtension || this.isExtensionUsed(name)) {\r\n                extensionPromises.push(\r\n                    (async () => {\r\n                        const extension = await registeredExtension.factory(this);\r\n                        if (extension.name !== name) {\r\n                            Logger.Warn(`The name of the glTF loader extension instance does not match the registered name: ${extension.name} !== ${name}`);\r\n                        }\r\n\r\n                        this._parent.onExtensionLoadedObservable.notifyObservers(extension);\r\n                        return extension;\r\n                    })()\r\n                );\r\n            }\r\n        });\r\n\r\n        this._extensions.push(...(await Promise.all(extensionPromises)));\r\n\r\n        this._extensions.sort((a, b) => (a.order || Number.MAX_VALUE) - (b.order || Number.MAX_VALUE));\r\n        this._parent.onExtensionLoadedObservable.clear();\r\n\r\n        if (this._gltf.extensionsRequired) {\r\n            for (const name of this._gltf.extensionsRequired) {\r\n                const available = this._extensions.some((extension) => extension.name === name && extension.enabled);\r\n                if (!available) {\r\n                    if (this.parent.extensionOptions[name]?.enabled === false) {\r\n                        throw new Error(`Required extension ${name} is disabled`);\r\n                    }\r\n                    throw new Error(`Required extension ${name} is not available`);\r\n                }\r\n            }\r\n        }\r\n    }\r\n\r\n    private _createRootNode(): INode {\r\n        if (this._parent.customRootNode !== undefined) {\r\n            this._rootBabylonMesh = this._parent.customRootNode;\r\n            return {\r\n                // eslint-disable-next-line @typescript-eslint/naming-convention\r\n                _babylonTransformNode: this._rootBabylonMesh === null ? undefined : this._rootBabylonMesh,\r\n                index: -1,\r\n            };\r\n        }\r\n        this._babylonScene._blockEntityCollection = !!this._assetContainer;\r\n        const rootMesh = new Mesh(\"__root__\", this._babylonScene);\r\n        this._rootBabylonMesh = rootMesh;\r\n        this._rootBabylonMesh._parentContainer = this._assetContainer;\r\n        this._babylonScene._blockEntityCollection = false;\r\n        this._rootBabylonMesh.setEnabled(false);\r\n\r\n        const rootNode: INode = {\r\n            // eslint-disable-next-line @typescript-eslint/naming-convention\r\n            _babylonTransformNode: this._rootBabylonMesh,\r\n            index: -1,\r\n        };\r\n\r\n        switch (this._parent.coordinateSystemMode) {\r\n            case GLTFLoaderCoordinateSystemMode.AUTO: {\r\n                if (!this._babylonScene.useRightHandedSystem) {\r\n                    rootNode.rotation = [0, 1, 0, 0];\r\n                    rootNode.scale = [1, 1, -1];\r\n                    GLTFLoader._LoadTransform(rootNode, this._rootBabylonMesh);\r\n                }\r\n                break;\r\n            }\r\n            case GLTFLoaderCoordinateSystemMode.FORCE_RIGHT_HANDED: {\r\n                this._babylonScene.useRightHandedSystem = true;\r\n                break;\r\n            }\r\n            default: {\r\n                throw new Error(`Invalid coordinate system mode (${this._parent.coordinateSystemMode})`);\r\n            }\r\n        }\r\n\r\n        this._parent.onMeshLoadedObservable.notifyObservers(rootMesh);\r\n        return rootNode;\r\n    }\r\n\r\n    /**\r\n     * Loads a glTF scene.\r\n     * @param context The context when loading the asset\r\n     * @param scene The glTF scene property\r\n     * @returns A promise that resolves when the load is complete\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax, @typescript-eslint/promise-function-async\r\n    public loadSceneAsync(context: string, scene: IScene): Promise<void> {\r\n        const extensionPromise = this._extensionsLoadSceneAsync(context, scene);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        this.logOpen(`${context} ${scene.name || \"\"}`);\r\n\r\n        if (scene.nodes) {\r\n            for (const index of scene.nodes) {\r\n                const node = ArrayItem.Get(`${context}/nodes/${index}`, this._gltf.nodes, index);\r\n                promises.push(\r\n                    this.loadNodeAsync(`/nodes/${node.index}`, node, (babylonMesh) => {\r\n                        babylonMesh.parent = this._rootBabylonMesh;\r\n                    })\r\n                );\r\n            }\r\n        }\r\n\r\n        for (const action of this._postSceneLoadActions) {\r\n            action();\r\n        }\r\n\r\n        promises.push(this._loadAnimationsAsync());\r\n\r\n        this.logClose();\r\n\r\n        return Promise.all(promises).then(() => {});\r\n    }\r\n\r\n    private _forEachPrimitive(node: INode, callback: (babylonMesh: AbstractMesh) => void): void {\r\n        if (node._primitiveBabylonMeshes) {\r\n            for (const babylonMesh of node._primitiveBabylonMeshes) {\r\n                callback(babylonMesh);\r\n            }\r\n        }\r\n    }\r\n\r\n    private _getGeometries(): Geometry[] {\r\n        const geometries: Geometry[] = [];\r\n\r\n        const nodes = this._gltf.nodes;\r\n        if (nodes) {\r\n            for (const node of nodes) {\r\n                this._forEachPrimitive(node, (babylonMesh) => {\r\n                    const geometry = (babylonMesh as Mesh).geometry;\r\n                    if (geometry && geometries.indexOf(geometry) === -1) {\r\n                        geometries.push(geometry);\r\n                    }\r\n                });\r\n            }\r\n        }\r\n\r\n        return geometries;\r\n    }\r\n\r\n    private _getMeshes(): AbstractMesh[] {\r\n        const meshes: AbstractMesh[] = [];\r\n\r\n        // Root mesh is always first, if available.\r\n        if (this._rootBabylonMesh instanceof AbstractMesh) {\r\n            meshes.push(this._rootBabylonMesh);\r\n        }\r\n\r\n        const nodes = this._gltf.nodes;\r\n        if (nodes) {\r\n            for (const node of nodes) {\r\n                this._forEachPrimitive(node, (babylonMesh) => {\r\n                    meshes.push(babylonMesh);\r\n                });\r\n            }\r\n        }\r\n\r\n        return meshes;\r\n    }\r\n\r\n    private _getTransformNodes(): TransformNode[] {\r\n        const transformNodes: TransformNode[] = [];\r\n\r\n        const nodes = this._gltf.nodes;\r\n        if (nodes) {\r\n            for (const node of nodes) {\r\n                if (node._babylonTransformNode && node._babylonTransformNode.getClassName() === \"TransformNode\") {\r\n                    transformNodes.push(node._babylonTransformNode);\r\n                }\r\n                if (node._babylonTransformNodeForSkin) {\r\n                    transformNodes.push(node._babylonTransformNodeForSkin);\r\n                }\r\n            }\r\n        }\r\n\r\n        return transformNodes;\r\n    }\r\n\r\n    private _getSkeletons(): Skeleton[] {\r\n        const skeletons: Skeleton[] = [];\r\n\r\n        const skins = this._gltf.skins;\r\n        if (skins) {\r\n            for (const skin of skins) {\r\n                if (skin._data) {\r\n                    skeletons.push(skin._data.babylonSkeleton);\r\n                }\r\n            }\r\n        }\r\n\r\n        return skeletons;\r\n    }\r\n\r\n    private _getAnimationGroups(): AnimationGroup[] {\r\n        const animationGroups: AnimationGroup[] = [];\r\n\r\n        const animations = this._gltf.animations;\r\n        if (animations) {\r\n            for (const animation of animations) {\r\n                if (animation._babylonAnimationGroup) {\r\n                    animationGroups.push(animation._babylonAnimationGroup);\r\n                }\r\n            }\r\n        }\r\n\r\n        return animationGroups;\r\n    }\r\n\r\n    private _startAnimations(): void {\r\n        switch (this._parent.animationStartMode) {\r\n            case GLTFLoaderAnimationStartMode.NONE: {\r\n                // do nothing\r\n                break;\r\n            }\r\n            case GLTFLoaderAnimationStartMode.FIRST: {\r\n                const babylonAnimationGroups = this._getAnimationGroups();\r\n                if (babylonAnimationGroups.length !== 0) {\r\n                    babylonAnimationGroups[0].start(true);\r\n                }\r\n                break;\r\n            }\r\n            case GLTFLoaderAnimationStartMode.ALL: {\r\n                const babylonAnimationGroups = this._getAnimationGroups();\r\n                for (const babylonAnimationGroup of babylonAnimationGroups) {\r\n                    babylonAnimationGroup.start(true);\r\n                }\r\n                break;\r\n            }\r\n            default: {\r\n                Logger.Error(`Invalid animation start mode (${this._parent.animationStartMode})`);\r\n                return;\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Loads a glTF node.\r\n     * @param context The context when loading the asset\r\n     * @param node The glTF node property\r\n     * @param assign A function called synchronously after parsing the glTF properties\r\n     * @returns A promise that resolves with the loaded Babylon mesh when the load is complete\r\n     */\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    public loadNodeAsync(context: string, node: INode, assign: (babylonTransformNode: TransformNode) => void = () => {}): Promise<TransformNode> {\r\n        const extensionPromise = this._extensionsLoadNodeAsync(context, node, assign);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        if (node._babylonTransformNode) {\r\n            throw new Error(`${context}: Invalid recursive node hierarchy`);\r\n        }\r\n\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        this.logOpen(`${context} ${node.name || \"\"}`);\r\n\r\n        const loadNode = (babylonTransformNode: TransformNode) => {\r\n            GLTFLoader.AddPointerMetadata(babylonTransformNode, context);\r\n            GLTFLoader._LoadTransform(node, babylonTransformNode);\r\n\r\n            if (node.camera != undefined) {\r\n                const camera = ArrayItem.Get(`${context}/camera`, this._gltf.cameras, node.camera);\r\n                promises.push(\r\n                    this.loadCameraAsync(`/cameras/${camera.index}`, camera, (babylonCamera) => {\r\n                        babylonCamera.parent = babylonTransformNode;\r\n                        if (!this._babylonScene.useRightHandedSystem) {\r\n                            babylonTransformNode.scaling.x = -1; // Cancelling root node scaling for handedness so the view matrix does not end up flipped.\r\n                        }\r\n                    })\r\n                );\r\n            }\r\n\r\n            if (node.children) {\r\n                for (const index of node.children) {\r\n                    const childNode = ArrayItem.Get(`${context}/children/${index}`, this._gltf.nodes, index);\r\n                    promises.push(\r\n                        this.loadNodeAsync(`/nodes/${childNode.index}`, childNode, (childBabylonMesh) => {\r\n                            childBabylonMesh.parent = babylonTransformNode;\r\n                        })\r\n                    );\r\n                }\r\n            }\r\n\r\n            assign(babylonTransformNode);\r\n        };\r\n\r\n        const hasMesh = node.mesh != undefined;\r\n        const hasSkin = this._parent.loadSkins && node.skin != undefined;\r\n\r\n        if (!hasMesh || hasSkin) {\r\n            const nodeName = node.name || `node${node.index}`;\r\n            this._babylonScene._blockEntityCollection = !!this._assetContainer;\r\n            const transformNode = new TransformNode(nodeName, this._babylonScene);\r\n            transformNode._parentContainer = this._assetContainer;\r\n            this._babylonScene._blockEntityCollection = false;\r\n            if (node.mesh == undefined) {\r\n                node._babylonTransformNode = transformNode;\r\n            } else {\r\n                node._babylonTransformNodeForSkin = transformNode;\r\n            }\r\n            loadNode(transformNode);\r\n        }\r\n\r\n        if (hasMesh) {\r\n            if (hasSkin) {\r\n                // See https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins (second implementation note)\r\n                // This code path will place the skinned mesh as a sibling of the skeleton root node without loading the\r\n                // transform, which effectively ignores the transform of the skinned mesh, as per spec.\r\n\r\n                const mesh = ArrayItem.Get(`${context}/mesh`, this._gltf.meshes, node.mesh);\r\n                promises.push(\r\n                    this._loadMeshAsync(`/meshes/${mesh.index}`, node, mesh, (babylonTransformNode) => {\r\n                        const babylonTransformNodeForSkin = node._babylonTransformNodeForSkin!;\r\n\r\n                        // Merge the metadata from the skin node to the skinned mesh in case a loader extension added metadata.\r\n                        babylonTransformNode.metadata = deepMerge(babylonTransformNodeForSkin.metadata, babylonTransformNode.metadata || {});\r\n\r\n                        const skin = ArrayItem.Get(`${context}/skin`, this._gltf.skins, node.skin);\r\n                        promises.push(\r\n                            this._loadSkinAsync(`/skins/${skin.index}`, node, skin, (babylonSkeleton) => {\r\n                                this._forEachPrimitive(node, (babylonMesh) => {\r\n                                    babylonMesh.skeleton = babylonSkeleton;\r\n                                });\r\n\r\n                                // Wait until all the nodes are parented before parenting the skinned mesh.\r\n                                this._postSceneLoadActions.push(() => {\r\n                                    if (skin.skeleton != undefined) {\r\n                                        // Place the skinned mesh node as a sibling of the skeleton root node.\r\n                                        // Handle special case when the parent of the skeleton root is the skinned mesh.\r\n                                        const parentNode = ArrayItem.Get(`/skins/${skin.index}/skeleton`, this._gltf.nodes, skin.skeleton).parent!;\r\n                                        if (node.index === parentNode.index) {\r\n                                            babylonTransformNode.parent = babylonTransformNodeForSkin.parent;\r\n                                        } else {\r\n                                            babylonTransformNode.parent = parentNode._babylonTransformNode!;\r\n                                        }\r\n                                    } else {\r\n                                        babylonTransformNode.parent = this._rootBabylonMesh;\r\n                                    }\r\n\r\n                                    this._parent.onSkinLoadedObservable.notifyObservers({ node: babylonTransformNodeForSkin, skinnedNode: babylonTransformNode });\r\n                                });\r\n                            })\r\n                        );\r\n                    })\r\n                );\r\n            } else {\r\n                const mesh = ArrayItem.Get(`${context}/mesh`, this._gltf.meshes, node.mesh);\r\n                promises.push(this._loadMeshAsync(`/meshes/${mesh.index}`, node, mesh, loadNode));\r\n            }\r\n        }\r\n\r\n        this.logClose();\r\n\r\n        return Promise.all(promises).then(() => {\r\n            this._forEachPrimitive(node, (babylonMesh) => {\r\n                const asMesh = babylonMesh as Mesh;\r\n                if (!asMesh.isAnInstance && asMesh.geometry && asMesh.geometry.useBoundingInfoFromGeometry) {\r\n                    // simply apply the world matrices to the bounding info - the extends are already ok\r\n                    babylonMesh._updateBoundingInfo();\r\n                } else {\r\n                    babylonMesh.refreshBoundingInfo(true, true);\r\n                }\r\n            });\r\n\r\n            return node._babylonTransformNode!;\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadMeshAsync(context: string, node: INode, mesh: IMesh, assign: (babylonTransformNode: TransformNode) => void): Promise<TransformNode> {\r\n        const primitives = mesh.primitives;\r\n        if (!primitives || !primitives.length) {\r\n            throw new Error(`${context}: Primitives are missing`);\r\n        }\r\n\r\n        if (primitives[0].index == undefined) {\r\n            ArrayItem.Assign(primitives);\r\n        }\r\n\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        this.logOpen(`${context} ${mesh.name || \"\"}`);\r\n\r\n        const name = node.name || `node${node.index}`;\r\n\r\n        if (primitives.length === 1) {\r\n            const primitive = mesh.primitives[0];\r\n            promises.push(\r\n                this._loadMeshPrimitiveAsync(`${context}/primitives/${primitive.index}`, name, node, mesh, primitive, (babylonMesh) => {\r\n                    node._babylonTransformNode = babylonMesh;\r\n                    node._primitiveBabylonMeshes = [babylonMesh];\r\n                })\r\n            );\r\n        } else {\r\n            this._babylonScene._blockEntityCollection = !!this._assetContainer;\r\n            node._babylonTransformNode = new TransformNode(name, this._babylonScene);\r\n            node._babylonTransformNode._parentContainer = this._assetContainer;\r\n            this._babylonScene._blockEntityCollection = false;\r\n            node._primitiveBabylonMeshes = [];\r\n            for (const primitive of primitives) {\r\n                promises.push(\r\n                    this._loadMeshPrimitiveAsync(`${context}/primitives/${primitive.index}`, `${name}_primitive${primitive.index}`, node, mesh, primitive, (babylonMesh) => {\r\n                        babylonMesh.parent = node._babylonTransformNode!;\r\n                        node._primitiveBabylonMeshes!.push(babylonMesh);\r\n                    })\r\n                );\r\n            }\r\n        }\r\n\r\n        assign(node._babylonTransformNode!);\r\n\r\n        this.logClose();\r\n\r\n        return Promise.all(promises).then(() => {\r\n            return node._babylonTransformNode!;\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @internal Define this method to modify the default behavior when loading data for mesh primitives.\r\n     * @param context The context when loading the asset\r\n     * @param name The mesh name when loading the asset\r\n     * @param node The glTF node when loading the asset\r\n     * @param mesh The glTF mesh when loading the asset\r\n     * @param primitive The glTF mesh primitive property\r\n     * @param assign A function called synchronously after parsing the glTF properties\r\n     * @returns A promise that resolves with the loaded mesh when the load is complete or null if not handled\r\n     */\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    public _loadMeshPrimitiveAsync(\r\n        context: string,\r\n        name: string,\r\n        node: INode,\r\n        mesh: IMesh,\r\n        primitive: IMeshPrimitive,\r\n        assign: (babylonMesh: AbstractMesh) => void\r\n    ): Promise<AbstractMesh> {\r\n        const extensionPromise = this._extensionsLoadMeshPrimitiveAsync(context, name, node, mesh, primitive, assign);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        this.logOpen(`${context}`);\r\n\r\n        const shouldInstance = this._disableInstancedMesh === 0 && this._parent.createInstances && node.skin == undefined && !mesh.primitives[0].targets;\r\n\r\n        let babylonAbstractMesh: AbstractMesh;\r\n        let promise: Promise<unknown>;\r\n\r\n        if (shouldInstance && primitive._instanceData) {\r\n            this._babylonScene._blockEntityCollection = !!this._assetContainer;\r\n            babylonAbstractMesh = primitive._instanceData.babylonSourceMesh.createInstance(name);\r\n            babylonAbstractMesh._parentContainer = this._assetContainer;\r\n            this._babylonScene._blockEntityCollection = false;\r\n            promise = primitive._instanceData.promise;\r\n        } else {\r\n            const promises = new Array<Promise<unknown>>();\r\n\r\n            this._babylonScene._blockEntityCollection = !!this._assetContainer;\r\n            const babylonMesh = new Mesh(name, this._babylonScene);\r\n            babylonMesh._parentContainer = this._assetContainer;\r\n            this._babylonScene._blockEntityCollection = false;\r\n            babylonMesh.sideOrientation = this._babylonScene.useRightHandedSystem ? Material.CounterClockWiseSideOrientation : Material.ClockWiseSideOrientation;\r\n\r\n            this._createMorphTargets(context, node, mesh, primitive, babylonMesh);\r\n            promises.push(\r\n                this._loadVertexDataAsync(context, primitive, babylonMesh).then(async (babylonGeometry) => {\r\n                    return await this._loadMorphTargetsAsync(context, primitive, babylonMesh, babylonGeometry).then(() => {\r\n                        if (this._disposed) {\r\n                            return;\r\n                        }\r\n\r\n                        this._babylonScene._blockEntityCollection = !!this._assetContainer;\r\n                        babylonGeometry.applyToMesh(babylonMesh);\r\n                        babylonGeometry._parentContainer = this._assetContainer;\r\n                        this._babylonScene._blockEntityCollection = false;\r\n                    });\r\n                })\r\n            );\r\n\r\n            const babylonDrawMode = GLTFLoader._GetDrawMode(context, primitive.mode);\r\n            if (primitive.material == undefined) {\r\n                let babylonMaterial = this._defaultBabylonMaterialData[babylonDrawMode];\r\n                if (!babylonMaterial) {\r\n                    babylonMaterial = this._createDefaultMaterial(\"__GLTFLoader._default\", babylonDrawMode);\r\n                    this._parent.onMaterialLoadedObservable.notifyObservers(babylonMaterial);\r\n                    this._defaultBabylonMaterialData[babylonDrawMode] = babylonMaterial;\r\n                }\r\n                babylonMesh.material = babylonMaterial;\r\n            } else if (!this.parent.skipMaterials) {\r\n                const material = ArrayItem.Get(`${context}/material`, this._gltf.materials, primitive.material);\r\n                promises.push(\r\n                    this._loadMaterialAsync(`/materials/${material.index}`, material, babylonMesh, babylonDrawMode, (babylonMaterial) => {\r\n                        babylonMesh.material = babylonMaterial;\r\n                    })\r\n                );\r\n            }\r\n\r\n            promise = Promise.all(promises);\r\n\r\n            if (shouldInstance) {\r\n                primitive._instanceData = {\r\n                    babylonSourceMesh: babylonMesh,\r\n                    promise: promise,\r\n                };\r\n            }\r\n\r\n            babylonAbstractMesh = babylonMesh;\r\n        }\r\n\r\n        GLTFLoader.AddPointerMetadata(babylonAbstractMesh, context);\r\n        this._parent.onMeshLoadedObservable.notifyObservers(babylonAbstractMesh);\r\n        assign(babylonAbstractMesh);\r\n\r\n        this.logClose();\r\n\r\n        return promise.then(() => {\r\n            return babylonAbstractMesh;\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadVertexDataAsync(context: string, primitive: IMeshPrimitive, babylonMesh: Mesh): Promise<Geometry> {\r\n        const extensionPromise = this._extensionsLoadVertexDataAsync(context, primitive, babylonMesh);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        const attributes = primitive.attributes;\r\n        if (!attributes) {\r\n            throw new Error(`${context}: Attributes are missing`);\r\n        }\r\n\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        const babylonGeometry = new Geometry(babylonMesh.name, this._babylonScene);\r\n\r\n        if (primitive.indices == undefined) {\r\n            babylonMesh.isUnIndexed = true;\r\n        } else {\r\n            const accessor = ArrayItem.Get(`${context}/indices`, this._gltf.accessors, primitive.indices);\r\n            promises.push(\r\n                this._loadIndicesAccessorAsync(`/accessors/${accessor.index}`, accessor).then((data) => {\r\n                    babylonGeometry.setIndices(data);\r\n                })\r\n            );\r\n        }\r\n\r\n        const loadAttribute = (name: string, kind: string, callback?: (accessor: IAccessor) => void) => {\r\n            if (attributes[name] == undefined) {\r\n                return;\r\n            }\r\n\r\n            babylonMesh._delayInfo = babylonMesh._delayInfo || [];\r\n            if (babylonMesh._delayInfo.indexOf(kind) === -1) {\r\n                babylonMesh._delayInfo.push(kind);\r\n            }\r\n\r\n            const accessor = ArrayItem.Get(`${context}/attributes/${name}`, this._gltf.accessors, attributes[name]);\r\n            promises.push(\r\n                this._loadVertexAccessorAsync(`/accessors/${accessor.index}`, accessor, kind).then((babylonVertexBuffer) => {\r\n                    if (babylonVertexBuffer.getKind() === VertexBuffer.PositionKind && !this.parent.alwaysComputeBoundingBox && !babylonMesh.skeleton) {\r\n                        const babylonBoundingInfo = LoadBoundingInfoFromPositionAccessor(accessor);\r\n                        if (babylonBoundingInfo) {\r\n                            babylonGeometry._boundingInfo = babylonBoundingInfo;\r\n                            babylonGeometry.useBoundingInfoFromGeometry = true;\r\n                        }\r\n                    }\r\n                    babylonGeometry.setVerticesBuffer(babylonVertexBuffer, accessor.count);\r\n                })\r\n            );\r\n\r\n            if (kind == VertexBuffer.MatricesIndicesExtraKind) {\r\n                babylonMesh.numBoneInfluencers = 8;\r\n            }\r\n\r\n            if (callback) {\r\n                callback(accessor);\r\n            }\r\n        };\r\n\r\n        loadAttribute(\"POSITION\", VertexBuffer.PositionKind);\r\n        loadAttribute(\"NORMAL\", VertexBuffer.NormalKind);\r\n        loadAttribute(\"TANGENT\", VertexBuffer.TangentKind);\r\n        loadAttribute(\"TEXCOORD_0\", VertexBuffer.UVKind);\r\n        loadAttribute(\"TEXCOORD_1\", VertexBuffer.UV2Kind);\r\n        loadAttribute(\"TEXCOORD_2\", VertexBuffer.UV3Kind);\r\n        loadAttribute(\"TEXCOORD_3\", VertexBuffer.UV4Kind);\r\n        loadAttribute(\"TEXCOORD_4\", VertexBuffer.UV5Kind);\r\n        loadAttribute(\"TEXCOORD_5\", VertexBuffer.UV6Kind);\r\n        loadAttribute(\"JOINTS_0\", VertexBuffer.MatricesIndicesKind);\r\n        loadAttribute(\"WEIGHTS_0\", VertexBuffer.MatricesWeightsKind);\r\n        loadAttribute(\"JOINTS_1\", VertexBuffer.MatricesIndicesExtraKind);\r\n        loadAttribute(\"WEIGHTS_1\", VertexBuffer.MatricesWeightsExtraKind);\r\n        loadAttribute(\"COLOR_0\", VertexBuffer.ColorKind, (accessor) => {\r\n            if (accessor.type === AccessorType.VEC4) {\r\n                babylonMesh.hasVertexAlpha = true;\r\n            }\r\n        });\r\n\r\n        return Promise.all(promises).then(() => {\r\n            return babylonGeometry;\r\n        });\r\n    }\r\n\r\n    private _createMorphTargets(context: string, node: INode, mesh: IMesh, primitive: IMeshPrimitive, babylonMesh: Mesh): void {\r\n        if (!primitive.targets || !this._parent.loadMorphTargets) {\r\n            return;\r\n        }\r\n\r\n        if (node._numMorphTargets == undefined) {\r\n            node._numMorphTargets = primitive.targets.length;\r\n        } else if (primitive.targets.length !== node._numMorphTargets) {\r\n            throw new Error(`${context}: Primitives do not have the same number of targets`);\r\n        }\r\n\r\n        const targetNames = mesh.extras ? mesh.extras.targetNames : null;\r\n\r\n        this._babylonScene._blockEntityCollection = !!this._assetContainer;\r\n        babylonMesh.morphTargetManager = new MorphTargetManager(this._babylonScene);\r\n        babylonMesh.morphTargetManager._parentContainer = this._assetContainer;\r\n        this._babylonScene._blockEntityCollection = false;\r\n\r\n        babylonMesh.morphTargetManager.areUpdatesFrozen = true;\r\n\r\n        for (let index = 0; index < primitive.targets.length; index++) {\r\n            const weight = node.weights ? node.weights[index] : mesh.weights ? mesh.weights[index] : 0;\r\n            const name = targetNames ? targetNames[index] : `morphTarget${index}`;\r\n            babylonMesh.morphTargetManager.addTarget(new MorphTarget(name, weight, babylonMesh.getScene()));\r\n            // TODO: tell the target whether it has positions, normals, tangents\r\n        }\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadMorphTargetsAsync(context: string, primitive: IMeshPrimitive, babylonMesh: Mesh, babylonGeometry: Geometry): Promise<void> {\r\n        if (!primitive.targets || !this._parent.loadMorphTargets) {\r\n            return Promise.resolve();\r\n        }\r\n\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        const morphTargetManager = babylonMesh.morphTargetManager!;\r\n        for (let index = 0; index < morphTargetManager.numTargets; index++) {\r\n            const babylonMorphTarget = morphTargetManager.getTarget(index);\r\n            promises.push(this._loadMorphTargetVertexDataAsync(`${context}/targets/${index}`, babylonGeometry, primitive.targets[index], babylonMorphTarget));\r\n        }\r\n\r\n        return Promise.all(promises).then(() => {\r\n            morphTargetManager.areUpdatesFrozen = false;\r\n        });\r\n    }\r\n\r\n    private async _loadMorphTargetVertexDataAsync(\r\n        context: string,\r\n        babylonGeometry: Geometry,\r\n        attributes: { [name: string]: number },\r\n        babylonMorphTarget: MorphTarget\r\n    ): Promise<void> {\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        const loadAttribute = (attribute: string, kind: string, setData: (babylonVertexBuffer: VertexBuffer, data: Float32Array) => void) => {\r\n            if (attributes[attribute] == undefined) {\r\n                return;\r\n            }\r\n\r\n            const babylonVertexBuffer = babylonGeometry.getVertexBuffer(kind);\r\n            if (!babylonVertexBuffer) {\r\n                return;\r\n            }\r\n\r\n            const accessor = ArrayItem.Get(`${context}/${attribute}`, this._gltf.accessors, attributes[attribute]);\r\n            promises.push(\r\n                this._loadFloatAccessorAsync(`/accessors/${accessor.index}`, accessor).then((data) => {\r\n                    setData(babylonVertexBuffer, data);\r\n                })\r\n            );\r\n        };\r\n\r\n        loadAttribute(\"POSITION\", VertexBuffer.PositionKind, (babylonVertexBuffer, data) => {\r\n            const positions = new Float32Array(data.length);\r\n            babylonVertexBuffer.forEach(data.length, (value, index) => {\r\n                positions[index] = data[index] + value;\r\n            });\r\n\r\n            babylonMorphTarget.setPositions(positions);\r\n        });\r\n\r\n        loadAttribute(\"NORMAL\", VertexBuffer.NormalKind, (babylonVertexBuffer, data) => {\r\n            const normals = new Float32Array(data.length);\r\n            babylonVertexBuffer.forEach(normals.length, (value, index) => {\r\n                normals[index] = data[index] + value;\r\n            });\r\n\r\n            babylonMorphTarget.setNormals(normals);\r\n        });\r\n\r\n        loadAttribute(\"TANGENT\", VertexBuffer.TangentKind, (babylonVertexBuffer, data) => {\r\n            const tangents = new Float32Array((data.length / 3) * 4);\r\n            let dataIndex = 0;\r\n            babylonVertexBuffer.forEach((data.length / 3) * 4, (value, index) => {\r\n                // Tangent data for morph targets is stored as xyz delta.\r\n                // The vertexData.tangent is stored as xyzw.\r\n                // So we need to skip every fourth vertexData.tangent.\r\n                if ((index + 1) % 4 !== 0) {\r\n                    tangents[dataIndex] = data[dataIndex] + value;\r\n                    dataIndex++;\r\n                }\r\n            });\r\n            babylonMorphTarget.setTangents(tangents);\r\n        });\r\n\r\n        loadAttribute(\"TEXCOORD_0\", VertexBuffer.UVKind, (babylonVertexBuffer, data) => {\r\n            const uvs = new Float32Array(data.length);\r\n            babylonVertexBuffer.forEach(data.length, (value, index) => {\r\n                uvs[index] = data[index] + value;\r\n            });\r\n\r\n            babylonMorphTarget.setUVs(uvs);\r\n        });\r\n\r\n        loadAttribute(\"TEXCOORD_1\", VertexBuffer.UV2Kind, (babylonVertexBuffer, data) => {\r\n            const uvs = new Float32Array(data.length);\r\n            babylonVertexBuffer.forEach(data.length, (value, index) => {\r\n                uvs[index] = data[index] + value;\r\n            });\r\n\r\n            babylonMorphTarget.setUV2s(uvs);\r\n        });\r\n\r\n        loadAttribute(\"COLOR_0\", VertexBuffer.ColorKind, (babylonVertexBuffer, data) => {\r\n            let colors = null;\r\n            const componentSize = babylonVertexBuffer.getSize();\r\n            if (componentSize === 3) {\r\n                colors = new Float32Array((data.length / 3) * 4);\r\n                babylonVertexBuffer.forEach(data.length, (value, index) => {\r\n                    const pixid = Math.floor(index / 3);\r\n                    const channel = index % 3;\r\n                    colors[4 * pixid + channel] = data[3 * pixid + channel] + value;\r\n                });\r\n                for (let i = 0; i < data.length / 3; ++i) {\r\n                    colors[4 * i + 3] = 1;\r\n                }\r\n            } else if (componentSize === 4) {\r\n                colors = new Float32Array(data.length);\r\n                babylonVertexBuffer.forEach(data.length, (value, index) => {\r\n                    colors[index] = data[index] + value;\r\n                });\r\n            } else {\r\n                throw new Error(`${context}: Invalid number of components (${componentSize}) for COLOR_0 attribute`);\r\n            }\r\n            babylonMorphTarget.setColors(colors);\r\n        });\r\n\r\n        return await Promise.all(promises).then(() => {});\r\n    }\r\n\r\n    private static _LoadTransform(node: INode, babylonNode: TransformNode): void {\r\n        // Ignore the TRS of skinned nodes.\r\n        // See https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins (second implementation note)\r\n        if (node.skin != undefined) {\r\n            return;\r\n        }\r\n\r\n        let position = Vector3.Zero();\r\n        let rotation = Quaternion.Identity();\r\n        let scaling = Vector3.One();\r\n\r\n        if (node.matrix) {\r\n            const matrix = Matrix.FromArray(node.matrix);\r\n            matrix.decompose(scaling, rotation, position);\r\n        } else {\r\n            if (node.translation) {\r\n                position = Vector3.FromArray(node.translation);\r\n            }\r\n            if (node.rotation) {\r\n                rotation = Quaternion.FromArray(node.rotation);\r\n            }\r\n            if (node.scale) {\r\n                scaling = Vector3.FromArray(node.scale);\r\n            }\r\n        }\r\n\r\n        babylonNode.position = position;\r\n        babylonNode.rotationQuaternion = rotation;\r\n        babylonNode.scaling = scaling;\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadSkinAsync(context: string, node: INode, skin: ISkin, assign: (babylonSkeleton: Skeleton) => void): Promise<void> {\r\n        if (!this._parent.loadSkins) {\r\n            return Promise.resolve();\r\n        }\r\n\r\n        const extensionPromise = this._extensionsLoadSkinAsync(context, node, skin);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        if (skin._data) {\r\n            assign(skin._data.babylonSkeleton);\r\n            return skin._data.promise;\r\n        }\r\n\r\n        const skeletonId = `skeleton${skin.index}`;\r\n        this._babylonScene._blockEntityCollection = !!this._assetContainer;\r\n        const babylonSkeleton = new Skeleton(skin.name || skeletonId, skeletonId, this._babylonScene);\r\n        babylonSkeleton._parentContainer = this._assetContainer;\r\n        this._babylonScene._blockEntityCollection = false;\r\n\r\n        this._loadBones(context, skin, babylonSkeleton);\r\n        const promise = this._loadSkinInverseBindMatricesDataAsync(context, skin).then((inverseBindMatricesData) => {\r\n            this._updateBoneMatrices(babylonSkeleton, inverseBindMatricesData);\r\n        });\r\n\r\n        skin._data = {\r\n            babylonSkeleton: babylonSkeleton,\r\n            promise: promise,\r\n        };\r\n\r\n        assign(babylonSkeleton);\r\n\r\n        return promise;\r\n    }\r\n\r\n    private _loadBones(context: string, skin: ISkin, babylonSkeleton: Skeleton): void {\r\n        if (skin.skeleton == undefined || this._parent.alwaysComputeSkeletonRootNode) {\r\n            const rootNode = this._findSkeletonRootNode(`${context}/joints`, skin.joints);\r\n            if (rootNode) {\r\n                if (skin.skeleton === undefined) {\r\n                    skin.skeleton = rootNode.index;\r\n                } else {\r\n                    const isParent = (a: INode, b: INode): boolean => {\r\n                        for (; b.parent; b = b.parent) {\r\n                            if (b.parent === a) {\r\n                                return true;\r\n                            }\r\n                        }\r\n\r\n                        return false;\r\n                    };\r\n\r\n                    const skeletonNode = ArrayItem.Get(`${context}/skeleton`, this._gltf.nodes, skin.skeleton);\r\n                    if (skeletonNode !== rootNode && !isParent(skeletonNode, rootNode)) {\r\n                        Logger.Warn(`${context}/skeleton: Overriding with nearest common ancestor as skeleton node is not a common root`);\r\n                        skin.skeleton = rootNode.index;\r\n                    }\r\n                }\r\n            } else {\r\n                Logger.Warn(`${context}: Failed to find common root`);\r\n            }\r\n        }\r\n\r\n        const babylonBones: { [index: number]: Bone } = {};\r\n        for (const index of skin.joints) {\r\n            const node = ArrayItem.Get(`${context}/joints/${index}`, this._gltf.nodes, index);\r\n            this._loadBone(node, skin, babylonSkeleton, babylonBones);\r\n        }\r\n    }\r\n\r\n    private _findSkeletonRootNode(context: string, joints: Array<number>): Nullable<INode> {\r\n        if (joints.length === 0) {\r\n            return null;\r\n        }\r\n\r\n        const paths: { [joint: number]: Array<INode> } = {};\r\n        for (const index of joints) {\r\n            const path: INode[] = [];\r\n            let node = ArrayItem.Get(`${context}/${index}`, this._gltf.nodes, index);\r\n            while (node.index !== -1) {\r\n                path.unshift(node);\r\n                node = node.parent!;\r\n            }\r\n            paths[index] = path;\r\n        }\r\n\r\n        let rootNode: Nullable<INode> = null;\r\n        for (let i = 0; ; ++i) {\r\n            let path = paths[joints[0]];\r\n            if (i >= path.length) {\r\n                return rootNode;\r\n            }\r\n\r\n            const node = path[i];\r\n            for (let j = 1; j < joints.length; ++j) {\r\n                path = paths[joints[j]];\r\n                if (i >= path.length || node !== path[i]) {\r\n                    return rootNode;\r\n                }\r\n            }\r\n\r\n            rootNode = node;\r\n        }\r\n    }\r\n\r\n    private _loadBone(node: INode, skin: ISkin, babylonSkeleton: Skeleton, babylonBones: { [index: number]: Bone }): Bone {\r\n        node._isJoint = true;\r\n\r\n        let babylonBone = babylonBones[node.index];\r\n        if (babylonBone) {\r\n            return babylonBone;\r\n        }\r\n\r\n        let parentBabylonBone: Nullable<Bone> = null;\r\n        if (node.index !== skin.skeleton) {\r\n            if (node.parent && node.parent.index !== -1) {\r\n                parentBabylonBone = this._loadBone(node.parent, skin, babylonSkeleton, babylonBones);\r\n            } else if (skin.skeleton !== undefined) {\r\n                Logger.Warn(`/skins/${skin.index}/skeleton: Skeleton node is not a common root`);\r\n            }\r\n        }\r\n\r\n        const boneIndex = skin.joints.indexOf(node.index);\r\n        babylonBone = new Bone(node.name || `joint${node.index}`, babylonSkeleton, parentBabylonBone, this._getNodeMatrix(node), null, null, boneIndex);\r\n        babylonBones[node.index] = babylonBone;\r\n\r\n        // Wait until the scene is loaded to ensure the transform nodes are loaded.\r\n        this._postSceneLoadActions.push(() => {\r\n            // Link the Babylon bone with the corresponding Babylon transform node.\r\n            // A glTF joint is a pointer to a glTF node in the glTF node hierarchy similar to Unity3D.\r\n            babylonBone.linkTransformNode(node._babylonTransformNode!);\r\n        });\r\n\r\n        return babylonBone;\r\n    }\r\n\r\n    private _loadSkinInverseBindMatricesDataAsync(context: string, skin: ISkin): Promise<Nullable<Float32Array>> {\r\n        if (skin.inverseBindMatrices == undefined) {\r\n            return Promise.resolve(null);\r\n        }\r\n\r\n        const accessor = ArrayItem.Get(`${context}/inverseBindMatrices`, this._gltf.accessors, skin.inverseBindMatrices);\r\n        return this._loadFloatAccessorAsync(`/accessors/${accessor.index}`, accessor);\r\n    }\r\n\r\n    private _updateBoneMatrices(babylonSkeleton: Skeleton, inverseBindMatricesData: Nullable<Float32Array>): void {\r\n        for (const babylonBone of babylonSkeleton.bones) {\r\n            const baseMatrix = Matrix.Identity();\r\n            const boneIndex = babylonBone._index!;\r\n            if (inverseBindMatricesData && boneIndex !== -1) {\r\n                Matrix.FromArrayToRef(inverseBindMatricesData, boneIndex * 16, baseMatrix);\r\n                baseMatrix.invertToRef(baseMatrix);\r\n            }\r\n\r\n            const babylonParentBone = babylonBone.getParent();\r\n            if (babylonParentBone) {\r\n                baseMatrix.multiplyToRef(babylonParentBone.getAbsoluteInverseBindMatrix(), baseMatrix);\r\n            }\r\n\r\n            babylonBone.updateMatrix(baseMatrix, false, false);\r\n            babylonBone._updateAbsoluteBindMatrices(undefined, false);\r\n        }\r\n    }\r\n\r\n    private _getNodeMatrix(node: INode): Matrix {\r\n        return node.matrix\r\n            ? Matrix.FromArray(node.matrix)\r\n            : Matrix.Compose(\r\n                  node.scale ? Vector3.FromArray(node.scale) : Vector3.One(),\r\n                  node.rotation ? Quaternion.FromArray(node.rotation) : Quaternion.Identity(),\r\n                  node.translation ? Vector3.FromArray(node.translation) : Vector3.Zero()\r\n              );\r\n    }\r\n\r\n    /**\r\n     * Loads a glTF camera.\r\n     * @param context The context when loading the asset\r\n     * @param camera The glTF camera property\r\n     * @param assign A function called synchronously after parsing the glTF properties\r\n     * @returns A promise that resolves with the loaded Babylon camera when the load is complete\r\n     */\r\n    public loadCameraAsync(context: string, camera: ICamera, assign: (babylonCamera: Camera) => void = () => {}): Promise<Camera> {\r\n        const extensionPromise = this._extensionsLoadCameraAsync(context, camera, assign);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        this.logOpen(`${context} ${camera.name || \"\"}`);\r\n\r\n        this._babylonScene._blockEntityCollection = !!this._assetContainer;\r\n        const babylonCamera = new FreeCamera(camera.name || `camera${camera.index}`, Vector3.Zero(), this._babylonScene, false);\r\n        babylonCamera._parentContainer = this._assetContainer;\r\n        this._babylonScene._blockEntityCollection = false;\r\n        camera._babylonCamera = babylonCamera;\r\n\r\n        // glTF cameras look towards the local -Z axis.\r\n        babylonCamera.setTarget(new Vector3(0, 0, -1));\r\n\r\n        switch (camera.type) {\r\n            case CameraType.PERSPECTIVE: {\r\n                const perspective = camera.perspective;\r\n                if (!perspective) {\r\n                    throw new Error(`${context}: Camera perspective properties are missing`);\r\n                }\r\n\r\n                babylonCamera.fov = perspective.yfov;\r\n                babylonCamera.minZ = perspective.znear;\r\n                babylonCamera.maxZ = perspective.zfar || 0;\r\n                break;\r\n            }\r\n            case CameraType.ORTHOGRAPHIC: {\r\n                if (!camera.orthographic) {\r\n                    throw new Error(`${context}: Camera orthographic properties are missing`);\r\n                }\r\n\r\n                babylonCamera.mode = Camera.ORTHOGRAPHIC_CAMERA;\r\n                babylonCamera.orthoLeft = -camera.orthographic.xmag;\r\n                babylonCamera.orthoRight = camera.orthographic.xmag;\r\n                babylonCamera.orthoBottom = -camera.orthographic.ymag;\r\n                babylonCamera.orthoTop = camera.orthographic.ymag;\r\n                babylonCamera.minZ = camera.orthographic.znear;\r\n                babylonCamera.maxZ = camera.orthographic.zfar;\r\n                break;\r\n            }\r\n            default: {\r\n                throw new Error(`${context}: Invalid camera type (${camera.type})`);\r\n            }\r\n        }\r\n\r\n        GLTFLoader.AddPointerMetadata(babylonCamera, context);\r\n        this._parent.onCameraLoadedObservable.notifyObservers(babylonCamera);\r\n        assign(babylonCamera);\r\n\r\n        this.logClose();\r\n\r\n        return Promise.all(promises).then(() => {\r\n            return babylonCamera;\r\n        });\r\n    }\r\n\r\n    private _loadAnimationsAsync(): Promise<void> {\r\n        this._parent._startPerformanceCounter(\"Load animations\");\r\n\r\n        const animations = this._gltf.animations;\r\n        if (!animations) {\r\n            return Promise.resolve();\r\n        }\r\n\r\n        const promises = new Array<Promise<void>>();\r\n\r\n        for (let index = 0; index < animations.length; index++) {\r\n            const animation = animations[index];\r\n            promises.push(\r\n                this.loadAnimationAsync(`/animations/${animation.index}`, animation).then((animationGroup) => {\r\n                    // Delete the animation group if it ended up not having any animations in it.\r\n                    if (animationGroup.targetedAnimations.length === 0) {\r\n                        animationGroup.dispose();\r\n                    }\r\n                })\r\n            );\r\n        }\r\n\r\n        return Promise.all(promises).then(() => {\r\n            this._parent._endPerformanceCounter(\"Load animations\");\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Loads a glTF animation.\r\n     * @param context The context when loading the asset\r\n     * @param animation The glTF animation property\r\n     * @returns A promise that resolves with the loaded Babylon animation group when the load is complete\r\n     */\r\n    public loadAnimationAsync(context: string, animation: IAnimation): Promise<AnimationGroup> {\r\n        this._parent._startPerformanceCounter(\"Load animation\");\r\n\r\n        const promise = this._extensionsLoadAnimationAsync(context, animation);\r\n        if (promise) {\r\n            return promise;\r\n        }\r\n\r\n        // eslint-disable-next-line @typescript-eslint/naming-convention\r\n        return LazyAnimationGroupModulePromise.value.then(({ AnimationGroup }) => {\r\n            this._babylonScene._blockEntityCollection = !!this._assetContainer;\r\n            const babylonAnimationGroup = new AnimationGroup(animation.name || `animation${animation.index}`, this._babylonScene);\r\n            babylonAnimationGroup._parentContainer = this._assetContainer;\r\n            this._babylonScene._blockEntityCollection = false;\r\n            animation._babylonAnimationGroup = babylonAnimationGroup;\r\n\r\n            const promises = new Array<Promise<unknown>>();\r\n\r\n            ArrayItem.Assign(animation.channels);\r\n            ArrayItem.Assign(animation.samplers);\r\n\r\n            for (const channel of animation.channels) {\r\n                promises.push(\r\n                    this._loadAnimationChannelAsync(`${context}/channels/${channel.index}`, context, animation, channel, (babylonTarget, babylonAnimation) => {\r\n                        babylonTarget.animations = babylonTarget.animations || [];\r\n                        babylonTarget.animations.push(babylonAnimation);\r\n                        babylonAnimationGroup.addTargetedAnimation(babylonAnimation, babylonTarget);\r\n                    })\r\n                );\r\n            }\r\n\r\n            this._parent._endPerformanceCounter(\"Load animation\");\r\n\r\n            return Promise.all(promises).then(() => {\r\n                babylonAnimationGroup.normalize(0);\r\n                return babylonAnimationGroup;\r\n            });\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @hidden\r\n     * Loads a glTF animation channel.\r\n     * @param context The context when loading the asset\r\n     * @param animationContext The context of the animation when loading the asset\r\n     * @param animation The glTF animation property\r\n     * @param channel The glTF animation channel property\r\n     * @param onLoad Called for each animation loaded\r\n     * @returns A void promise that resolves when the load is complete\r\n     */\r\n    public _loadAnimationChannelAsync(\r\n        context: string,\r\n        animationContext: string,\r\n        animation: IAnimation,\r\n        channel: IAnimationChannel,\r\n        onLoad: (babylonAnimatable: IAnimatable, babylonAnimation: Animation) => void\r\n    ): Promise<void> {\r\n        const promise = this._extensionsLoadAnimationChannelAsync(context, animationContext, animation, channel, onLoad);\r\n        if (promise) {\r\n            return promise;\r\n        }\r\n\r\n        if (channel.target.node == undefined) {\r\n            return Promise.resolve();\r\n        }\r\n\r\n        const targetNode = ArrayItem.Get(`${context}/target/node`, this._gltf.nodes, channel.target.node);\r\n        const channelTargetPath = channel.target.path;\r\n        const pathIsWeights = channelTargetPath === AnimationChannelTargetPath.WEIGHTS;\r\n\r\n        // Ignore animations that have no animation targets.\r\n        if ((pathIsWeights && !targetNode._numMorphTargets) || (!pathIsWeights && !targetNode._babylonTransformNode)) {\r\n            return Promise.resolve();\r\n        }\r\n\r\n        // Don't load node animations if disabled.\r\n        if (!this._parent.loadNodeAnimations && !pathIsWeights && !targetNode._isJoint) {\r\n            return Promise.resolve();\r\n        }\r\n\r\n        // async-load the animation sampler to provide the interpolation of the channelTargetPath\r\n        return LazyLoaderAnimationModulePromise.value.then(() => {\r\n            let properties: IInterpolationPropertyInfo[];\r\n            switch (channelTargetPath) {\r\n                case AnimationChannelTargetPath.TRANSLATION: {\r\n                    properties = GetMappingForKey(\"/nodes/{}/translation\")?.interpolation!;\r\n                    break;\r\n                }\r\n                case AnimationChannelTargetPath.ROTATION: {\r\n                    properties = GetMappingForKey(\"/nodes/{}/rotation\")?.interpolation!;\r\n                    break;\r\n                }\r\n                case AnimationChannelTargetPath.SCALE: {\r\n                    properties = GetMappingForKey(\"/nodes/{}/scale\")?.interpolation!;\r\n                    break;\r\n                }\r\n                case AnimationChannelTargetPath.WEIGHTS: {\r\n                    properties = GetMappingForKey(\"/nodes/{}/weights\")?.interpolation!;\r\n                    break;\r\n                }\r\n                default: {\r\n                    throw new Error(`${context}/target/path: Invalid value (${channel.target.path})`);\r\n                }\r\n            }\r\n            // stay safe\r\n            if (!properties) {\r\n                throw new Error(`${context}/target/path: Could not find interpolation properties for target path (${channel.target.path})`);\r\n            }\r\n\r\n            const targetInfo: IObjectInfo<IInterpolationPropertyInfo[]> = {\r\n                object: targetNode,\r\n                info: properties,\r\n            };\r\n\r\n            return this._loadAnimationChannelFromTargetInfoAsync(context, animationContext, animation, channel, targetInfo, onLoad);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @hidden\r\n     * Loads a glTF animation channel.\r\n     * @param context The context when loading the asset\r\n     * @param animationContext The context of the animation when loading the asset\r\n     * @param animation The glTF animation property\r\n     * @param channel The glTF animation channel property\r\n     * @param targetInfo The glTF target and properties\r\n     * @param onLoad Called for each animation loaded\r\n     * @returns A void promise that resolves when the load is complete\r\n     */\r\n    public _loadAnimationChannelFromTargetInfoAsync(\r\n        context: string,\r\n        animationContext: string,\r\n        animation: IAnimation,\r\n        channel: IAnimationChannel,\r\n        targetInfo: IObjectInfo<IInterpolationPropertyInfo[]>,\r\n        onLoad: (babylonAnimatable: IAnimatable, babylonAnimation: Animation) => void\r\n    ): Promise<void> {\r\n        const fps = this.parent.targetFps;\r\n        const invfps = 1 / fps;\r\n\r\n        const sampler = ArrayItem.Get(`${context}/sampler`, animation.samplers, channel.sampler);\r\n        return this._loadAnimationSamplerAsync(`${animationContext}/samplers/${channel.sampler}`, sampler).then((data) => {\r\n            let numAnimations = 0;\r\n\r\n            const target = targetInfo.object;\r\n            const propertyInfos = targetInfo.info;\r\n            // Extract the corresponding values from the read value.\r\n            // GLTF values may be dispatched to several Babylon properties.\r\n            // For example, baseColorFactor [`r`, `g`, `b`, `a`] is dispatched to\r\n            // - albedoColor as Color3(`r`, `g`, `b`)\r\n            // - alpha as `a`\r\n            for (const propertyInfo of propertyInfos) {\r\n                const stride = propertyInfo.getStride(target);\r\n                const input = data.input;\r\n                const output = data.output;\r\n                const keys = new Array<IAnimationKey>(input.length);\r\n                let outputOffset = 0;\r\n\r\n                switch (data.interpolation) {\r\n                    case AnimationSamplerInterpolation.STEP: {\r\n                        for (let index = 0; index < input.length; index++) {\r\n                            const value = propertyInfo.getValue(target, output, outputOffset, 1);\r\n                            outputOffset += stride;\r\n\r\n                            keys[index] = {\r\n                                frame: input[index] * fps,\r\n                                value: value,\r\n                                interpolation: AnimationKeyInterpolation.STEP,\r\n                            };\r\n                        }\r\n                        break;\r\n                    }\r\n                    case AnimationSamplerInterpolation.CUBICSPLINE: {\r\n                        for (let index = 0; index < input.length; index++) {\r\n                            const inTangent = propertyInfo.getValue(target, output, outputOffset, invfps);\r\n                            outputOffset += stride;\r\n                            const value = propertyInfo.getValue(target, output, outputOffset, 1);\r\n                            outputOffset += stride;\r\n                            const outTangent = propertyInfo.getValue(target, output, outputOffset, invfps);\r\n                            outputOffset += stride;\r\n\r\n                            keys[index] = {\r\n                                frame: input[index] * fps,\r\n                                inTangent: inTangent,\r\n                                value: value,\r\n                                outTangent: outTangent,\r\n                            };\r\n                        }\r\n                        break;\r\n                    }\r\n                    case AnimationSamplerInterpolation.LINEAR: {\r\n                        for (let index = 0; index < input.length; index++) {\r\n                            const value = propertyInfo.getValue(target, output, outputOffset, 1);\r\n                            outputOffset += stride;\r\n\r\n                            keys[index] = {\r\n                                frame: input[index] * fps,\r\n                                value: value,\r\n                            };\r\n                        }\r\n                        break;\r\n                    }\r\n                }\r\n\r\n                if (outputOffset > 0) {\r\n                    const name = `${animation.name || `animation${animation.index}`}_channel${channel.index}_${numAnimations}`;\r\n                    const babylonAnimations = propertyInfo.buildAnimations(target, name, fps, keys);\r\n                    for (const babylonAnimation of babylonAnimations) {\r\n                        numAnimations++;\r\n                        onLoad(babylonAnimation.babylonAnimatable, babylonAnimation.babylonAnimation);\r\n                    }\r\n                }\r\n            }\r\n        });\r\n    }\r\n\r\n    private _loadAnimationSamplerAsync(context: string, sampler: IAnimationSampler): Promise<_IAnimationSamplerData> {\r\n        if (sampler._data) {\r\n            return sampler._data;\r\n        }\r\n\r\n        const interpolation = sampler.interpolation || AnimationSamplerInterpolation.LINEAR;\r\n        switch (interpolation) {\r\n            case AnimationSamplerInterpolation.STEP:\r\n            case AnimationSamplerInterpolation.LINEAR:\r\n            case AnimationSamplerInterpolation.CUBICSPLINE: {\r\n                break;\r\n            }\r\n            default: {\r\n                throw new Error(`${context}/interpolation: Invalid value (${sampler.interpolation})`);\r\n            }\r\n        }\r\n\r\n        const inputAccessor = ArrayItem.Get(`${context}/input`, this._gltf.accessors, sampler.input);\r\n        const outputAccessor = ArrayItem.Get(`${context}/output`, this._gltf.accessors, sampler.output);\r\n        sampler._data = Promise.all([\r\n            this._loadFloatAccessorAsync(`/accessors/${inputAccessor.index}`, inputAccessor),\r\n            this._loadFloatAccessorAsync(`/accessors/${outputAccessor.index}`, outputAccessor),\r\n        ]).then(([inputData, outputData]) => {\r\n            return {\r\n                input: inputData,\r\n                interpolation: interpolation,\r\n                output: outputData,\r\n            };\r\n        });\r\n\r\n        return sampler._data;\r\n    }\r\n\r\n    /**\r\n     * Loads a glTF buffer.\r\n     * @param context The context when loading the asset\r\n     * @param buffer The glTF buffer property\r\n     * @param byteOffset The byte offset to use\r\n     * @param byteLength The byte length to use\r\n     * @returns A promise that resolves with the loaded data when the load is complete\r\n     */\r\n    public loadBufferAsync(context: string, buffer: IBuffer, byteOffset: number, byteLength: number): Promise<ArrayBufferView> {\r\n        const extensionPromise = this._extensionsLoadBufferAsync(context, buffer, byteOffset, byteLength);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        if (!buffer._data) {\r\n            if (buffer.uri) {\r\n                buffer._data = this.loadUriAsync(`${context}/uri`, buffer, buffer.uri);\r\n            } else {\r\n                if (!this._bin) {\r\n                    throw new Error(`${context}: Uri is missing or the binary glTF is missing its binary chunk`);\r\n                }\r\n\r\n                buffer._data = this._bin.readAsync(0, buffer.byteLength);\r\n            }\r\n        }\r\n\r\n        return buffer._data.then((data) => {\r\n            try {\r\n                return new Uint8Array(data.buffer, data.byteOffset + byteOffset, byteLength);\r\n            } catch (e) {\r\n                throw new Error(`${context}: ${e.message}`);\r\n            }\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Loads a glTF buffer view.\r\n     * @param context The context when loading the asset\r\n     * @param bufferView The glTF buffer view property\r\n     * @returns A promise that resolves with the loaded data when the load is complete\r\n     */\r\n    public loadBufferViewAsync(context: string, bufferView: IBufferView): Promise<ArrayBufferView> {\r\n        const extensionPromise = this._extensionsLoadBufferViewAsync(context, bufferView);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        if (bufferView._data) {\r\n            return bufferView._data;\r\n        }\r\n\r\n        const buffer = ArrayItem.Get(`${context}/buffer`, this._gltf.buffers, bufferView.buffer);\r\n        bufferView._data = this.loadBufferAsync(`/buffers/${buffer.index}`, buffer, bufferView.byteOffset || 0, bufferView.byteLength);\r\n\r\n        return bufferView._data;\r\n    }\r\n\r\n    private _loadAccessorAsync(context: string, accessor: IAccessor, constructor: TypedArrayConstructor): Promise<ArrayBufferView> {\r\n        if (accessor._data) {\r\n            return accessor._data;\r\n        }\r\n\r\n        const numComponents = GLTFLoader._GetNumComponents(context, accessor.type);\r\n        const byteStride = numComponents * VertexBuffer.GetTypeByteLength(accessor.componentType);\r\n        const length = numComponents * accessor.count;\r\n\r\n        if (accessor.bufferView == undefined) {\r\n            accessor._data = Promise.resolve(new constructor(length));\r\n        } else {\r\n            const bufferView = ArrayItem.Get(`${context}/bufferView`, this._gltf.bufferViews, accessor.bufferView);\r\n            accessor._data = this.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView).then((data) => {\r\n                if (accessor.componentType === AccessorComponentType.FLOAT && !accessor.normalized && (!bufferView.byteStride || bufferView.byteStride === byteStride)) {\r\n                    return GLTFLoader._GetTypedArray(context, accessor.componentType, data, accessor.byteOffset, length);\r\n                } else {\r\n                    const typedArray = new constructor(length);\r\n                    VertexBuffer.ForEach(\r\n                        data,\r\n                        accessor.byteOffset || 0,\r\n                        bufferView.byteStride || byteStride,\r\n                        numComponents,\r\n                        accessor.componentType,\r\n                        typedArray.length,\r\n                        accessor.normalized || false,\r\n                        (value, index) => {\r\n                            typedArray[index] = value;\r\n                        }\r\n                    );\r\n                    return typedArray;\r\n                }\r\n            });\r\n        }\r\n\r\n        if (accessor.sparse) {\r\n            const sparse = accessor.sparse;\r\n            accessor._data = accessor._data.then((data) => {\r\n                const typedArray = data as TypedArray;\r\n                const indicesBufferView = ArrayItem.Get(`${context}/sparse/indices/bufferView`, this._gltf.bufferViews, sparse.indices.bufferView);\r\n                const valuesBufferView = ArrayItem.Get(`${context}/sparse/values/bufferView`, this._gltf.bufferViews, sparse.values.bufferView);\r\n                return Promise.all([\r\n                    this.loadBufferViewAsync(`/bufferViews/${indicesBufferView.index}`, indicesBufferView),\r\n                    this.loadBufferViewAsync(`/bufferViews/${valuesBufferView.index}`, valuesBufferView),\r\n                ]).then(([indicesData, valuesData]) => {\r\n                    const indices = GLTFLoader._GetTypedArray(\r\n                        `${context}/sparse/indices`,\r\n                        sparse.indices.componentType,\r\n                        indicesData,\r\n                        sparse.indices.byteOffset,\r\n                        sparse.count\r\n                    ) as IndicesArray;\r\n\r\n                    const sparseLength = numComponents * sparse.count;\r\n                    let values: TypedArray;\r\n\r\n                    if (accessor.componentType === AccessorComponentType.FLOAT && !accessor.normalized) {\r\n                        values = GLTFLoader._GetTypedArray(`${context}/sparse/values`, accessor.componentType, valuesData, sparse.values.byteOffset, sparseLength);\r\n                    } else {\r\n                        const sparseData = GLTFLoader._GetTypedArray(`${context}/sparse/values`, accessor.componentType, valuesData, sparse.values.byteOffset, sparseLength);\r\n                        values = new constructor(sparseLength);\r\n                        VertexBuffer.ForEach(sparseData, 0, byteStride, numComponents, accessor.componentType, values.length, accessor.normalized || false, (value, index) => {\r\n                            values[index] = value;\r\n                        });\r\n                    }\r\n\r\n                    let valuesIndex = 0;\r\n                    for (let indicesIndex = 0; indicesIndex < indices.length; indicesIndex++) {\r\n                        let dataIndex = indices[indicesIndex] * numComponents;\r\n                        for (let componentIndex = 0; componentIndex < numComponents; componentIndex++) {\r\n                            typedArray[dataIndex++] = values[valuesIndex++];\r\n                        }\r\n                    }\r\n\r\n                    return typedArray;\r\n                });\r\n            });\r\n        }\r\n\r\n        return accessor._data;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public _loadFloatAccessorAsync(context: string, accessor: IAccessor): Promise<Float32Array> {\r\n        return this._loadAccessorAsync(context, accessor, Float32Array) as Promise<Float32Array>;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public _loadIndicesAccessorAsync(context: string, accessor: IAccessor): Promise<IndicesArray> {\r\n        if (accessor.type !== AccessorType.SCALAR) {\r\n            throw new Error(`${context}/type: Invalid value ${accessor.type}`);\r\n        }\r\n\r\n        if (\r\n            accessor.componentType !== AccessorComponentType.UNSIGNED_BYTE &&\r\n            accessor.componentType !== AccessorComponentType.UNSIGNED_SHORT &&\r\n            accessor.componentType !== AccessorComponentType.UNSIGNED_INT\r\n        ) {\r\n            throw new Error(`${context}/componentType: Invalid value ${accessor.componentType}`);\r\n        }\r\n\r\n        if (accessor._data) {\r\n            return accessor._data as Promise<IndicesArray>;\r\n        }\r\n\r\n        if (accessor.sparse) {\r\n            const constructor = GLTFLoader._GetTypedArrayConstructor(`${context}/componentType`, accessor.componentType);\r\n            accessor._data = this._loadAccessorAsync(context, accessor, constructor);\r\n        } else {\r\n            const bufferView = ArrayItem.Get(`${context}/bufferView`, this._gltf.bufferViews, accessor.bufferView);\r\n            accessor._data = this.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView).then((data) => {\r\n                return GLTFLoader._GetTypedArray(context, accessor.componentType, data, accessor.byteOffset, accessor.count);\r\n            });\r\n        }\r\n\r\n        return accessor._data as Promise<IndicesArray>;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public _loadVertexBufferViewAsync(bufferView: IBufferView): Promise<Buffer> {\r\n        if (bufferView._babylonBuffer) {\r\n            return bufferView._babylonBuffer;\r\n        }\r\n\r\n        const engine = this._babylonScene.getEngine();\r\n        bufferView._babylonBuffer = this.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView).then((data) => {\r\n            return new Buffer(engine, data, false);\r\n        });\r\n\r\n        return bufferView._babylonBuffer;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public _loadVertexAccessorAsync(context: string, accessor: IAccessor, kind: string): Promise<VertexBuffer> {\r\n        if (accessor._babylonVertexBuffer?.[kind]) {\r\n            return accessor._babylonVertexBuffer[kind];\r\n        }\r\n\r\n        if (!accessor._babylonVertexBuffer) {\r\n            accessor._babylonVertexBuffer = {};\r\n        }\r\n\r\n        const engine = this._babylonScene.getEngine();\r\n\r\n        if (accessor.sparse || accessor.bufferView == undefined) {\r\n            accessor._babylonVertexBuffer[kind] = this._loadFloatAccessorAsync(context, accessor).then((data) => {\r\n                return new VertexBuffer(engine, data, kind, false);\r\n            });\r\n        } else {\r\n            const bufferView = ArrayItem.Get(`${context}/bufferView`, this._gltf.bufferViews, accessor.bufferView);\r\n            accessor._babylonVertexBuffer[kind] = this._loadVertexBufferViewAsync(bufferView).then((babylonBuffer) => {\r\n                const numComponents = GLTFLoader._GetNumComponents(context, accessor.type);\r\n                return new VertexBuffer(\r\n                    engine,\r\n                    babylonBuffer,\r\n                    kind,\r\n                    false,\r\n                    undefined,\r\n                    bufferView.byteStride,\r\n                    undefined,\r\n                    accessor.byteOffset,\r\n                    numComponents,\r\n                    accessor.componentType,\r\n                    accessor.normalized,\r\n                    true,\r\n                    undefined,\r\n                    true\r\n                );\r\n            });\r\n        }\r\n\r\n        return accessor._babylonVertexBuffer[kind];\r\n    }\r\n\r\n    private _loadMaterialMetallicRoughnessPropertiesAsync(context: string, properties: IMaterialPbrMetallicRoughness, babylonMaterial: Material): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        if (properties) {\r\n            if (properties.baseColorFactor) {\r\n                babylonMaterial.albedoColor = Color3.FromArray(properties.baseColorFactor);\r\n                babylonMaterial.alpha = properties.baseColorFactor[3];\r\n            } else {\r\n                babylonMaterial.albedoColor = Color3.White();\r\n            }\r\n\r\n            babylonMaterial.metallic = properties.metallicFactor == undefined ? 1 : properties.metallicFactor;\r\n            babylonMaterial.roughness = properties.roughnessFactor == undefined ? 1 : properties.roughnessFactor;\r\n\r\n            if (properties.baseColorTexture) {\r\n                promises.push(\r\n                    this.loadTextureInfoAsync(`${context}/baseColorTexture`, properties.baseColorTexture, (texture) => {\r\n                        texture.name = `${babylonMaterial.name} (Base Color)`;\r\n                        babylonMaterial.albedoTexture = texture;\r\n                    })\r\n                );\r\n            }\r\n\r\n            if (properties.metallicRoughnessTexture) {\r\n                properties.metallicRoughnessTexture.nonColorData = true;\r\n                promises.push(\r\n                    this.loadTextureInfoAsync(`${context}/metallicRoughnessTexture`, properties.metallicRoughnessTexture, (texture) => {\r\n                        texture.name = `${babylonMaterial.name} (Metallic Roughness)`;\r\n                        babylonMaterial.metallicTexture = texture;\r\n                    })\r\n                );\r\n\r\n                babylonMaterial.useMetallnessFromMetallicTextureBlue = true;\r\n                babylonMaterial.useRoughnessFromMetallicTextureGreen = true;\r\n                babylonMaterial.useRoughnessFromMetallicTextureAlpha = false;\r\n            }\r\n        }\r\n\r\n        return Promise.all(promises).then(() => {});\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public _loadMaterialAsync(\r\n        context: string,\r\n        material: IMaterial,\r\n        babylonMesh: Nullable<Mesh>,\r\n        babylonDrawMode: number,\r\n        assign: (babylonMaterial: Material) => void = () => {}\r\n    ): Promise<Material> {\r\n        const extensionPromise = this._extensionsLoadMaterialAsync(context, material, babylonMesh, babylonDrawMode, assign);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        material._data = material._data || {};\r\n        let babylonData = material._data[babylonDrawMode];\r\n        if (!babylonData) {\r\n            this.logOpen(`${context} ${material.name || \"\"}`);\r\n\r\n            const babylonMaterial = this.createMaterial(context, material, babylonDrawMode);\r\n\r\n            babylonData = {\r\n                babylonMaterial: babylonMaterial,\r\n                babylonMeshes: [],\r\n                promise: this.loadMaterialPropertiesAsync(context, material, babylonMaterial),\r\n            };\r\n\r\n            material._data[babylonDrawMode] = babylonData;\r\n\r\n            GLTFLoader.AddPointerMetadata(babylonMaterial, context);\r\n            this._parent.onMaterialLoadedObservable.notifyObservers(babylonMaterial);\r\n\r\n            this.logClose();\r\n        }\r\n\r\n        if (babylonMesh) {\r\n            babylonData.babylonMeshes.push(babylonMesh);\r\n\r\n            babylonMesh.onDisposeObservable.addOnce(() => {\r\n                const index = babylonData.babylonMeshes.indexOf(babylonMesh);\r\n                if (index !== -1) {\r\n                    babylonData.babylonMeshes.splice(index, 1);\r\n                }\r\n            });\r\n        }\r\n\r\n        assign(babylonData.babylonMaterial);\r\n\r\n        return babylonData.promise.then(() => {\r\n            return babylonData.babylonMaterial;\r\n        });\r\n    }\r\n\r\n    private _createDefaultMaterial(name: string, babylonDrawMode: number): Material {\r\n        this._babylonScene._blockEntityCollection = !!this._assetContainer;\r\n        const babylonMaterial = new PBRMaterial(name, this._babylonScene);\r\n        babylonMaterial._parentContainer = this._assetContainer;\r\n        this._babylonScene._blockEntityCollection = false;\r\n        // Moved to mesh so user can change materials on gltf meshes: babylonMaterial.sideOrientation = this._babylonScene.useRightHandedSystem ? Material.CounterClockWiseSideOrientation : Material.ClockWiseSideOrientation;\r\n        babylonMaterial.fillMode = babylonDrawMode;\r\n        babylonMaterial.enableSpecularAntiAliasing = true;\r\n        babylonMaterial.useRadianceOverAlpha = !this._parent.transparencyAsCoverage;\r\n        babylonMaterial.useSpecularOverAlpha = !this._parent.transparencyAsCoverage;\r\n        babylonMaterial.transparencyMode = PBRMaterial.PBRMATERIAL_OPAQUE;\r\n        babylonMaterial.metallic = 1;\r\n        babylonMaterial.roughness = 1;\r\n\r\n        return babylonMaterial;\r\n    }\r\n\r\n    /**\r\n     * Creates a Babylon material from a glTF material.\r\n     * @param context The context when loading the asset\r\n     * @param material The glTF material property\r\n     * @param babylonDrawMode The draw mode for the Babylon material\r\n     * @returns The Babylon material\r\n     */\r\n    public createMaterial(context: string, material: IMaterial, babylonDrawMode: number): Material {\r\n        const extensionPromise = this._extensionsCreateMaterial(context, material, babylonDrawMode);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        const name = material.name || `material${material.index}`;\r\n        const babylonMaterial = this._createDefaultMaterial(name, babylonDrawMode);\r\n\r\n        return babylonMaterial;\r\n    }\r\n\r\n    /**\r\n     * Loads properties from a glTF material into a Babylon material.\r\n     * @param context The context when loading the asset\r\n     * @param material The glTF material property\r\n     * @param babylonMaterial The Babylon material\r\n     * @returns A promise that resolves when the load is complete\r\n     */\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Promise<void> {\r\n        const extensionPromise = this._extensionsLoadMaterialPropertiesAsync(context, material, babylonMaterial);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        promises.push(this.loadMaterialBasePropertiesAsync(context, material, babylonMaterial));\r\n\r\n        if (material.pbrMetallicRoughness) {\r\n            promises.push(this._loadMaterialMetallicRoughnessPropertiesAsync(`${context}/pbrMetallicRoughness`, material.pbrMetallicRoughness, babylonMaterial));\r\n        }\r\n\r\n        this.loadMaterialAlphaProperties(context, material, babylonMaterial);\r\n\r\n        return Promise.all(promises).then(() => {});\r\n    }\r\n\r\n    /**\r\n     * Loads the normal, occlusion, and emissive properties from a glTF material into a Babylon material.\r\n     * @param context The context when loading the asset\r\n     * @param material The glTF material property\r\n     * @param babylonMaterial The Babylon material\r\n     * @returns A promise that resolves when the load is complete\r\n     */\r\n    public loadMaterialBasePropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        babylonMaterial.emissiveColor = material.emissiveFactor ? Color3.FromArray(material.emissiveFactor) : new Color3(0, 0, 0);\r\n        if (material.doubleSided) {\r\n            babylonMaterial.backFaceCulling = false;\r\n            babylonMaterial.twoSidedLighting = true;\r\n        }\r\n\r\n        if (material.normalTexture) {\r\n            material.normalTexture.nonColorData = true;\r\n            promises.push(\r\n                this.loadTextureInfoAsync(`${context}/normalTexture`, material.normalTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Normal)`;\r\n                    babylonMaterial.bumpTexture = texture;\r\n                })\r\n            );\r\n\r\n            babylonMaterial.invertNormalMapX = !this._babylonScene.useRightHandedSystem;\r\n            babylonMaterial.invertNormalMapY = this._babylonScene.useRightHandedSystem;\r\n            if (material.normalTexture.scale != undefined && babylonMaterial.bumpTexture) {\r\n                babylonMaterial.bumpTexture.level = material.normalTexture.scale;\r\n            }\r\n\r\n            babylonMaterial.forceIrradianceInFragment = true;\r\n        }\r\n\r\n        if (material.occlusionTexture) {\r\n            material.occlusionTexture.nonColorData = true;\r\n            promises.push(\r\n                this.loadTextureInfoAsync(`${context}/occlusionTexture`, material.occlusionTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Occlusion)`;\r\n                    babylonMaterial.ambientTexture = texture;\r\n                })\r\n            );\r\n\r\n            babylonMaterial.useAmbientInGrayScale = true;\r\n            if (material.occlusionTexture.strength != undefined) {\r\n                babylonMaterial.ambientTextureStrength = material.occlusionTexture.strength;\r\n            }\r\n        }\r\n\r\n        if (material.emissiveTexture) {\r\n            promises.push(\r\n                this.loadTextureInfoAsync(`${context}/emissiveTexture`, material.emissiveTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Emissive)`;\r\n                    babylonMaterial.emissiveTexture = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        return Promise.all(promises).then(() => {});\r\n    }\r\n\r\n    /**\r\n     * Loads the alpha properties from a glTF material into a Babylon material.\r\n     * Must be called after the setting the albedo texture of the Babylon material when the material has an albedo texture.\r\n     * @param context The context when loading the asset\r\n     * @param material The glTF material property\r\n     * @param babylonMaterial The Babylon material\r\n     */\r\n    public loadMaterialAlphaProperties(context: string, material: IMaterial, babylonMaterial: Material): void {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        const alphaMode = material.alphaMode || MaterialAlphaMode.OPAQUE;\r\n        switch (alphaMode) {\r\n            case MaterialAlphaMode.OPAQUE: {\r\n                babylonMaterial.transparencyMode = PBRMaterial.PBRMATERIAL_OPAQUE;\r\n                babylonMaterial.alpha = 1.0; // Force alpha to 1.0 for opaque mode.\r\n                break;\r\n            }\r\n            case MaterialAlphaMode.MASK: {\r\n                babylonMaterial.transparencyMode = PBRMaterial.PBRMATERIAL_ALPHATEST;\r\n                babylonMaterial.alphaCutOff = material.alphaCutoff == undefined ? 0.5 : material.alphaCutoff;\r\n                if (babylonMaterial.albedoTexture) {\r\n                    babylonMaterial.albedoTexture.hasAlpha = true;\r\n                }\r\n                break;\r\n            }\r\n            case MaterialAlphaMode.BLEND: {\r\n                babylonMaterial.transparencyMode = PBRMaterial.PBRMATERIAL_ALPHABLEND;\r\n                if (babylonMaterial.albedoTexture) {\r\n                    babylonMaterial.albedoTexture.hasAlpha = true;\r\n                    babylonMaterial.useAlphaFromAlbedoTexture = true;\r\n                }\r\n                break;\r\n            }\r\n            default: {\r\n                throw new Error(`${context}/alphaMode: Invalid value (${material.alphaMode})`);\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Loads a glTF texture info.\r\n     * @param context The context when loading the asset\r\n     * @param textureInfo The glTF texture info property\r\n     * @param assign A function called synchronously after parsing the glTF properties\r\n     * @returns A promise that resolves with the loaded Babylon texture when the load is complete\r\n     */\r\n    public loadTextureInfoAsync(context: string, textureInfo: ITextureInfo, assign: (babylonTexture: BaseTexture) => void = () => {}): Promise<BaseTexture> {\r\n        const extensionPromise = this._extensionsLoadTextureInfoAsync(context, textureInfo, assign);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        this.logOpen(`${context}`);\r\n\r\n        if (textureInfo.texCoord! >= 6) {\r\n            throw new Error(`${context}/texCoord: Invalid value (${textureInfo.texCoord})`);\r\n        }\r\n\r\n        const texture = ArrayItem.Get(`${context}/index`, this._gltf.textures, textureInfo.index);\r\n        texture._textureInfo = textureInfo;\r\n\r\n        const promise = this._loadTextureAsync(`/textures/${textureInfo.index}`, texture, (babylonTexture) => {\r\n            babylonTexture.coordinatesIndex = textureInfo.texCoord || 0;\r\n            GLTFLoader.AddPointerMetadata(babylonTexture, context);\r\n            this._parent.onTextureLoadedObservable.notifyObservers(babylonTexture);\r\n            assign(babylonTexture);\r\n        });\r\n\r\n        this.logClose();\r\n\r\n        return promise;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public _loadTextureAsync(context: string, texture: ITexture, assign: (babylonTexture: BaseTexture) => void = () => {}): Promise<BaseTexture> {\r\n        const extensionPromise = this._extensionsLoadTextureAsync(context, texture, assign);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        this.logOpen(`${context} ${texture.name || \"\"}`);\r\n\r\n        const sampler = texture.sampler == undefined ? GLTFLoader.DefaultSampler : ArrayItem.Get(`${context}/sampler`, this._gltf.samplers, texture.sampler);\r\n        const image = ArrayItem.Get(`${context}/source`, this._gltf.images, texture.source);\r\n        const promise = this._createTextureAsync(context, sampler, image, assign, undefined, !texture._textureInfo.nonColorData);\r\n\r\n        this.logClose();\r\n\r\n        return promise;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public _createTextureAsync(\r\n        context: string,\r\n        sampler: ISampler,\r\n        image: IImage,\r\n        assign: (babylonTexture: BaseTexture) => void = () => {},\r\n        textureLoaderOptions?: unknown,\r\n        useSRGBBuffer?: boolean\r\n    ): Promise<BaseTexture> {\r\n        const samplerData = this._loadSampler(`/samplers/${sampler.index}`, sampler);\r\n\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        const deferred = new Deferred<void>();\r\n        this._babylonScene._blockEntityCollection = !!this._assetContainer;\r\n        const textureCreationOptions: ITextureCreationOptions = {\r\n            noMipmap: samplerData.noMipMaps,\r\n            invertY: false,\r\n            samplingMode: samplerData.samplingMode,\r\n            onLoad: () => {\r\n                if (!this._disposed) {\r\n                    deferred.resolve();\r\n                }\r\n            },\r\n            onError: (message?: string, exception?: any) => {\r\n                if (!this._disposed) {\r\n                    deferred.reject(new Error(`${context}: ${exception && exception.message ? exception.message : message || \"Failed to load texture\"}`));\r\n                }\r\n            },\r\n            mimeType: image.mimeType ?? GetMimeType(image.uri ?? \"\"),\r\n            loaderOptions: textureLoaderOptions,\r\n            useSRGBBuffer: !!useSRGBBuffer && this._parent.useSRGBBuffers,\r\n        };\r\n        const babylonTexture = new Texture(null, this._babylonScene, textureCreationOptions);\r\n        babylonTexture._parentContainer = this._assetContainer;\r\n        this._babylonScene._blockEntityCollection = false;\r\n        promises.push(deferred.promise);\r\n\r\n        promises.push(\r\n            this.loadImageAsync(`/images/${image.index}`, image).then((data) => {\r\n                const name = image.uri || `${this._fileName}#image${image.index}`;\r\n                const dataUrl = `data:${this._uniqueRootUrl}${name}`;\r\n                babylonTexture.updateURL(dataUrl, data);\r\n\r\n                // Set the internal texture label.\r\n                const internalTexture = babylonTexture.getInternalTexture();\r\n                if (internalTexture) {\r\n                    internalTexture.label = image.name;\r\n                }\r\n            })\r\n        );\r\n\r\n        babylonTexture.wrapU = samplerData.wrapU;\r\n        babylonTexture.wrapV = samplerData.wrapV;\r\n        assign(babylonTexture);\r\n\r\n        if (this._parent.useGltfTextureNames) {\r\n            babylonTexture.name = image.name || image.uri || `image${image.index}`;\r\n        }\r\n\r\n        return Promise.all(promises).then(() => {\r\n            return babylonTexture;\r\n        });\r\n    }\r\n\r\n    private _loadSampler(context: string, sampler: ISampler): _ISamplerData {\r\n        if (!sampler._data) {\r\n            sampler._data = {\r\n                noMipMaps: sampler.minFilter === TextureMinFilter.NEAREST || sampler.minFilter === TextureMinFilter.LINEAR,\r\n                samplingMode: GLTFLoader._GetTextureSamplingMode(context, sampler),\r\n                wrapU: GLTFLoader._GetTextureWrapMode(`${context}/wrapS`, sampler.wrapS),\r\n                wrapV: GLTFLoader._GetTextureWrapMode(`${context}/wrapT`, sampler.wrapT),\r\n            };\r\n        }\r\n\r\n        return sampler._data;\r\n    }\r\n\r\n    /**\r\n     * Loads a glTF image.\r\n     * @param context The context when loading the asset\r\n     * @param image The glTF image property\r\n     * @returns A promise that resolves with the loaded data when the load is complete\r\n     */\r\n    public loadImageAsync(context: string, image: IImage): Promise<ArrayBufferView> {\r\n        if (!image._data) {\r\n            this.logOpen(`${context} ${image.name || \"\"}`);\r\n\r\n            if (image.uri) {\r\n                image._data = this.loadUriAsync(`${context}/uri`, image, image.uri);\r\n            } else {\r\n                const bufferView = ArrayItem.Get(`${context}/bufferView`, this._gltf.bufferViews, image.bufferView);\r\n                image._data = this.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView);\r\n            }\r\n\r\n            this.logClose();\r\n        }\r\n\r\n        return image._data;\r\n    }\r\n\r\n    /**\r\n     * Loads a glTF uri.\r\n     * @param context The context when loading the asset\r\n     * @param property The glTF property associated with the uri\r\n     * @param uri The base64 or relative uri\r\n     * @returns A promise that resolves with the loaded data when the load is complete\r\n     */\r\n    public loadUriAsync(context: string, property: IProperty, uri: string): Promise<ArrayBufferView> {\r\n        const extensionPromise = this._extensionsLoadUriAsync(context, property, uri);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        if (!GLTFLoader._ValidateUri(uri)) {\r\n            throw new Error(`${context}: '${uri}' is invalid`);\r\n        }\r\n\r\n        if (IsBase64DataUrl(uri)) {\r\n            const data = new Uint8Array(DecodeBase64UrlToBinary(uri));\r\n            this.log(`${context}: Decoded ${uri.substring(0, 64)}... (${data.length} bytes)`);\r\n            return Promise.resolve(data);\r\n        }\r\n\r\n        this.log(`${context}: Loading ${uri}`);\r\n\r\n        return this._parent.preprocessUrlAsync(this._rootUrl + uri).then((url) => {\r\n            return new Promise((resolve, reject) => {\r\n                this._parent._loadFile(\r\n                    this._babylonScene,\r\n                    url,\r\n                    (data) => {\r\n                        if (!this._disposed) {\r\n                            this.log(`${context}: Loaded ${uri} (${(data as ArrayBuffer).byteLength} bytes)`);\r\n                            resolve(new Uint8Array(data as ArrayBuffer));\r\n                        }\r\n                    },\r\n                    true,\r\n                    (request) => {\r\n                        reject(new LoadFileError(`${context}: Failed to load '${uri}'${request ? \": \" + request.status + \" \" + request.statusText : \"\"}`, request));\r\n                    }\r\n                );\r\n            });\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Adds a JSON pointer to the _internalMetadata of the Babylon object at `<object>._internalMetadata.gltf.pointers`.\r\n     * @param babylonObject the Babylon object with _internalMetadata\r\n     * @param pointer the JSON pointer\r\n     */\r\n    public static AddPointerMetadata(babylonObject: IWithMetadata, pointer: string): void {\r\n        babylonObject.metadata = babylonObject.metadata || {};\r\n        const metadata = (babylonObject._internalMetadata = babylonObject._internalMetadata || {});\r\n        const gltf = (metadata.gltf = metadata.gltf || {});\r\n        const pointers = (gltf.pointers = gltf.pointers || []);\r\n        pointers.push(pointer);\r\n    }\r\n\r\n    private static _GetTextureWrapMode(context: string, mode: TextureWrapMode | undefined): number {\r\n        // Set defaults if undefined\r\n        mode = mode == undefined ? TextureWrapMode.REPEAT : mode;\r\n\r\n        switch (mode) {\r\n            case TextureWrapMode.CLAMP_TO_EDGE:\r\n                return Texture.CLAMP_ADDRESSMODE;\r\n            case TextureWrapMode.MIRRORED_REPEAT:\r\n                return Texture.MIRROR_ADDRESSMODE;\r\n            case TextureWrapMode.REPEAT:\r\n                return Texture.WRAP_ADDRESSMODE;\r\n            default:\r\n                Logger.Warn(`${context}: Invalid value (${mode})`);\r\n                return Texture.WRAP_ADDRESSMODE;\r\n        }\r\n    }\r\n\r\n    private static _GetTextureSamplingMode(context: string, sampler: ISampler): number {\r\n        // Set defaults if undefined\r\n        const magFilter = sampler.magFilter == undefined ? TextureMagFilter.LINEAR : sampler.magFilter;\r\n        const minFilter = sampler.minFilter == undefined ? TextureMinFilter.LINEAR_MIPMAP_LINEAR : sampler.minFilter;\r\n\r\n        if (magFilter === TextureMagFilter.LINEAR) {\r\n            switch (minFilter) {\r\n                case TextureMinFilter.NEAREST:\r\n                    return Texture.LINEAR_NEAREST;\r\n                case TextureMinFilter.LINEAR:\r\n                    return Texture.LINEAR_LINEAR;\r\n                case TextureMinFilter.NEAREST_MIPMAP_NEAREST:\r\n                    return Texture.LINEAR_NEAREST_MIPNEAREST;\r\n                case TextureMinFilter.LINEAR_MIPMAP_NEAREST:\r\n                    return Texture.LINEAR_LINEAR_MIPNEAREST;\r\n                case TextureMinFilter.NEAREST_MIPMAP_LINEAR:\r\n                    return Texture.LINEAR_NEAREST_MIPLINEAR;\r\n                case TextureMinFilter.LINEAR_MIPMAP_LINEAR:\r\n                    return Texture.LINEAR_LINEAR_MIPLINEAR;\r\n                default:\r\n                    Logger.Warn(`${context}/minFilter: Invalid value (${minFilter})`);\r\n                    return Texture.LINEAR_LINEAR_MIPLINEAR;\r\n            }\r\n        } else {\r\n            if (magFilter !== TextureMagFilter.NEAREST) {\r\n                Logger.Warn(`${context}/magFilter: Invalid value (${magFilter})`);\r\n            }\r\n\r\n            switch (minFilter) {\r\n                case TextureMinFilter.NEAREST:\r\n                    return Texture.NEAREST_NEAREST;\r\n                case TextureMinFilter.LINEAR:\r\n                    return Texture.NEAREST_LINEAR;\r\n                case TextureMinFilter.NEAREST_MIPMAP_NEAREST:\r\n                    return Texture.NEAREST_NEAREST_MIPNEAREST;\r\n                case TextureMinFilter.LINEAR_MIPMAP_NEAREST:\r\n                    return Texture.NEAREST_LINEAR_MIPNEAREST;\r\n                case TextureMinFilter.NEAREST_MIPMAP_LINEAR:\r\n                    return Texture.NEAREST_NEAREST_MIPLINEAR;\r\n                case TextureMinFilter.LINEAR_MIPMAP_LINEAR:\r\n                    return Texture.NEAREST_LINEAR_MIPLINEAR;\r\n                default:\r\n                    Logger.Warn(`${context}/minFilter: Invalid value (${minFilter})`);\r\n                    return Texture.NEAREST_NEAREST_MIPNEAREST;\r\n            }\r\n        }\r\n    }\r\n\r\n    private static _GetTypedArrayConstructor(context: string, componentType: AccessorComponentType): TypedArrayConstructor {\r\n        try {\r\n            return GetTypedArrayConstructor(componentType);\r\n        } catch (e) {\r\n            throw new Error(`${context}: ${e.message}`);\r\n        }\r\n    }\r\n\r\n    private static _GetTypedArray(context: string, componentType: AccessorComponentType, bufferView: ArrayBufferView, byteOffset: number | undefined, length: number): TypedArray {\r\n        const buffer = bufferView.buffer;\r\n        byteOffset = bufferView.byteOffset + (byteOffset || 0);\r\n\r\n        const constructor = GLTFLoader._GetTypedArrayConstructor(`${context}/componentType`, componentType);\r\n\r\n        const componentTypeLength = VertexBuffer.GetTypeByteLength(componentType);\r\n        if (byteOffset % componentTypeLength !== 0) {\r\n            // HACK: Copy the buffer if byte offset is not a multiple of component type byte length.\r\n            Logger.Warn(`${context}: Copying buffer as byte offset (${byteOffset}) is not a multiple of component type byte length (${componentTypeLength})`);\r\n            return new constructor(buffer.slice(byteOffset, byteOffset + length * componentTypeLength), 0);\r\n        }\r\n\r\n        return new constructor(buffer, byteOffset, length);\r\n    }\r\n\r\n    private static _GetNumComponents(context: string, type: string): number {\r\n        switch (type) {\r\n            case \"SCALAR\":\r\n                return 1;\r\n            case \"VEC2\":\r\n                return 2;\r\n            case \"VEC3\":\r\n                return 3;\r\n            case \"VEC4\":\r\n                return 4;\r\n            case \"MAT2\":\r\n                return 4;\r\n            case \"MAT3\":\r\n                return 9;\r\n            case \"MAT4\":\r\n                return 16;\r\n        }\r\n\r\n        throw new Error(`${context}: Invalid type (${type})`);\r\n    }\r\n\r\n    private static _ValidateUri(uri: string): boolean {\r\n        return Tools.IsBase64(uri) || uri.indexOf(\"..\") === -1;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public static _GetDrawMode(context: string, mode: number | undefined): number {\r\n        if (mode == undefined) {\r\n            mode = MeshPrimitiveMode.TRIANGLES;\r\n        }\r\n\r\n        switch (mode) {\r\n            case MeshPrimitiveMode.POINTS:\r\n                return Material.PointListDrawMode;\r\n            case MeshPrimitiveMode.LINES:\r\n                return Material.LineListDrawMode;\r\n            case MeshPrimitiveMode.LINE_LOOP:\r\n                return Material.LineLoopDrawMode;\r\n            case MeshPrimitiveMode.LINE_STRIP:\r\n                return Material.LineStripDrawMode;\r\n            case MeshPrimitiveMode.TRIANGLES:\r\n                return Material.TriangleFillMode;\r\n            case MeshPrimitiveMode.TRIANGLE_STRIP:\r\n                return Material.TriangleStripDrawMode;\r\n            case MeshPrimitiveMode.TRIANGLE_FAN:\r\n                return Material.TriangleFanDrawMode;\r\n        }\r\n\r\n        throw new Error(`${context}: Invalid mesh primitive mode (${mode})`);\r\n    }\r\n\r\n    private _compileMaterialsAsync(): Promise<void> {\r\n        this._parent._startPerformanceCounter(\"Compile materials\");\r\n\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        if (this._gltf.materials) {\r\n            for (const material of this._gltf.materials) {\r\n                if (material._data) {\r\n                    for (const babylonDrawMode in material._data) {\r\n                        const babylonData = material._data[babylonDrawMode];\r\n                        for (const babylonMesh of babylonData.babylonMeshes) {\r\n                            // Ensure nonUniformScaling is set if necessary.\r\n                            babylonMesh.computeWorldMatrix(true);\r\n\r\n                            const babylonMaterial = babylonData.babylonMaterial;\r\n                            promises.push(babylonMaterial.forceCompilationAsync(babylonMesh));\r\n                            promises.push(babylonMaterial.forceCompilationAsync(babylonMesh, { useInstances: true }));\r\n                            if (this._parent.useClipPlane) {\r\n                                promises.push(babylonMaterial.forceCompilationAsync(babylonMesh, { clipPlane: true }));\r\n                                promises.push(babylonMaterial.forceCompilationAsync(babylonMesh, { clipPlane: true, useInstances: true }));\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        return Promise.all(promises).then(() => {\r\n            this._parent._endPerformanceCounter(\"Compile materials\");\r\n        });\r\n    }\r\n\r\n    private _compileShadowGeneratorsAsync(): Promise<void> {\r\n        this._parent._startPerformanceCounter(\"Compile shadow generators\");\r\n\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        const lights = this._babylonScene.lights;\r\n        for (const light of lights) {\r\n            const generator = light.getShadowGenerator();\r\n            if (generator) {\r\n                promises.push(generator.forceCompilationAsync());\r\n            }\r\n        }\r\n\r\n        return Promise.all(promises).then(() => {\r\n            this._parent._endPerformanceCounter(\"Compile shadow generators\");\r\n        });\r\n    }\r\n\r\n    private _forEachExtensions(action: (extension: IGLTFLoaderExtension) => void): void {\r\n        for (const extension of this._extensions) {\r\n            if (extension.enabled) {\r\n                action(extension);\r\n            }\r\n        }\r\n    }\r\n\r\n    private _applyExtensions<T>(property: IProperty, functionName: string, actionAsync: (extension: IGLTFLoaderExtension) => Nullable<T> | undefined): Nullable<T> {\r\n        for (const extension of this._extensions) {\r\n            if (extension.enabled) {\r\n                const id = `${extension.name}.${functionName}`;\r\n                const loaderProperty = property as ILoaderProperty;\r\n                loaderProperty._activeLoaderExtensionFunctions = loaderProperty._activeLoaderExtensionFunctions || {};\r\n                const activeLoaderExtensionFunctions = loaderProperty._activeLoaderExtensionFunctions;\r\n                if (!activeLoaderExtensionFunctions[id]) {\r\n                    activeLoaderExtensionFunctions[id] = true;\r\n\r\n                    try {\r\n                        const result = actionAsync(extension);\r\n                        if (result) {\r\n                            return result;\r\n                        }\r\n                    } finally {\r\n                        delete activeLoaderExtensionFunctions[id];\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        return null;\r\n    }\r\n\r\n    private _extensionsOnLoading(): void {\r\n        this._forEachExtensions((extension) => extension.onLoading && extension.onLoading());\r\n    }\r\n\r\n    private _extensionsOnReady(): void {\r\n        this._forEachExtensions((extension) => extension.onReady && extension.onReady());\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadSceneAsync(context: string, scene: IScene): Nullable<Promise<void>> {\r\n        return this._applyExtensions(scene, \"loadScene\", (extension) => extension.loadSceneAsync && extension.loadSceneAsync(context, scene));\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadNodeAsync(context: string, node: INode, assign: (babylonTransformNode: TransformNode) => void): Nullable<Promise<TransformNode>> {\r\n        return this._applyExtensions(node, \"loadNode\", (extension) => extension.loadNodeAsync && extension.loadNodeAsync(context, node, assign));\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadCameraAsync(context: string, camera: ICamera, assign: (babylonCamera: Camera) => void): Nullable<Promise<Camera>> {\r\n        return this._applyExtensions(camera, \"loadCamera\", (extension) => extension.loadCameraAsync && extension.loadCameraAsync(context, camera, assign));\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadVertexDataAsync(context: string, primitive: IMeshPrimitive, babylonMesh: Mesh): Nullable<Promise<Geometry>> {\r\n        return this._applyExtensions(primitive, \"loadVertexData\", (extension) => extension._loadVertexDataAsync && extension._loadVertexDataAsync(context, primitive, babylonMesh));\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadMeshPrimitiveAsync(\r\n        context: string,\r\n        name: string,\r\n        node: INode,\r\n        mesh: IMesh,\r\n        primitive: IMeshPrimitive,\r\n        assign: (babylonMesh: AbstractMesh) => void\r\n    ): Nullable<Promise<AbstractMesh>> {\r\n        return this._applyExtensions(\r\n            primitive,\r\n            \"loadMeshPrimitive\",\r\n            (extension) => extension._loadMeshPrimitiveAsync && extension._loadMeshPrimitiveAsync(context, name, node, mesh, primitive, assign)\r\n        );\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadMaterialAsync(\r\n        context: string,\r\n        material: IMaterial,\r\n        babylonMesh: Nullable<Mesh>,\r\n        babylonDrawMode: number,\r\n        assign: (babylonMaterial: Material) => void\r\n    ): Nullable<Promise<Material>> {\r\n        return this._applyExtensions(\r\n            material,\r\n            \"loadMaterial\",\r\n            (extension) => extension._loadMaterialAsync && extension._loadMaterialAsync(context, material, babylonMesh, babylonDrawMode, assign)\r\n        );\r\n    }\r\n\r\n    private _extensionsCreateMaterial(context: string, material: IMaterial, babylonDrawMode: number): Nullable<Material> {\r\n        return this._applyExtensions(material, \"createMaterial\", (extension) => extension.createMaterial && extension.createMaterial(context, material, babylonDrawMode));\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return this._applyExtensions(\r\n            material,\r\n            \"loadMaterialProperties\",\r\n            (extension) => extension.loadMaterialPropertiesAsync && extension.loadMaterialPropertiesAsync(context, material, babylonMaterial)\r\n        );\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadTextureInfoAsync(context: string, textureInfo: ITextureInfo, assign: (babylonTexture: BaseTexture) => void): Nullable<Promise<BaseTexture>> {\r\n        return this._applyExtensions(textureInfo, \"loadTextureInfo\", (extension) => extension.loadTextureInfoAsync && extension.loadTextureInfoAsync(context, textureInfo, assign));\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadTextureAsync(context: string, texture: ITexture, assign: (babylonTexture: BaseTexture) => void): Nullable<Promise<BaseTexture>> {\r\n        return this._applyExtensions(texture, \"loadTexture\", (extension) => extension._loadTextureAsync && extension._loadTextureAsync(context, texture, assign));\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadAnimationAsync(context: string, animation: IAnimation): Nullable<Promise<AnimationGroup>> {\r\n        return this._applyExtensions(animation, \"loadAnimation\", (extension) => extension.loadAnimationAsync && extension.loadAnimationAsync(context, animation));\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadAnimationChannelAsync(\r\n        context: string,\r\n        animationContext: string,\r\n        animation: IAnimation,\r\n        channel: IAnimationChannel,\r\n        onLoad: (babylonAnimatable: IAnimatable, babylonAnimation: Animation) => void\r\n    ): Nullable<Promise<void>> {\r\n        return this._applyExtensions(\r\n            animation,\r\n            \"loadAnimationChannel\",\r\n            (extension) => extension._loadAnimationChannelAsync && extension._loadAnimationChannelAsync(context, animationContext, animation, channel, onLoad)\r\n        );\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadSkinAsync(context: string, node: INode, skin: ISkin): Nullable<Promise<void>> {\r\n        return this._applyExtensions(skin, \"loadSkin\", (extension) => extension._loadSkinAsync && extension._loadSkinAsync(context, node, skin));\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadUriAsync(context: string, property: IProperty, uri: string): Nullable<Promise<ArrayBufferView>> {\r\n        return this._applyExtensions(property, \"loadUri\", (extension) => extension._loadUriAsync && extension._loadUriAsync(context, property, uri));\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadBufferViewAsync(context: string, bufferView: IBufferView): Nullable<Promise<ArrayBufferView>> {\r\n        return this._applyExtensions(bufferView, \"loadBufferView\", (extension) => extension.loadBufferViewAsync && extension.loadBufferViewAsync(context, bufferView));\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadBufferAsync(context: string, buffer: IBuffer, byteOffset: number, byteLength: number): Nullable<Promise<ArrayBufferView>> {\r\n        return this._applyExtensions(buffer, \"loadBuffer\", (extension) => extension.loadBufferAsync && extension.loadBufferAsync(context, buffer, byteOffset, byteLength));\r\n    }\r\n\r\n    /**\r\n     * Helper method called by a loader extension to load an glTF extension.\r\n     * @param context The context when loading the asset\r\n     * @param property The glTF property to load the extension from\r\n     * @param extensionName The name of the extension to load\r\n     * @param actionAsync The action to run\r\n     * @returns The promise returned by actionAsync or null if the extension does not exist\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax, @typescript-eslint/naming-convention\r\n    public static LoadExtensionAsync<TExtension = unknown, TResult = void>(\r\n        context: string,\r\n        property: IProperty,\r\n        extensionName: string,\r\n        actionAsync: (extensionContext: string, extension: TExtension) => Nullable<Promise<TResult>>\r\n    ): Nullable<Promise<TResult>> {\r\n        if (!property.extensions) {\r\n            return null;\r\n        }\r\n\r\n        const extensions = property.extensions;\r\n\r\n        const extension = extensions[extensionName] as TExtension;\r\n        if (!extension) {\r\n            return null;\r\n        }\r\n\r\n        return actionAsync(`${context}/extensions/${extensionName}`, extension);\r\n    }\r\n\r\n    /**\r\n     * Helper method called by a loader extension to load a glTF extra.\r\n     * @param context The context when loading the asset\r\n     * @param property The glTF property to load the extra from\r\n     * @param extensionName The name of the extension to load\r\n     * @param actionAsync The action to run\r\n     * @returns The promise returned by actionAsync or null if the extra does not exist\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax, @typescript-eslint/naming-convention\r\n    public static LoadExtraAsync<TExtra = unknown, TResult = void>(\r\n        context: string,\r\n        property: IProperty,\r\n        extensionName: string,\r\n        actionAsync: (extraContext: string, extra: TExtra) => Nullable<Promise<TResult>>\r\n    ): Nullable<Promise<TResult>> {\r\n        if (!property.extras) {\r\n            return null;\r\n        }\r\n\r\n        const extras = property.extras;\r\n\r\n        const extra = extras[extensionName] as TExtra;\r\n        if (!extra) {\r\n            return null;\r\n        }\r\n\r\n        return actionAsync(`${context}/extras/${extensionName}`, extra);\r\n    }\r\n\r\n    /**\r\n     * Checks for presence of an extension.\r\n     * @param name The name of the extension to check\r\n     * @returns A boolean indicating the presence of the given extension name in `extensionsUsed`\r\n     */\r\n    public isExtensionUsed(name: string): boolean {\r\n        return !!this._gltf.extensionsUsed && this._gltf.extensionsUsed.indexOf(name) !== -1;\r\n    }\r\n\r\n    /**\r\n     * Increments the indentation level and logs a message.\r\n     * @param message The message to log\r\n     */\r\n    public logOpen(message: string): void {\r\n        this._parent._logOpen(message);\r\n    }\r\n\r\n    /**\r\n     * Decrements the indentation level.\r\n     */\r\n    public logClose(): void {\r\n        this._parent._logClose();\r\n    }\r\n\r\n    /**\r\n     * Logs a message\r\n     * @param message The message to log\r\n     */\r\n    public log(message: string): void {\r\n        this._parent._log(message);\r\n    }\r\n\r\n    /**\r\n     * Starts a performance counter.\r\n     * @param counterName The name of the performance counter\r\n     */\r\n    public startPerformanceCounter(counterName: string): void {\r\n        this._parent._startPerformanceCounter(counterName);\r\n    }\r\n\r\n    /**\r\n     * Ends a performance counter.\r\n     * @param counterName The name of the performance counter\r\n     */\r\n    public endPerformanceCounter(counterName: string): void {\r\n        this._parent._endPerformanceCounter(counterName);\r\n    }\r\n}\r\n\r\nGLTFFileLoader._CreateGLTF2Loader = (parent) => new GLTFLoader(parent);\r\n","import type { Nullable } from \"core/types\";\r\nimport { SphericalHarmonics, SphericalPolynomial } from \"core/Maths/sphericalPolynomial\";\r\nimport { Quaternion, Matrix } from \"core/Maths/math.vector\";\r\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\r\nimport { RawCubeTexture } from \"core/Materials/Textures/rawCubeTexture\";\r\n\r\nimport type { IEXTLightsImageBased_LightReferenceImageBased, IEXTLightsImageBased_LightImageBased, IEXTLightsImageBased } from \"babylonjs-gltf2interface\";\r\nimport type { IScene } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader, ArrayItem } from \"../glTFLoader\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"EXT_lights_image_based\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the EXT_lights_image_based extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"EXT_lights_image_based\"]: {};\r\n    }\r\n}\r\n\r\ndeclare module \"babylonjs-gltf2interface\" {\r\n    /** @internal */\r\n    // eslint-disable-next-line @typescript-eslint/naming-convention\r\n    interface IEXTLightsImageBased_LightImageBased {\r\n        _babylonTexture?: BaseTexture;\r\n        _loaded?: Promise<void>;\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Vendor/EXT_lights_image_based/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class EXT_lights_image_based implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    private _loader: GLTFLoader;\r\n    private _lights?: IEXTLightsImageBased_LightImageBased[];\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n        delete this._lights;\r\n    }\r\n\r\n    /** @internal */\r\n    public onLoading(): void {\r\n        const extensions = this._loader.gltf.extensions;\r\n        if (extensions && extensions[this.name]) {\r\n            const extension = extensions[this.name] as IEXTLightsImageBased;\r\n            this._lights = extension.lights;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadSceneAsync(context: string, scene: IScene): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IEXTLightsImageBased_LightReferenceImageBased>(context, scene, this.name, async (extensionContext, extension) => {\r\n            this._loader._allMaterialsDirtyRequired = true;\r\n\r\n            const promises = new Array<Promise<any>>();\r\n\r\n            promises.push(this._loader.loadSceneAsync(context, scene));\r\n\r\n            this._loader.logOpen(`${extensionContext}`);\r\n\r\n            const light = ArrayItem.Get(`${extensionContext}/light`, this._lights, extension.light);\r\n            promises.push(\r\n                // eslint-disable-next-line github/no-then\r\n                this._loadLightAsync(`/extensions/${this.name}/lights/${extension.light}`, light).then((texture) => {\r\n                    this._loader.babylonScene.environmentTexture = texture;\r\n                })\r\n            );\r\n\r\n            this._loader.logClose();\r\n\r\n            // eslint-disable-next-line github/no-then\r\n            return await Promise.all(promises).then(() => {});\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadLightAsync(context: string, light: IEXTLightsImageBased_LightImageBased): Promise<BaseTexture> {\r\n        if (!light._loaded) {\r\n            const promises = new Array<Promise<any>>();\r\n\r\n            this._loader.logOpen(`${context}`);\r\n\r\n            const imageData = new Array<Array<ArrayBufferView>>(light.specularImages.length);\r\n            for (let mipmap = 0; mipmap < light.specularImages.length; mipmap++) {\r\n                const faces = light.specularImages[mipmap];\r\n                imageData[mipmap] = new Array<ArrayBufferView>(faces.length);\r\n                for (let face = 0; face < faces.length; face++) {\r\n                    const specularImageContext = `${context}/specularImages/${mipmap}/${face}`;\r\n                    this._loader.logOpen(`${specularImageContext}`);\r\n\r\n                    const index = faces[face];\r\n                    const image = ArrayItem.Get(specularImageContext, this._loader.gltf.images, index);\r\n                    promises.push(\r\n                        // eslint-disable-next-line github/no-then\r\n                        this._loader.loadImageAsync(`/images/${index}`, image).then((data) => {\r\n                            imageData[mipmap][face] = data;\r\n                        })\r\n                    );\r\n\r\n                    this._loader.logClose();\r\n                }\r\n            }\r\n\r\n            this._loader.logClose();\r\n\r\n            // eslint-disable-next-line github/no-then\r\n            light._loaded = Promise.all(promises).then(async () => {\r\n                const babylonTexture = new RawCubeTexture(this._loader.babylonScene, null, light.specularImageSize);\r\n                babylonTexture.name = light.name || \"environment\";\r\n                light._babylonTexture = babylonTexture;\r\n\r\n                if (light.intensity != undefined) {\r\n                    babylonTexture.level = light.intensity;\r\n                }\r\n\r\n                if (light.rotation) {\r\n                    let rotation = Quaternion.FromArray(light.rotation);\r\n\r\n                    // Invert the rotation so that positive rotation is counter-clockwise.\r\n                    if (!this._loader.babylonScene.useRightHandedSystem) {\r\n                        rotation = Quaternion.Inverse(rotation);\r\n                    }\r\n\r\n                    Matrix.FromQuaternionToRef(rotation, babylonTexture.getReflectionTextureMatrix());\r\n                }\r\n\r\n                if (!light.irradianceCoefficients) {\r\n                    throw new Error(`${context}: Irradiance coefficients are missing`);\r\n                }\r\n\r\n                const sphericalHarmonics = SphericalHarmonics.FromArray(light.irradianceCoefficients);\r\n                sphericalHarmonics.scaleInPlace(light.intensity);\r\n\r\n                sphericalHarmonics.convertIrradianceToLambertianRadiance();\r\n                const sphericalPolynomial = SphericalPolynomial.FromHarmonics(sphericalHarmonics);\r\n\r\n                // Compute the lod generation scale to fit exactly to the number of levels available.\r\n                const lodGenerationScale = (imageData.length - 1) / Math.log2(light.specularImageSize);\r\n                return await babylonTexture.updateRGBDAsync(imageData, sphericalPolynomial, lodGenerationScale);\r\n            });\r\n        }\r\n\r\n        // eslint-disable-next-line github/no-then\r\n        return light._loaded.then(() => {\r\n            return light._babylonTexture!;\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new EXT_lights_image_based(loader));\r\n","import { Vector3, Quaternion, Matrix, TmpVectors } from \"core/Maths/math.vector\";\r\nimport type { Mesh } from \"core/Meshes/mesh\";\r\nimport type { TransformNode } from \"core/Meshes/transformNode\";\r\nimport type { Nullable } from \"core/types\";\r\nimport { GLTFLoader, ArrayItem } from \"../glTFLoader\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport type { INode } from \"../glTFLoaderInterfaces\";\r\nimport type { IEXTMeshGpuInstancing } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nimport \"core/Meshes/thinInstanceMesh\";\r\n\r\nconst NAME = \"EXT_mesh_gpu_instancing\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the EXT_mesh_gpu_instancing extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"EXT_mesh_gpu_instancing\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Vendor/EXT_mesh_gpu_instancing/README.md)\r\n * [Playground Sample](https://playground.babylonjs.com/#QFIGLW#9)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class EXT_mesh_gpu_instancing implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadNodeAsync(context: string, node: INode, assign: (babylonTransformNode: TransformNode) => void): Nullable<Promise<TransformNode>> {\r\n        return GLTFLoader.LoadExtensionAsync<IEXTMeshGpuInstancing, TransformNode>(context, node, this.name, async (extensionContext, extension) => {\r\n            this._loader._disableInstancedMesh++;\r\n\r\n            const promise = this._loader.loadNodeAsync(`/nodes/${node.index}`, node, assign);\r\n\r\n            this._loader._disableInstancedMesh--;\r\n\r\n            if (!node._primitiveBabylonMeshes) {\r\n                return await promise;\r\n            }\r\n\r\n            const promises = new Array<Promise<Nullable<Float32Array>>>();\r\n            let instanceCount = 0;\r\n\r\n            const loadAttribute = (attribute: string) => {\r\n                if (extension.attributes[attribute] == undefined) {\r\n                    promises.push(Promise.resolve(null));\r\n                    return;\r\n                }\r\n\r\n                const accessor = ArrayItem.Get(`${extensionContext}/attributes/${attribute}`, this._loader.gltf.accessors, extension.attributes[attribute]);\r\n                promises.push(this._loader._loadFloatAccessorAsync(`/accessors/${accessor.bufferView}`, accessor));\r\n\r\n                if (instanceCount === 0) {\r\n                    instanceCount = accessor.count;\r\n                } else if (instanceCount !== accessor.count) {\r\n                    throw new Error(`${extensionContext}/attributes: Instance buffer accessors do not have the same count.`);\r\n                }\r\n            };\r\n\r\n            loadAttribute(\"TRANSLATION\");\r\n            loadAttribute(\"ROTATION\");\r\n            loadAttribute(\"SCALE\");\r\n\r\n            // eslint-disable-next-line github/no-then\r\n            return await promise.then(async (babylonTransformNode) => {\r\n                const [translationBuffer, rotationBuffer, scaleBuffer] = await Promise.all(promises);\r\n                const matrices = new Float32Array(instanceCount * 16);\r\n                TmpVectors.Vector3[0].copyFromFloats(0, 0, 0); // translation\r\n                TmpVectors.Quaternion[0].copyFromFloats(0, 0, 0, 1); // rotation\r\n                TmpVectors.Vector3[1].copyFromFloats(1, 1, 1); // scale\r\n                for (let i = 0; i < instanceCount; ++i) {\r\n                    translationBuffer && Vector3.FromArrayToRef(translationBuffer, i * 3, TmpVectors.Vector3[0]);\r\n                    rotationBuffer && Quaternion.FromArrayToRef(rotationBuffer, i * 4, TmpVectors.Quaternion[0]);\r\n                    scaleBuffer && Vector3.FromArrayToRef(scaleBuffer, i * 3, TmpVectors.Vector3[1]);\r\n\r\n                    Matrix.ComposeToRef(TmpVectors.Vector3[1], TmpVectors.Quaternion[0], TmpVectors.Vector3[0], TmpVectors.Matrix[0]);\r\n\r\n                    TmpVectors.Matrix[0].copyToArray(matrices, i * 16);\r\n                }\r\n                for (const babylonMesh of node._primitiveBabylonMeshes!) {\r\n                    (babylonMesh as Mesh).thinInstanceSetBuffer(\"matrix\", matrices, 16, true);\r\n                }\r\n                return babylonTransformNode;\r\n            });\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new EXT_mesh_gpu_instancing(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { ArrayItem, GLTFLoader } from \"../glTFLoader\";\r\nimport type { IBufferView } from \"../glTFLoaderInterfaces\";\r\nimport type { IEXTMeshoptCompression } from \"babylonjs-gltf2interface\";\r\nimport { MeshoptCompression } from \"core/Meshes/Compression/meshoptCompression\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"EXT_meshopt_compression\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the EXT_meshopt_compression extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"EXT_meshopt_compression\"]: {};\r\n    }\r\n}\r\n\r\ninterface IBufferViewMeshopt extends IBufferView {\r\n    _meshOptData?: Promise<ArrayBufferView>;\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Vendor/EXT_meshopt_compression/README.md)\r\n *\r\n * This extension uses a WebAssembly decoder module from https://github.com/zeux/meshoptimizer/tree/master/js\r\n * @since 5.0.0\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class EXT_meshopt_compression implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this.enabled = loader.isExtensionUsed(NAME);\r\n        this._loader = loader;\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadBufferViewAsync(context: string, bufferView: IBufferView): Nullable<Promise<ArrayBufferView>> {\r\n        return GLTFLoader.LoadExtensionAsync<IEXTMeshoptCompression, ArrayBufferView>(context, bufferView, this.name, async (extensionContext, extension) => {\r\n            const bufferViewMeshopt = bufferView as IBufferViewMeshopt;\r\n            if (bufferViewMeshopt._meshOptData) {\r\n                return await bufferViewMeshopt._meshOptData;\r\n            }\r\n\r\n            const buffer = ArrayItem.Get(`${context}/buffer`, this._loader.gltf.buffers, extension.buffer);\r\n            bufferViewMeshopt._meshOptData = this._loader\r\n                .loadBufferAsync(`/buffers/${buffer.index}`, buffer, extension.byteOffset || 0, extension.byteLength)\r\n                // eslint-disable-next-line github/no-then\r\n                .then(async (buffer) => {\r\n                    return await MeshoptCompression.Default.decodeGltfBufferAsync(buffer as Uint8Array, extension.count, extension.byteStride, extension.mode, extension.filter);\r\n                });\r\n\r\n            return await bufferViewMeshopt._meshOptData;\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new EXT_meshopt_compression(loader));\r\n","import type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader, ArrayItem } from \"../glTFLoader\";\r\nimport type { ITexture } from \"../glTFLoaderInterfaces\";\r\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\r\nimport type { Nullable } from \"core/types\";\r\nimport type { IEXTTextureWebP } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"EXT_texture_webp\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the EXT_texture_webp extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"EXT_texture_webp\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Vendor/EXT_texture_webp/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class EXT_texture_webp implements IGLTFLoaderExtension {\r\n    /** The name of this extension. */\r\n    public readonly name = NAME;\r\n\r\n    /** Defines whether this extension is enabled. */\r\n    public enabled: boolean;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public _loadTextureAsync(context: string, texture: ITexture, assign: (babylonTexture: BaseTexture) => void): Nullable<Promise<BaseTexture>> {\r\n        return GLTFLoader.LoadExtensionAsync<IEXTTextureWebP, BaseTexture>(context, texture, this.name, async (extensionContext, extension) => {\r\n            const sampler = texture.sampler == undefined ? GLTFLoader.DefaultSampler : ArrayItem.Get(`${context}/sampler`, this._loader.gltf.samplers, texture.sampler);\r\n            const image = ArrayItem.Get(`${extensionContext}/source`, this._loader.gltf.images, extension.source);\r\n            return await this._loader._createTextureAsync(\r\n                context,\r\n                sampler,\r\n                image,\r\n                (babylonTexture) => {\r\n                    assign(babylonTexture);\r\n                },\r\n                undefined,\r\n                !texture._textureInfo.nonColorData\r\n            );\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new EXT_texture_webp(loader));\r\n","import type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader, ArrayItem } from \"../glTFLoader\";\r\nimport type { ITexture } from \"../glTFLoaderInterfaces\";\r\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\r\nimport type { Nullable } from \"core/types\";\r\nimport type { IEXTTextureAVIF } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"EXT_texture_avif\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the EXT_texture_avif extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"EXT_texture_avif\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [glTF PR](https://github.com/KhronosGroup/glTF/pull/2235)\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Vendor/EXT_texture_avif/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class EXT_texture_avif implements IGLTFLoaderExtension {\r\n    /** The name of this extension. */\r\n    public readonly name = NAME;\r\n\r\n    /** Defines whether this extension is enabled. */\r\n    public enabled: boolean;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public _loadTextureAsync(context: string, texture: ITexture, assign: (babylonTexture: BaseTexture) => void): Nullable<Promise<BaseTexture>> {\r\n        return GLTFLoader.LoadExtensionAsync<IEXTTextureAVIF, BaseTexture>(context, texture, this.name, async (extensionContext, extension) => {\r\n            const sampler = texture.sampler == undefined ? GLTFLoader.DefaultSampler : ArrayItem.Get(`${context}/sampler`, this._loader.gltf.samplers, texture.sampler);\r\n            const image = ArrayItem.Get(`${extensionContext}/source`, this._loader.gltf.images, extension.source);\r\n            return await this._loader._createTextureAsync(\r\n                context,\r\n                sampler,\r\n                image,\r\n                (babylonTexture) => {\r\n                    assign(babylonTexture);\r\n                },\r\n                undefined,\r\n                !texture._textureInfo.nonColorData\r\n            );\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new EXT_texture_avif(loader));\r\n","/* eslint-disable @typescript-eslint/naming-convention */\r\nimport type { Nullable } from \"core/types\";\r\nimport { Vector3 } from \"core/Maths/math.vector\";\r\nimport { Color3 } from \"core/Maths/math.color\";\r\nimport { SpotLight } from \"core/Lights/spotLight\";\r\nimport { Light } from \"core/Lights/light\";\r\nimport type { TransformNode } from \"core/Meshes/transformNode\";\r\n\r\nimport type { IEXTLightsIES_LightReference } from \"babylonjs-gltf2interface\";\r\nimport type { IEXTLightsIES_Light, INode } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader, ArrayItem } from \"../glTFLoader\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\nimport { Texture } from \"core/Materials/Textures/texture\";\r\n\r\nconst NAME = \"EXT_lights_ies\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the EXT_lights_ies extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"EXT_lights_ies\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Vendor/EXT_lights_ies)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class EXT_lights_ies implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /** hidden */\r\n    private _loader: GLTFLoader;\r\n    private _lights?: IEXTLightsIES_Light[];\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n        delete this._lights;\r\n    }\r\n\r\n    /** @internal */\r\n    public onLoading(): void {\r\n        const extensions = this._loader.gltf.extensions;\r\n        if (extensions && extensions[this.name]) {\r\n            const extension = extensions[this.name];\r\n            this._lights = extension.lights;\r\n            ArrayItem.Assign(this._lights);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadNodeAsync(context: string, node: INode, assign: (babylonTransformNode: TransformNode) => void): Nullable<Promise<TransformNode>> {\r\n        return GLTFLoader.LoadExtensionAsync<IEXTLightsIES_LightReference, TransformNode>(context, node, this.name, async (extensionContext, extension) => {\r\n            this._loader._allMaterialsDirtyRequired = true;\r\n\r\n            let babylonSpotLight: SpotLight;\r\n            let light: IEXTLightsIES_Light;\r\n\r\n            const transformNode = await this._loader.loadNodeAsync(context, node, (babylonMesh) => {\r\n                light = ArrayItem.Get(extensionContext, this._lights, extension.light);\r\n                const name = light.name || babylonMesh.name;\r\n\r\n                this._loader.babylonScene._blockEntityCollection = !!this._loader._assetContainer;\r\n\r\n                babylonSpotLight = new SpotLight(name, Vector3.Zero(), Vector3.Backward(), 0, 1, this._loader.babylonScene);\r\n                babylonSpotLight.angle = Math.PI / 2;\r\n                babylonSpotLight.innerAngle = 0;\r\n\r\n                babylonSpotLight._parentContainer = this._loader._assetContainer;\r\n                this._loader.babylonScene._blockEntityCollection = false;\r\n                light._babylonLight = babylonSpotLight;\r\n\r\n                babylonSpotLight.falloffType = Light.FALLOFF_GLTF;\r\n                babylonSpotLight.diffuse = extension.color ? Color3.FromArray(extension.color) : Color3.White();\r\n                babylonSpotLight.intensity = extension.multiplier || 1;\r\n                babylonSpotLight.range = Number.MAX_VALUE;\r\n                babylonSpotLight.parent = babylonMesh;\r\n\r\n                this._loader._babylonLights.push(babylonSpotLight);\r\n\r\n                GLTFLoader.AddPointerMetadata(babylonSpotLight, extensionContext);\r\n\r\n                assign(babylonMesh);\r\n            });\r\n\r\n            // Load the profile\r\n            let bufferData: ArrayBufferView;\r\n            if (light!.uri) {\r\n                bufferData = await this._loader.loadUriAsync(context, light!, light!.uri);\r\n            } else {\r\n                const bufferView = ArrayItem.Get(`${context}/bufferView`, this._loader.gltf.bufferViews, light!.bufferView);\r\n                bufferData = await this._loader.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView);\r\n            }\r\n            babylonSpotLight!.iesProfileTexture = new Texture(\r\n                name + \"_iesProfile\",\r\n                this._loader.babylonScene,\r\n                true,\r\n                false,\r\n                undefined,\r\n                null,\r\n                null,\r\n                bufferData,\r\n                true,\r\n                undefined,\r\n                undefined,\r\n                undefined,\r\n                undefined,\r\n                \".ies\"\r\n            );\r\n\r\n            return transformNode;\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new EXT_lights_ies(loader));\r\n","/* eslint-disable github/no-then */\r\nimport { DracoDecoder } from \"core/Meshes/Compression/dracoDecoder\";\r\nimport type { Nullable } from \"core/types\";\r\nimport { VertexBuffer } from \"core/Buffers/buffer\";\r\nimport type { Geometry } from \"core/Meshes/geometry\";\r\nimport type { Mesh } from \"core/Meshes/mesh\";\r\n\r\nimport { MeshPrimitiveMode } from \"babylonjs-gltf2interface\";\r\nimport type { IKHRDracoMeshCompression } from \"babylonjs-gltf2interface\";\r\nimport type { IMeshPrimitive, IBufferView } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader, ArrayItem, LoadBoundingInfoFromPositionAccessor } from \"../glTFLoader\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_draco_mesh_compression\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_draco_mesh_compression extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_draco_mesh_compression\"]: {};\r\n    }\r\n}\r\n\r\ninterface IBufferViewDraco extends IBufferView {\r\n    _dracoBabylonGeometry?: Promise<Geometry>;\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_draco_mesh_compression/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_draco_mesh_compression implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * The draco decoder used to decode vertex data or DracoDecoder.Default if not defined\r\n     */\r\n    public dracoDecoder?: DracoDecoder;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines whether to use the normalized flag from the glTF accessor instead of the Draco data. Defaults to true.\r\n     */\r\n    public useNormalizedFlagFromAccessor = true;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = DracoDecoder.DefaultAvailable && this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose(): void {\r\n        delete this.dracoDecoder;\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public _loadVertexDataAsync(context: string, primitive: IMeshPrimitive, babylonMesh: Mesh): Nullable<Promise<Geometry>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRDracoMeshCompression, Geometry>(context, primitive, this.name, async (extensionContext, extension) => {\r\n            if (primitive.mode != undefined) {\r\n                if (primitive.mode !== MeshPrimitiveMode.TRIANGLES && primitive.mode !== MeshPrimitiveMode.TRIANGLE_STRIP) {\r\n                    throw new Error(`${context}: Unsupported mode ${primitive.mode}`);\r\n                }\r\n            }\r\n\r\n            const attributes: { [kind: string]: number } = {};\r\n            const normalized: { [kind: string]: boolean } = {};\r\n            const loadAttribute = (name: string, kind: string) => {\r\n                const uniqueId = extension.attributes[name];\r\n                if (uniqueId == undefined) {\r\n                    return;\r\n                }\r\n\r\n                babylonMesh._delayInfo = babylonMesh._delayInfo || [];\r\n                if (babylonMesh._delayInfo.indexOf(kind) === -1) {\r\n                    babylonMesh._delayInfo.push(kind);\r\n                }\r\n\r\n                attributes[kind] = uniqueId;\r\n\r\n                if (this.useNormalizedFlagFromAccessor) {\r\n                    const accessor = ArrayItem.TryGet(this._loader.gltf.accessors, primitive.attributes[name]);\r\n                    if (accessor) {\r\n                        normalized[kind] = accessor.normalized || false;\r\n                    }\r\n                }\r\n            };\r\n\r\n            loadAttribute(\"POSITION\", VertexBuffer.PositionKind);\r\n            loadAttribute(\"NORMAL\", VertexBuffer.NormalKind);\r\n            loadAttribute(\"TANGENT\", VertexBuffer.TangentKind);\r\n            loadAttribute(\"TEXCOORD_0\", VertexBuffer.UVKind);\r\n            loadAttribute(\"TEXCOORD_1\", VertexBuffer.UV2Kind);\r\n            loadAttribute(\"TEXCOORD_2\", VertexBuffer.UV3Kind);\r\n            loadAttribute(\"TEXCOORD_3\", VertexBuffer.UV4Kind);\r\n            loadAttribute(\"TEXCOORD_4\", VertexBuffer.UV5Kind);\r\n            loadAttribute(\"TEXCOORD_5\", VertexBuffer.UV6Kind);\r\n            loadAttribute(\"JOINTS_0\", VertexBuffer.MatricesIndicesKind);\r\n            loadAttribute(\"WEIGHTS_0\", VertexBuffer.MatricesWeightsKind);\r\n            loadAttribute(\"COLOR_0\", VertexBuffer.ColorKind);\r\n\r\n            const bufferView = ArrayItem.Get(extensionContext, this._loader.gltf.bufferViews, extension.bufferView) as IBufferViewDraco;\r\n            if (!bufferView._dracoBabylonGeometry) {\r\n                bufferView._dracoBabylonGeometry = this._loader.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView).then(async (data) => {\r\n                    const dracoDecoder = this.dracoDecoder || DracoDecoder.Default;\r\n                    const positionAccessor = ArrayItem.TryGet(this._loader.gltf.accessors, primitive.attributes[\"POSITION\"]);\r\n                    const babylonBoundingInfo =\r\n                        !this._loader.parent.alwaysComputeBoundingBox && !babylonMesh.skeleton && positionAccessor ? LoadBoundingInfoFromPositionAccessor(positionAccessor) : null;\r\n                    return await dracoDecoder\r\n                        ._decodeMeshToGeometryForGltfAsync(babylonMesh.name, this._loader.babylonScene, data, attributes, normalized, babylonBoundingInfo)\r\n                        .catch((error) => {\r\n                            throw new Error(`${context}: ${error.message}`);\r\n                        });\r\n                });\r\n            }\r\n\r\n            return await bufferView._dracoBabylonGeometry;\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_draco_mesh_compression(loader));\r\n","/* eslint-disable @typescript-eslint/naming-convention */\r\nimport type { Nullable } from \"core/types\";\r\nimport { Vector3 } from \"core/Maths/math.vector\";\r\nimport { Color3 } from \"core/Maths/math.color\";\r\nimport { DirectionalLight } from \"core/Lights/directionalLight\";\r\nimport { PointLight } from \"core/Lights/pointLight\";\r\nimport { SpotLight } from \"core/Lights/spotLight\";\r\nimport { Light } from \"core/Lights/light\";\r\nimport type { TransformNode } from \"core/Meshes/transformNode\";\r\n\r\nimport type { IKHRLightsPunctual_LightReference } from \"babylonjs-gltf2interface\";\r\nimport { KHRLightsPunctual_LightType } from \"babylonjs-gltf2interface\";\r\nimport type { INode, IKHRLightsPunctual_Light } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader, ArrayItem } from \"../glTFLoader\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_lights_punctual\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_lights_punctual extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_lights_punctual\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_lights_punctual/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_lights implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /** hidden */\r\n    private _loader: GLTFLoader;\r\n    private _lights?: IKHRLightsPunctual_Light[];\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n        delete this._lights;\r\n    }\r\n\r\n    /** @internal */\r\n    public onLoading(): void {\r\n        const extensions = this._loader.gltf.extensions;\r\n        if (extensions && extensions[this.name]) {\r\n            const extension = extensions[this.name];\r\n            this._lights = extension.lights;\r\n            ArrayItem.Assign(this._lights);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadNodeAsync(context: string, node: INode, assign: (babylonTransformNode: TransformNode) => void): Nullable<Promise<TransformNode>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRLightsPunctual_LightReference, TransformNode>(context, node, this.name, async (extensionContext, extension) => {\r\n            this._loader._allMaterialsDirtyRequired = true;\r\n\r\n            return await this._loader.loadNodeAsync(context, node, (babylonMesh) => {\r\n                let babylonLight: Light;\r\n\r\n                const light = ArrayItem.Get(extensionContext, this._lights, extension.light);\r\n                const name = light.name || babylonMesh.name;\r\n\r\n                this._loader.babylonScene._blockEntityCollection = !!this._loader._assetContainer;\r\n\r\n                switch (light.type) {\r\n                    case KHRLightsPunctual_LightType.DIRECTIONAL: {\r\n                        const babylonDirectionalLight = new DirectionalLight(name, Vector3.Backward(), this._loader.babylonScene);\r\n                        babylonDirectionalLight.position.setAll(0);\r\n                        babylonLight = babylonDirectionalLight;\r\n                        break;\r\n                    }\r\n                    case KHRLightsPunctual_LightType.POINT: {\r\n                        babylonLight = new PointLight(name, Vector3.Zero(), this._loader.babylonScene);\r\n                        break;\r\n                    }\r\n                    case KHRLightsPunctual_LightType.SPOT: {\r\n                        const babylonSpotLight = new SpotLight(name, Vector3.Zero(), Vector3.Backward(), 0, 1, this._loader.babylonScene);\r\n                        babylonSpotLight.angle = ((light.spot && light.spot.outerConeAngle) || Math.PI / 4) * 2;\r\n                        babylonSpotLight.innerAngle = ((light.spot && light.spot.innerConeAngle) || 0) * 2;\r\n                        babylonLight = babylonSpotLight;\r\n                        break;\r\n                    }\r\n                    default: {\r\n                        this._loader.babylonScene._blockEntityCollection = false;\r\n                        throw new Error(`${extensionContext}: Invalid light type (${light.type})`);\r\n                    }\r\n                }\r\n\r\n                babylonLight._parentContainer = this._loader._assetContainer;\r\n                this._loader.babylonScene._blockEntityCollection = false;\r\n                light._babylonLight = babylonLight;\r\n\r\n                babylonLight.falloffType = Light.FALLOFF_GLTF;\r\n                babylonLight.diffuse = light.color ? Color3.FromArray(light.color) : Color3.White();\r\n                babylonLight.intensity = light.intensity == undefined ? 1 : light.intensity;\r\n                babylonLight.range = light.range == undefined ? Number.MAX_VALUE : light.range;\r\n                babylonLight.parent = babylonMesh;\r\n\r\n                this._loader._babylonLights.push(babylonLight);\r\n\r\n                GLTFLoader.AddPointerMetadata(babylonLight, extensionContext);\r\n\r\n                assign(babylonMesh);\r\n            });\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_lights(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport { Color3 } from \"core/Maths/math.color\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\n\r\nimport type { IMaterial } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IKHRMaterialsPbrSpecularGlossiness } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_materials_pbrSpecularGlossiness\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_pbrSpecularGlossiness extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_pbrSpecularGlossiness\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Archived/KHR_materials_pbrSpecularGlossiness/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_pbrSpecularGlossiness implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 200;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsPbrSpecularGlossiness>(context, material, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(this._loader.loadMaterialBasePropertiesAsync(context, material, babylonMaterial));\r\n            promises.push(this._loadSpecularGlossinessPropertiesAsync(extensionContext, extension, babylonMaterial));\r\n            this._loader.loadMaterialAlphaProperties(context, material, babylonMaterial);\r\n            // eslint-disable-next-line github/no-then\r\n            return await Promise.all(promises).then(() => {});\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadSpecularGlossinessPropertiesAsync(context: string, properties: IKHRMaterialsPbrSpecularGlossiness, babylonMaterial: Material): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        const promises = new Array<Promise<any>>();\r\n\r\n        babylonMaterial.metallic = null;\r\n        babylonMaterial.roughness = null;\r\n\r\n        if (properties.diffuseFactor) {\r\n            babylonMaterial.albedoColor = Color3.FromArray(properties.diffuseFactor);\r\n            babylonMaterial.alpha = properties.diffuseFactor[3];\r\n        } else {\r\n            babylonMaterial.albedoColor = Color3.White();\r\n        }\r\n\r\n        babylonMaterial.reflectivityColor = properties.specularFactor ? Color3.FromArray(properties.specularFactor) : Color3.White();\r\n        babylonMaterial.microSurface = properties.glossinessFactor == undefined ? 1 : properties.glossinessFactor;\r\n\r\n        if (properties.diffuseTexture) {\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/diffuseTexture`, properties.diffuseTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Diffuse)`;\r\n                    babylonMaterial.albedoTexture = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        if (properties.specularGlossinessTexture) {\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/specularGlossinessTexture`, properties.specularGlossinessTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Specular Glossiness)`;\r\n                    babylonMaterial.reflectivityTexture = texture;\r\n                    babylonMaterial.reflectivityTexture.hasAlpha = true;\r\n                })\r\n            );\r\n\r\n            babylonMaterial.useMicroSurfaceFromReflectivityMapAlpha = true;\r\n        }\r\n\r\n        // eslint-disable-next-line github/no-then\r\n        return Promise.all(promises).then(() => {});\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_pbrSpecularGlossiness(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport { Color3 } from \"core/Maths/math.color\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\n\r\nimport type { IMaterial } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_materials_unlit\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_unlit extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_unlit\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_unlit/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_unlit implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 210;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync(context, material, this.name, async () => {\r\n            return await this._loadUnlitPropertiesAsync(context, material, babylonMaterial);\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadUnlitPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        const promises = new Array<Promise<any>>();\r\n        babylonMaterial.unlit = true;\r\n\r\n        const properties = material.pbrMetallicRoughness;\r\n        if (properties) {\r\n            if (properties.baseColorFactor) {\r\n                babylonMaterial.albedoColor = Color3.FromArray(properties.baseColorFactor);\r\n                babylonMaterial.alpha = properties.baseColorFactor[3];\r\n            } else {\r\n                babylonMaterial.albedoColor = Color3.White();\r\n            }\r\n\r\n            if (properties.baseColorTexture) {\r\n                promises.push(\r\n                    this._loader.loadTextureInfoAsync(`${context}/baseColorTexture`, properties.baseColorTexture, (texture) => {\r\n                        texture.name = `${babylonMaterial.name} (Base Color)`;\r\n                        babylonMaterial.albedoTexture = texture;\r\n                    })\r\n                );\r\n            }\r\n        }\r\n\r\n        if (material.doubleSided) {\r\n            babylonMaterial.backFaceCulling = false;\r\n            babylonMaterial.twoSidedLighting = true;\r\n        }\r\n\r\n        this._loader.loadMaterialAlphaProperties(context, material, babylonMaterial);\r\n\r\n        // eslint-disable-next-line github/no-then\r\n        return Promise.all(promises).then(() => {});\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_unlit(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\n\r\nimport type { IMaterial, ITextureInfo } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IKHRMaterialsClearcoat } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_materials_clearcoat\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_clearcoat extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_clearcoat\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_clearcoat/README.md)\r\n * [Playground Sample](https://www.babylonjs-playground.com/frame.html#7F7PN6#8)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_clearcoat implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 190;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsClearcoat>(context, material, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));\r\n            promises.push(this._loadClearCoatPropertiesAsync(extensionContext, extension, babylonMaterial));\r\n            await Promise.all(promises);\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadClearCoatPropertiesAsync(context: string, properties: IKHRMaterialsClearcoat, babylonMaterial: Material): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        const promises = new Array<Promise<any>>();\r\n\r\n        babylonMaterial.clearCoat.isEnabled = true;\r\n        babylonMaterial.clearCoat.useRoughnessFromMainTexture = false;\r\n        babylonMaterial.clearCoat.remapF0OnInterfaceChange = false;\r\n\r\n        if (properties.clearcoatFactor != undefined) {\r\n            babylonMaterial.clearCoat.intensity = properties.clearcoatFactor;\r\n        } else {\r\n            babylonMaterial.clearCoat.intensity = 0;\r\n        }\r\n\r\n        if (properties.clearcoatTexture) {\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/clearcoatTexture`, properties.clearcoatTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (ClearCoat)`;\r\n                    babylonMaterial.clearCoat.texture = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        if (properties.clearcoatRoughnessFactor != undefined) {\r\n            babylonMaterial.clearCoat.roughness = properties.clearcoatRoughnessFactor;\r\n        } else {\r\n            babylonMaterial.clearCoat.roughness = 0;\r\n        }\r\n\r\n        if (properties.clearcoatRoughnessTexture) {\r\n            (properties.clearcoatRoughnessTexture as ITextureInfo).nonColorData = true;\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/clearcoatRoughnessTexture`, properties.clearcoatRoughnessTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (ClearCoat Roughness)`;\r\n                    babylonMaterial.clearCoat.textureRoughness = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        if (properties.clearcoatNormalTexture) {\r\n            (properties.clearcoatNormalTexture as ITextureInfo).nonColorData = true;\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/clearcoatNormalTexture`, properties.clearcoatNormalTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (ClearCoat Normal)`;\r\n                    babylonMaterial.clearCoat.bumpTexture = texture;\r\n                })\r\n            );\r\n\r\n            babylonMaterial.invertNormalMapX = !babylonMaterial.getScene().useRightHandedSystem;\r\n            babylonMaterial.invertNormalMapY = babylonMaterial.getScene().useRightHandedSystem;\r\n            if (properties.clearcoatNormalTexture.scale != undefined) {\r\n                babylonMaterial.clearCoat.bumpTexture!.level = properties.clearcoatNormalTexture.scale;\r\n            }\r\n        }\r\n\r\n        // eslint-disable-next-line github/no-then\r\n        return Promise.all(promises).then(() => {});\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_clearcoat(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\n\r\nimport type { IMaterial } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IKHRMaterialsIridescence } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_materials_iridescence\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_iridescence extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_iridescence\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_iridescence/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_iridescence implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 195;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsIridescence>(context, material, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));\r\n            promises.push(this._loadIridescencePropertiesAsync(extensionContext, extension, babylonMaterial));\r\n            // eslint-disable-next-line github/no-then\r\n            return await Promise.all(promises).then(() => {});\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadIridescencePropertiesAsync(context: string, properties: IKHRMaterialsIridescence, babylonMaterial: Material): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        const promises = new Array<Promise<any>>();\r\n\r\n        babylonMaterial.iridescence.isEnabled = true;\r\n\r\n        babylonMaterial.iridescence.intensity = properties.iridescenceFactor ?? 0;\r\n        babylonMaterial.iridescence.indexOfRefraction = properties.iridescenceIor ?? (properties as any).iridescenceIOR ?? 1.3;\r\n        babylonMaterial.iridescence.minimumThickness = properties.iridescenceThicknessMinimum ?? 100;\r\n        babylonMaterial.iridescence.maximumThickness = properties.iridescenceThicknessMaximum ?? 400;\r\n\r\n        if (properties.iridescenceTexture) {\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/iridescenceTexture`, properties.iridescenceTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Iridescence)`;\r\n                    babylonMaterial.iridescence.texture = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        if (properties.iridescenceThicknessTexture) {\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/iridescenceThicknessTexture`, properties.iridescenceThicknessTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Iridescence Thickness)`;\r\n                    babylonMaterial.iridescence.thicknessTexture = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        // eslint-disable-next-line github/no-then\r\n        return Promise.all(promises).then(() => {});\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_iridescence(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\n\r\nimport type { IMaterial, ITextureInfo } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IKHRMaterialsAnisotropy } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_materials_anisotropy\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_anisotropy extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_anisotropy\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_anisotropy)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_anisotropy implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 195;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsAnisotropy>(context, material, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));\r\n            promises.push(this._loadIridescencePropertiesAsync(extensionContext, extension, babylonMaterial));\r\n            await Promise.all(promises);\r\n        });\r\n    }\r\n\r\n    private async _loadIridescencePropertiesAsync(context: string, properties: IKHRMaterialsAnisotropy, babylonMaterial: Material): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        const promises = new Array<Promise<any>>();\r\n\r\n        babylonMaterial.anisotropy.isEnabled = true;\r\n\r\n        babylonMaterial.anisotropy.intensity = properties.anisotropyStrength ?? 0;\r\n        babylonMaterial.anisotropy.angle = properties.anisotropyRotation ?? 0;\r\n\r\n        if (properties.anisotropyTexture) {\r\n            (properties.anisotropyTexture as ITextureInfo).nonColorData = true;\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/anisotropyTexture`, properties.anisotropyTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Anisotropy Intensity)`;\r\n                    babylonMaterial.anisotropy.texture = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        await Promise.all(promises);\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_anisotropy(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\n\r\nimport type { IMaterial } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IKHRMaterialsEmissiveStrength } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_materials_emissive_strength\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_emissive_strength extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_emissive_strength\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_emissive_strength/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_emissive_strength implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 170;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsEmissiveStrength>(context, material, this.name, async (extensionContext, extension) => {\r\n            // eslint-disable-next-line github/no-then\r\n            return await this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial).then(() => {\r\n                this._loadEmissiveProperties(extensionContext, extension, babylonMaterial);\r\n            });\r\n        });\r\n    }\r\n\r\n    private _loadEmissiveProperties(context: string, properties: IKHRMaterialsEmissiveStrength, babylonMaterial: Material): void {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        if (properties.emissiveStrength !== undefined) {\r\n            babylonMaterial.emissiveIntensity = properties.emissiveStrength;\r\n        }\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_emissive_strength(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\n\r\nimport type { IMaterial, ITextureInfo } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport { Color3 } from \"core/Maths/math.color\";\r\nimport type { IKHRMaterialsSheen } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_materials_sheen\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_sheen extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_sheen\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_sheen/README.md)\r\n * [Playground Sample](https://www.babylonjs-playground.com/frame.html#BNIZX6#4)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_sheen implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 190;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsSheen>(context, material, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));\r\n            promises.push(this._loadSheenPropertiesAsync(extensionContext, extension, babylonMaterial));\r\n            // eslint-disable-next-line github/no-then\r\n            return await Promise.all(promises).then(() => {});\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadSheenPropertiesAsync(context: string, properties: IKHRMaterialsSheen, babylonMaterial: Material): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        const promises = new Array<Promise<any>>();\r\n\r\n        babylonMaterial.sheen.isEnabled = true;\r\n        babylonMaterial.sheen.intensity = 1;\r\n\r\n        if (properties.sheenColorFactor != undefined) {\r\n            babylonMaterial.sheen.color = Color3.FromArray(properties.sheenColorFactor);\r\n        } else {\r\n            babylonMaterial.sheen.color = Color3.Black();\r\n        }\r\n\r\n        if (properties.sheenColorTexture) {\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/sheenColorTexture`, properties.sheenColorTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Sheen Color)`;\r\n                    babylonMaterial.sheen.texture = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        if (properties.sheenRoughnessFactor !== undefined) {\r\n            babylonMaterial.sheen.roughness = properties.sheenRoughnessFactor;\r\n        } else {\r\n            babylonMaterial.sheen.roughness = 0;\r\n        }\r\n\r\n        if (properties.sheenRoughnessTexture) {\r\n            (properties.sheenRoughnessTexture as ITextureInfo).nonColorData = true;\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/sheenRoughnessTexture`, properties.sheenRoughnessTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Sheen Roughness)`;\r\n                    babylonMaterial.sheen.textureRoughness = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        babylonMaterial.sheen.albedoScaling = true;\r\n        babylonMaterial.sheen.useRoughnessFromMainTexture = false;\r\n\r\n        // eslint-disable-next-line github/no-then\r\n        return Promise.all(promises).then(() => {});\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_sheen(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\n\r\nimport type { IMaterial, ITextureInfo } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport { Color3 } from \"core/Maths/math.color\";\r\nimport { Constants } from \"core/Engines/constants\";\r\nimport type { IEXTMaterialsSpecularEdgeColor, IKHRMaterialsSpecular } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_materials_specular\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_specular extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_specular\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_specular/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_specular implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 190;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsSpecular>(context, material, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));\r\n            promises.push(this._loadSpecularPropertiesAsync(extensionContext, extension, babylonMaterial));\r\n            // Handle the EXT_materials_specular_edge_color sub-extension\r\n            // https://github.com/KhronosGroup/glTF/blob/2a1111b88f052cbd3e2d82abb9faee56e7494904/extensions/2.0/Vendor/EXT_materials_specular_edge_color/README.md\r\n            if (extension.extensions && extension.extensions.EXT_materials_specular_edge_color && babylonMaterial instanceof PBRMaterial) {\r\n                const specularEdgeColorExtension = extension.extensions.EXT_materials_specular_edge_color as IEXTMaterialsSpecularEdgeColor;\r\n                if (specularEdgeColorExtension.specularEdgeColorEnabled) {\r\n                    babylonMaterial.brdf.dielectricSpecularModel = Constants.MATERIAL_DIELECTRIC_SPECULAR_MODEL_OPENPBR;\r\n                    babylonMaterial.brdf.conductorSpecularModel = Constants.MATERIAL_CONDUCTOR_SPECULAR_MODEL_OPENPBR;\r\n                }\r\n            }\r\n            // eslint-disable-next-line github/no-then\r\n            return await Promise.all(promises).then(() => {});\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadSpecularPropertiesAsync(context: string, properties: IKHRMaterialsSpecular, babylonMaterial: Material): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        const promises = new Array<Promise<any>>();\r\n\r\n        if (properties.specularFactor !== undefined) {\r\n            babylonMaterial.metallicF0Factor = properties.specularFactor;\r\n        }\r\n\r\n        if (properties.specularColorFactor !== undefined) {\r\n            babylonMaterial.metallicReflectanceColor = Color3.FromArray(properties.specularColorFactor);\r\n        }\r\n\r\n        if (properties.specularTexture) {\r\n            (properties.specularTexture as ITextureInfo).nonColorData = true;\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/specularTexture`, properties.specularTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Specular)`;\r\n                    babylonMaterial.metallicReflectanceTexture = texture;\r\n                    babylonMaterial.useOnlyMetallicFromMetallicReflectanceTexture = true;\r\n                })\r\n            );\r\n        }\r\n\r\n        if (properties.specularColorTexture) {\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/specularColorTexture`, properties.specularColorTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Specular Color)`;\r\n                    babylonMaterial.reflectanceTexture = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        // eslint-disable-next-line github/no-then\r\n        return Promise.all(promises).then(() => {});\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_specular(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\n\r\nimport type { IMaterial } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IKHRMaterialsIor } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_materials_ior\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_ior extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_ior\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_ior/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_ior implements IGLTFLoaderExtension {\r\n    /**\r\n     * Default ior Value from the spec.\r\n     */\r\n    private static readonly _DEFAULT_IOR = 1.5;\r\n\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 180;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsIor>(context, material, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));\r\n            promises.push(this._loadIorPropertiesAsync(extensionContext, extension, babylonMaterial));\r\n            // eslint-disable-next-line github/no-then\r\n            return await Promise.all(promises).then(() => {});\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadIorPropertiesAsync(context: string, properties: IKHRMaterialsIor, babylonMaterial: Material): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        if (properties.ior !== undefined) {\r\n            babylonMaterial.indexOfRefraction = properties.ior;\r\n        } else {\r\n            babylonMaterial.indexOfRefraction = KHR_materials_ior._DEFAULT_IOR;\r\n        }\r\n\r\n        return Promise.resolve();\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_ior(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader, ArrayItem } from \"../glTFLoader\";\r\n\r\nimport type { Material } from \"core/Materials/material\";\r\nimport { Mesh } from \"core/Meshes/mesh\";\r\nimport type { Node } from \"core/node\";\r\nimport type { AbstractMesh } from \"core/Meshes/abstractMesh\";\r\nimport type { INode, IMeshPrimitive, IMesh } from \"../glTFLoaderInterfaces\";\r\nimport type { IKHRMaterialVariants_Mapping, IKHRMaterialVariants_Variant, IKHRMaterialVariants_Variants } from \"babylonjs-gltf2interface\";\r\nimport type { TransformNode } from \"core/Meshes/transformNode\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\nimport type { MaterialVariantsController } from \"../../glTFFileLoader\";\r\n\r\nconst NAME = \"KHR_materials_variants\";\r\n\r\nexport { MaterialVariantsController };\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // Define options related types here so they can be referenced in the options,\r\n    // but export the types at the module level. This ensures the types are in the\r\n    // correct namespace for UMD.\r\n    type MaterialVariantsController = {\r\n        /**\r\n         * The list of available variant names for this asset.\r\n         */\r\n        readonly variants: readonly string[];\r\n\r\n        /**\r\n         * Gets or sets the selected variant.\r\n         */\r\n        selectedVariant: string;\r\n    };\r\n\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_variants extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_variants\"]: Partial<{\r\n            /**\r\n             * Specifies the name of the variant that should be selected by default.\r\n             */\r\n            defaultVariant: string;\r\n\r\n            /**\r\n             * Defines a callback that will be called if material variants are loaded.\r\n             * @experimental\r\n             */\r\n            onLoaded: (controller: MaterialVariantsController) => void;\r\n        }>;\r\n    }\r\n}\r\n\r\ninterface IVariantsMap {\r\n    [key: string]: Array<{ mesh: AbstractMesh; material: Nullable<Material> }>;\r\n}\r\n\r\ninterface IExtensionMetadata {\r\n    lastSelected: Nullable<string | Array<string>>;\r\n    original: Array<{ mesh: AbstractMesh; material: Nullable<Material> }>;\r\n    variants: IVariantsMap;\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_variants/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_variants implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    private _variants?: Array<IKHRMaterialVariants_Variant>;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME) && !this._loader.parent.skipMaterials;\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * Gets the list of available variant names for this asset.\r\n     * @param rootNode The glTF root node\r\n     * @returns the list of all the variant names for this model\r\n     */\r\n    public static GetAvailableVariants(rootNode: TransformNode): string[] {\r\n        const extensionMetadata = this._GetExtensionMetadata(rootNode);\r\n        if (!extensionMetadata) {\r\n            return [];\r\n        }\r\n\r\n        return Object.keys(extensionMetadata.variants);\r\n    }\r\n\r\n    /**\r\n     * Gets the list of available variant names for this asset.\r\n     * @param rootNode The glTF root node\r\n     * @returns the list of all the variant names for this model\r\n     */\r\n    public getAvailableVariants(rootNode: TransformNode): string[] {\r\n        return KHR_materials_variants.GetAvailableVariants(rootNode);\r\n    }\r\n\r\n    /**\r\n     * Select a variant given a variant name or a list of variant names.\r\n     * @param rootNode The glTF root node\r\n     * @param variantName The variant name(s) to select.\r\n     */\r\n    public static SelectVariant(rootNode: TransformNode, variantName: string | string[]): void {\r\n        const extensionMetadata = this._GetExtensionMetadata(rootNode);\r\n        if (!extensionMetadata) {\r\n            throw new Error(`Cannot select variant on a glTF mesh that does not have the ${NAME} extension`);\r\n        }\r\n\r\n        const select = (variantName: string): void => {\r\n            const entries = extensionMetadata.variants[variantName];\r\n            if (entries) {\r\n                for (const entry of entries) {\r\n                    entry.mesh.material = entry.material;\r\n                }\r\n            }\r\n        };\r\n\r\n        if (variantName instanceof Array) {\r\n            for (const name of variantName) {\r\n                select(name);\r\n            }\r\n        } else {\r\n            select(variantName);\r\n        }\r\n\r\n        extensionMetadata.lastSelected = variantName;\r\n    }\r\n\r\n    /**\r\n     * Select a variant given a variant name or a list of variant names.\r\n     * @param rootNode The glTF root node\r\n     * @param variantName The variant name(s) to select.\r\n     */\r\n    public selectVariant(rootNode: TransformNode, variantName: string | string[]): void {\r\n        KHR_materials_variants.SelectVariant(rootNode, variantName);\r\n    }\r\n\r\n    /**\r\n     * Reset back to the original before selecting a variant.\r\n     * @param rootNode The glTF root node\r\n     */\r\n    public static Reset(rootNode: TransformNode): void {\r\n        const extensionMetadata = this._GetExtensionMetadata(rootNode);\r\n        if (!extensionMetadata) {\r\n            throw new Error(`Cannot reset on a glTF mesh that does not have the ${NAME} extension`);\r\n        }\r\n\r\n        for (const entry of extensionMetadata.original) {\r\n            entry.mesh.material = entry.material;\r\n        }\r\n\r\n        extensionMetadata.lastSelected = null;\r\n    }\r\n\r\n    /**\r\n     * Reset back to the original before selecting a variant.\r\n     * @param rootNode The glTF root node\r\n     */\r\n    public reset(rootNode: TransformNode): void {\r\n        KHR_materials_variants.Reset(rootNode);\r\n    }\r\n\r\n    /**\r\n     * Gets the last selected variant name(s) or null if original.\r\n     * @param rootNode The glTF root node\r\n     * @returns The selected variant name(s).\r\n     */\r\n    public static GetLastSelectedVariant(rootNode: TransformNode): Nullable<string | string[]> {\r\n        const extensionMetadata = this._GetExtensionMetadata(rootNode);\r\n        if (!extensionMetadata) {\r\n            throw new Error(`Cannot get the last selected variant on a glTF mesh that does not have the ${NAME} extension`);\r\n        }\r\n\r\n        return extensionMetadata.lastSelected;\r\n    }\r\n\r\n    /**\r\n     * Gets the last selected variant name(s) or null if original.\r\n     * @param rootNode The glTF root node\r\n     * @returns The selected variant name(s).\r\n     */\r\n    public getLastSelectedVariant(rootNode: TransformNode): Nullable<string | string[]> {\r\n        return KHR_materials_variants.GetLastSelectedVariant(rootNode);\r\n    }\r\n\r\n    private static _GetExtensionMetadata(rootNode: Nullable<TransformNode>): Nullable<IExtensionMetadata> {\r\n        return rootNode?._internalMetadata?.gltf?.[NAME] || null;\r\n    }\r\n\r\n    /** @internal */\r\n    public onLoading(): void {\r\n        const extensions = this._loader.gltf.extensions;\r\n        if (extensions && extensions[this.name]) {\r\n            const extension = extensions[this.name] as IKHRMaterialVariants_Variants;\r\n            this._variants = extension.variants;\r\n        }\r\n    }\r\n\r\n    /** @internal */\r\n    public onReady(): void {\r\n        const rootNode = this._loader.rootBabylonMesh;\r\n        if (rootNode) {\r\n            const options = this._loader.parent.extensionOptions[NAME];\r\n            if (options?.defaultVariant) {\r\n                KHR_materials_variants.SelectVariant(rootNode, options.defaultVariant);\r\n            }\r\n\r\n            options?.onLoaded?.({\r\n                get variants() {\r\n                    return KHR_materials_variants.GetAvailableVariants(rootNode);\r\n                },\r\n                get selectedVariant(): string {\r\n                    const lastSelectedVariant = KHR_materials_variants.GetLastSelectedVariant(rootNode);\r\n                    if (!lastSelectedVariant) {\r\n                        return KHR_materials_variants.GetAvailableVariants(rootNode)[0];\r\n                    }\r\n                    if (Array.isArray(lastSelectedVariant)) {\r\n                        return lastSelectedVariant[0];\r\n                    }\r\n                    return lastSelectedVariant;\r\n                },\r\n                set selectedVariant(variantName) {\r\n                    KHR_materials_variants.SelectVariant(rootNode, variantName);\r\n                },\r\n            });\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public _loadMeshPrimitiveAsync(\r\n        context: string,\r\n        name: string,\r\n        node: INode,\r\n        mesh: IMesh,\r\n        primitive: IMeshPrimitive,\r\n        assign: (babylonMesh: AbstractMesh) => void\r\n    ): Nullable<Promise<AbstractMesh>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialVariants_Mapping, AbstractMesh>(context, primitive, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(\r\n                this._loader._loadMeshPrimitiveAsync(context, name, node, mesh, primitive, (babylonMesh) => {\r\n                    assign(babylonMesh);\r\n\r\n                    if (babylonMesh instanceof Mesh) {\r\n                        const babylonDrawMode = GLTFLoader._GetDrawMode(context, primitive.mode);\r\n\r\n                        const root = this._loader.rootBabylonMesh;\r\n                        const metadata = root ? (root._internalMetadata = root._internalMetadata || {}) : {};\r\n                        const gltf = (metadata.gltf = metadata.gltf || {});\r\n                        const extensionMetadata: IExtensionMetadata = (gltf[NAME] = gltf[NAME] || { lastSelected: null, original: [], variants: {} });\r\n\r\n                        // Store the original material.\r\n                        extensionMetadata.original.push({ mesh: babylonMesh, material: babylonMesh.material });\r\n\r\n                        // For each mapping, look at the variants and make a new entry for them.\r\n                        for (let mappingIndex = 0; mappingIndex < extension.mappings.length; ++mappingIndex) {\r\n                            const mapping = extension.mappings[mappingIndex];\r\n                            const material = ArrayItem.Get(`${extensionContext}/mappings/${mappingIndex}/material`, this._loader.gltf.materials, mapping.material);\r\n                            promises.push(\r\n                                this._loader._loadMaterialAsync(`#/materials/${mapping.material}`, material, babylonMesh, babylonDrawMode, (babylonMaterial) => {\r\n                                    for (let mappingVariantIndex = 0; mappingVariantIndex < mapping.variants.length; ++mappingVariantIndex) {\r\n                                        const variantIndex = mapping.variants[mappingVariantIndex];\r\n                                        const variant = ArrayItem.Get(`/extensions/${NAME}/variants/${variantIndex}`, this._variants, variantIndex);\r\n                                        extensionMetadata.variants[variant.name] = extensionMetadata.variants[variant.name] || [];\r\n                                        extensionMetadata.variants[variant.name].push({\r\n                                            mesh: babylonMesh,\r\n                                            material: babylonMaterial,\r\n                                        });\r\n\r\n                                        // Replace the target when original mesh is cloned\r\n                                        babylonMesh.onClonedObservable.add((newOne: Node) => {\r\n                                            const newMesh = newOne as Mesh;\r\n                                            let metadata: Nullable<IExtensionMetadata> = null;\r\n                                            let newRoot: Nullable<Node> = newMesh;\r\n\r\n                                            // Find root to get medata\r\n                                            do {\r\n                                                newRoot = newRoot.parent;\r\n                                                if (!newRoot) {\r\n                                                    return;\r\n                                                }\r\n                                                metadata = KHR_materials_variants._GetExtensionMetadata(newRoot as Mesh);\r\n                                            } while (metadata === null);\r\n\r\n                                            // Need to clone the metadata on the root (first time only)\r\n                                            if (root && metadata === KHR_materials_variants._GetExtensionMetadata(root)) {\r\n                                                // Copy main metadata\r\n                                                newRoot._internalMetadata = {};\r\n                                                for (const key in root._internalMetadata) {\r\n                                                    newRoot._internalMetadata[key] = root._internalMetadata[key];\r\n                                                }\r\n\r\n                                                // Copy the gltf metadata\r\n                                                newRoot._internalMetadata.gltf = [];\r\n                                                for (const key in root._internalMetadata.gltf) {\r\n                                                    newRoot._internalMetadata.gltf[key] = root._internalMetadata.gltf[key];\r\n                                                }\r\n\r\n                                                // Duplicate the extension specific metadata\r\n                                                newRoot._internalMetadata.gltf[NAME] = { lastSelected: null, original: [], variants: {} };\r\n                                                for (const original of metadata.original) {\r\n                                                    newRoot._internalMetadata.gltf[NAME].original.push({\r\n                                                        mesh: original.mesh,\r\n                                                        material: original.material,\r\n                                                    });\r\n                                                }\r\n                                                for (const key in metadata.variants) {\r\n                                                    if (Object.prototype.hasOwnProperty.call(metadata.variants, key)) {\r\n                                                        newRoot._internalMetadata.gltf[NAME].variants[key] = [];\r\n                                                        for (const variantEntry of metadata.variants[key]) {\r\n                                                            newRoot._internalMetadata.gltf[NAME].variants[key].push({\r\n                                                                mesh: variantEntry.mesh,\r\n                                                                material: variantEntry.material,\r\n                                                            });\r\n                                                        }\r\n                                                    }\r\n                                                }\r\n\r\n                                                metadata = newRoot._internalMetadata.gltf[NAME];\r\n                                            }\r\n\r\n                                            // Relocate\r\n                                            for (const target of metadata!.original) {\r\n                                                if (target.mesh === babylonMesh) {\r\n                                                    target.mesh = newMesh;\r\n                                                }\r\n                                            }\r\n                                            for (const target of metadata!.variants[variant.name]) {\r\n                                                if (target.mesh === babylonMesh) {\r\n                                                    target.mesh = newMesh;\r\n                                                }\r\n                                            }\r\n                                        });\r\n                                    }\r\n                                })\r\n                            );\r\n                        }\r\n                    }\r\n                })\r\n            );\r\n            // eslint-disable-next-line github/no-then\r\n            return await Promise.all(promises).then(([babylonMesh]) => {\r\n                return babylonMesh;\r\n            });\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_variants(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\r\nimport type { IMaterial, ITextureInfo } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IKHRMaterialsTransmission } from \"babylonjs-gltf2interface\";\r\nimport type { Scene } from \"core/scene\";\r\nimport type { AbstractMesh } from \"core/Meshes/abstractMesh\";\r\nimport type { Texture } from \"core/Materials/Textures/texture\";\r\nimport { RenderTargetTexture } from \"core/Materials/Textures/renderTargetTexture\";\r\nimport type { Observer } from \"core/Misc/observable\";\r\nimport { Observable } from \"core/Misc/observable\";\r\nimport { Constants } from \"core/Engines/constants\";\r\nimport { Tools } from \"core/Misc/tools\";\r\nimport type { Color4 } from \"core/Maths/math.color\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\ninterface ITransmissionHelperHolder {\r\n    /**\r\n     * @internal\r\n     */\r\n    _transmissionHelper: TransmissionHelper | undefined;\r\n}\r\n\r\ninterface ITransmissionHelperOptions {\r\n    /**\r\n     * The size of the render buffers (default: 1024)\r\n     */\r\n    renderSize: number;\r\n\r\n    /**\r\n     * The number of samples to use when generating the render target texture for opaque meshes (default: 4)\r\n     */\r\n    samples: number;\r\n\r\n    /**\r\n     * Scale to apply when selecting the LOD level to sample the refraction texture (default: 1)\r\n     */\r\n    lodGenerationScale: number;\r\n\r\n    /**\r\n     * Offset to apply when selecting the LOD level to sample the refraction texture (default: -4)\r\n     */\r\n    lodGenerationOffset: number;\r\n\r\n    /**\r\n     * Type of the refraction render target texture (default: TEXTURETYPE_HALF_FLOAT)\r\n     */\r\n    renderTargetTextureType: number;\r\n\r\n    /**\r\n     * Defines if the mipmaps for the refraction render target texture must be generated (default: true)\r\n     */\r\n    generateMipmaps: boolean;\r\n\r\n    /**\r\n     * Clear color of the opaque texture. If not provided, use the scene clear color (which will be converted to linear space).\r\n     * If provided, should be in linear space\r\n     */\r\n    clearColor?: Color4;\r\n}\r\n\r\n/**\r\n * A class to handle setting up the rendering of opaque objects to be shown through transmissive objects.\r\n */\r\nclass TransmissionHelper {\r\n    /**\r\n     * Creates the default options for the helper.\r\n     * @returns the default options\r\n     */\r\n    private static _GetDefaultOptions(): ITransmissionHelperOptions {\r\n        return {\r\n            renderSize: 1024,\r\n            samples: 4,\r\n            lodGenerationScale: 1,\r\n            lodGenerationOffset: -4,\r\n            renderTargetTextureType: Constants.TEXTURETYPE_HALF_FLOAT,\r\n            generateMipmaps: true,\r\n        };\r\n    }\r\n\r\n    /**\r\n     * Stores the creation options.\r\n     */\r\n    private readonly _scene: Scene & ITransmissionHelperHolder;\r\n\r\n    private _options: ITransmissionHelperOptions;\r\n\r\n    private _opaqueRenderTarget: Nullable<RenderTargetTexture> = null;\r\n    private _opaqueMeshesCache: AbstractMesh[] = [];\r\n    private _transparentMeshesCache: AbstractMesh[] = [];\r\n    private _materialObservers: { [id: string]: Nullable<Observer<AbstractMesh>> } = {};\r\n\r\n    /**\r\n     * This observable will be notified with any error during the creation of the environment,\r\n     * mainly texture creation errors.\r\n     */\r\n    public onErrorObservable: Observable<{ message?: string; exception?: any }>;\r\n\r\n    /**\r\n     * constructor\r\n     * @param options Defines the options we want to customize the helper\r\n     * @param scene The scene to add the material to\r\n     */\r\n    constructor(options: Partial<ITransmissionHelperOptions>, scene: Scene) {\r\n        this._options = {\r\n            ...TransmissionHelper._GetDefaultOptions(),\r\n            ...options,\r\n        };\r\n        this._scene = scene as any;\r\n        this._scene._transmissionHelper = this;\r\n\r\n        this.onErrorObservable = new Observable();\r\n        this._scene.onDisposeObservable.addOnce(() => {\r\n            this.dispose();\r\n        });\r\n\r\n        this._parseScene();\r\n        this._setupRenderTargets();\r\n    }\r\n\r\n    /**\r\n     * Updates the background according to the new options\r\n     * @param options\r\n     */\r\n    public updateOptions(options: Partial<ITransmissionHelperOptions>) {\r\n        // First check if any options are actually being changed. If not, exit.\r\n        const newValues = Object.keys(options).filter((key: string) => (this._options as any)[key] !== (options as any)[key]);\r\n        if (!newValues.length) {\r\n            return;\r\n        }\r\n\r\n        const newOptions = {\r\n            ...this._options,\r\n            ...options,\r\n        };\r\n\r\n        const oldOptions = this._options;\r\n        this._options = newOptions;\r\n\r\n        // If size changes, recreate everything\r\n        if (\r\n            newOptions.renderSize !== oldOptions.renderSize ||\r\n            newOptions.renderTargetTextureType !== oldOptions.renderTargetTextureType ||\r\n            newOptions.generateMipmaps !== oldOptions.generateMipmaps ||\r\n            !this._opaqueRenderTarget\r\n        ) {\r\n            this._setupRenderTargets();\r\n        } else {\r\n            this._opaqueRenderTarget.samples = newOptions.samples;\r\n            this._opaqueRenderTarget.lodGenerationScale = newOptions.lodGenerationScale;\r\n            this._opaqueRenderTarget.lodGenerationOffset = newOptions.lodGenerationOffset;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @returns the opaque render target texture or null if not available.\r\n     */\r\n    public getOpaqueTarget(): Nullable<Texture> {\r\n        return this._opaqueRenderTarget;\r\n    }\r\n\r\n    private _shouldRenderAsTransmission(material: Nullable<Material>): boolean {\r\n        if (!material) {\r\n            return false;\r\n        }\r\n        if (material instanceof PBRMaterial && material.subSurface.isRefractionEnabled) {\r\n            return true;\r\n        }\r\n        return false;\r\n    }\r\n\r\n    private _addMesh(mesh: AbstractMesh): void {\r\n        this._materialObservers[mesh.uniqueId] = mesh.onMaterialChangedObservable.add(this._onMeshMaterialChanged.bind(this));\r\n\r\n        // we need to defer the processing because _addMesh may be called as part as an instance mesh creation, in which case some\r\n        // internal properties are not setup yet, like _sourceMesh (needed when doing mesh.material below)\r\n        Tools.SetImmediate(() => {\r\n            if (this._shouldRenderAsTransmission(mesh.material)) {\r\n                (mesh.material as PBRMaterial).refractionTexture = this._opaqueRenderTarget;\r\n                if (this._transparentMeshesCache.indexOf(mesh) === -1) {\r\n                    this._transparentMeshesCache.push(mesh);\r\n                }\r\n            } else {\r\n                if (this._opaqueMeshesCache.indexOf(mesh) === -1) {\r\n                    this._opaqueMeshesCache.push(mesh);\r\n                }\r\n            }\r\n        });\r\n    }\r\n\r\n    private _removeMesh(mesh: AbstractMesh): void {\r\n        mesh.onMaterialChangedObservable.remove(this._materialObservers[mesh.uniqueId]);\r\n        delete this._materialObservers[mesh.uniqueId];\r\n        let idx = this._transparentMeshesCache.indexOf(mesh);\r\n        if (idx !== -1) {\r\n            this._transparentMeshesCache.splice(idx, 1);\r\n        }\r\n        idx = this._opaqueMeshesCache.indexOf(mesh);\r\n        if (idx !== -1) {\r\n            this._opaqueMeshesCache.splice(idx, 1);\r\n        }\r\n    }\r\n\r\n    private _parseScene(): void {\r\n        this._scene.meshes.forEach(this._addMesh.bind(this));\r\n        // Listen for when a mesh is added to the scene and add it to our cache lists.\r\n        this._scene.onNewMeshAddedObservable.add(this._addMesh.bind(this));\r\n        // Listen for when a mesh is removed from to the scene and remove it from our cache lists.\r\n        this._scene.onMeshRemovedObservable.add(this._removeMesh.bind(this));\r\n    }\r\n\r\n    // When one of the meshes in the scene has its material changed, make sure that it's in the correct cache list.\r\n    private _onMeshMaterialChanged(mesh: AbstractMesh) {\r\n        const transparentIdx = this._transparentMeshesCache.indexOf(mesh);\r\n        const opaqueIdx = this._opaqueMeshesCache.indexOf(mesh);\r\n\r\n        // If the material is transparent, make sure that it's added to the transparent list and removed from the opaque list\r\n        const useTransmission = this._shouldRenderAsTransmission(mesh.material);\r\n        if (useTransmission) {\r\n            if (mesh.material instanceof PBRMaterial) {\r\n                mesh.material.subSurface.refractionTexture = this._opaqueRenderTarget;\r\n            }\r\n            if (opaqueIdx !== -1) {\r\n                this._opaqueMeshesCache.splice(opaqueIdx, 1);\r\n                this._transparentMeshesCache.push(mesh);\r\n            } else if (transparentIdx === -1) {\r\n                this._transparentMeshesCache.push(mesh);\r\n            }\r\n            // If the material is opaque, make sure that it's added to the opaque list and removed from the transparent list\r\n        } else {\r\n            if (transparentIdx !== -1) {\r\n                this._transparentMeshesCache.splice(transparentIdx, 1);\r\n                this._opaqueMeshesCache.push(mesh);\r\n            } else if (opaqueIdx === -1) {\r\n                this._opaqueMeshesCache.push(mesh);\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     * Check if the opaque render target has not been disposed and can still be used.\r\n     * @returns\r\n     */\r\n    public _isRenderTargetValid() {\r\n        return this._opaqueRenderTarget?.getInternalTexture() !== null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     * Setup the render targets according to the specified options.\r\n     */\r\n    public _setupRenderTargets(): void {\r\n        if (this._opaqueRenderTarget) {\r\n            this._opaqueRenderTarget.dispose();\r\n        }\r\n        this._opaqueRenderTarget = new RenderTargetTexture(\r\n            \"opaqueSceneTexture\",\r\n            this._options.renderSize,\r\n            this._scene,\r\n            this._options.generateMipmaps,\r\n            undefined,\r\n            this._options.renderTargetTextureType\r\n        );\r\n        this._opaqueRenderTarget.ignoreCameraViewport = true;\r\n        this._opaqueRenderTarget.renderList = this._opaqueMeshesCache;\r\n        this._opaqueRenderTarget.clearColor = this._options.clearColor?.clone() ?? this._scene.clearColor.clone();\r\n        this._opaqueRenderTarget.gammaSpace = false;\r\n        this._opaqueRenderTarget.lodGenerationScale = this._options.lodGenerationScale;\r\n        this._opaqueRenderTarget.lodGenerationOffset = this._options.lodGenerationOffset;\r\n        this._opaqueRenderTarget.samples = this._options.samples;\r\n        this._opaqueRenderTarget.renderSprites = true;\r\n        this._opaqueRenderTarget.renderParticles = true;\r\n        this._opaqueRenderTarget.disableImageProcessing = true;\r\n\r\n        let saveSceneEnvIntensity: number;\r\n        this._opaqueRenderTarget.onBeforeBindObservable.add((opaqueRenderTarget) => {\r\n            saveSceneEnvIntensity = this._scene.environmentIntensity;\r\n            this._scene.environmentIntensity = 1.0;\r\n            if (!this._options.clearColor) {\r\n                this._scene.clearColor.toLinearSpaceToRef(opaqueRenderTarget.clearColor, this._scene.getEngine().useExactSrgbConversions);\r\n            } else {\r\n                opaqueRenderTarget.clearColor.copyFrom(this._options.clearColor);\r\n            }\r\n        });\r\n        this._opaqueRenderTarget.onAfterUnbindObservable.add(() => {\r\n            this._scene.environmentIntensity = saveSceneEnvIntensity;\r\n        });\r\n\r\n        for (const mesh of this._transparentMeshesCache) {\r\n            if (this._shouldRenderAsTransmission(mesh.material)) {\r\n                (mesh.material as PBRMaterial).refractionTexture = this._opaqueRenderTarget;\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Dispose all the elements created by the Helper.\r\n     */\r\n    public dispose(): void {\r\n        this._scene._transmissionHelper = undefined;\r\n        if (this._opaqueRenderTarget) {\r\n            this._opaqueRenderTarget.dispose();\r\n            this._opaqueRenderTarget = null;\r\n        }\r\n        this._transparentMeshesCache = [];\r\n        this._opaqueMeshesCache = [];\r\n    }\r\n}\r\n\r\nconst NAME = \"KHR_materials_transmission\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_transmission extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_transmission\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_transmission/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_transmission implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 175;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n        if (this.enabled) {\r\n            loader.parent.transparencyAsCoverage = true;\r\n        }\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsTransmission>(context, material, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));\r\n            promises.push(this._loadTransparentPropertiesAsync(extensionContext, material, babylonMaterial, extension));\r\n            // eslint-disable-next-line github/no-then\r\n            return await Promise.all(promises).then(() => {});\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax, @typescript-eslint/promise-function-async\r\n    private _loadTransparentPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material, extension: IKHRMaterialsTransmission): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n        const pbrMaterial = babylonMaterial;\r\n\r\n        // Enables \"refraction\" texture which represents transmitted light.\r\n        pbrMaterial.subSurface.isRefractionEnabled = true;\r\n\r\n        // Since this extension models thin-surface transmission only, we must make IOR = 1.0\r\n        pbrMaterial.subSurface.volumeIndexOfRefraction = 1.0;\r\n\r\n        // Albedo colour will tint transmission.\r\n        pbrMaterial.subSurface.useAlbedoToTintRefraction = true;\r\n\r\n        if (extension.transmissionFactor !== undefined) {\r\n            pbrMaterial.subSurface.refractionIntensity = extension.transmissionFactor;\r\n            const scene = pbrMaterial.getScene() as unknown as ITransmissionHelperHolder;\r\n            if (pbrMaterial.subSurface.refractionIntensity && !scene._transmissionHelper) {\r\n                new TransmissionHelper({}, pbrMaterial.getScene());\r\n            } else if (pbrMaterial.subSurface.refractionIntensity && !scene._transmissionHelper?._isRenderTargetValid()) {\r\n                // If the render target is not valid, recreate it.\r\n                scene._transmissionHelper?._setupRenderTargets();\r\n            }\r\n        } else {\r\n            pbrMaterial.subSurface.refractionIntensity = 0.0;\r\n            pbrMaterial.subSurface.isRefractionEnabled = false;\r\n            return Promise.resolve();\r\n        }\r\n\r\n        pbrMaterial.subSurface.minimumThickness = 0.0;\r\n        pbrMaterial.subSurface.maximumThickness = 0.0;\r\n        if (extension.transmissionTexture) {\r\n            (extension.transmissionTexture as ITextureInfo).nonColorData = true;\r\n            // eslint-disable-next-line github/no-then\r\n            return this._loader.loadTextureInfoAsync(`${context}/transmissionTexture`, extension.transmissionTexture, undefined).then((texture: BaseTexture) => {\r\n                texture.name = `${babylonMaterial.name} (Transmission)`;\r\n                pbrMaterial.subSurface.refractionIntensityTexture = texture;\r\n                pbrMaterial.subSurface.useGltfStyleTextures = true;\r\n            });\r\n        } else {\r\n            return Promise.resolve();\r\n        }\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_transmission(loader));\r\n","/* eslint-disable github/no-then */\r\nimport type { Nullable } from \"core/types\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\r\nimport type { IMaterial, ITextureInfo } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IKHRMaterialsDiffuseTransmission } from \"babylonjs-gltf2interface\";\r\nimport { Color3 } from \"core/Maths/math.color\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_materials_diffuse_transmission\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_diffuse_transmission extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_diffuse_transmission\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Proposed Specification](https://github.com/KhronosGroup/glTF/pull/1825)\r\n * !!! Experimental Extension Subject to Changes !!!\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_diffuse_transmission implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 174;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n        if (this.enabled) {\r\n            loader.parent.transparencyAsCoverage = true;\r\n        }\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsDiffuseTransmission>(context, material, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));\r\n            promises.push(this._loadTranslucentPropertiesAsync(extensionContext, material, babylonMaterial, extension));\r\n            return await Promise.all(promises).then(() => {});\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax, @typescript-eslint/promise-function-async\r\n    private _loadTranslucentPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material, extension: IKHRMaterialsDiffuseTransmission): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        const pbrMaterial = babylonMaterial;\r\n\r\n        // Enables \"translucency\" texture which represents diffusely-transmitted light.\r\n        pbrMaterial.subSurface.isTranslucencyEnabled = true;\r\n\r\n        // Since this extension models thin-surface transmission only, we must make the\r\n        // internal IOR == 1.0 and set the thickness to 0.\r\n        pbrMaterial.subSurface.volumeIndexOfRefraction = 1.0;\r\n        pbrMaterial.subSurface.minimumThickness = 0.0;\r\n        pbrMaterial.subSurface.maximumThickness = 0.0;\r\n\r\n        // Tint color will be used for transmission.\r\n        pbrMaterial.subSurface.useAlbedoToTintTranslucency = false;\r\n\r\n        if (extension.diffuseTransmissionFactor !== undefined) {\r\n            pbrMaterial.subSurface.translucencyIntensity = extension.diffuseTransmissionFactor;\r\n        } else {\r\n            pbrMaterial.subSurface.translucencyIntensity = 0.0;\r\n            pbrMaterial.subSurface.isTranslucencyEnabled = false;\r\n            return Promise.resolve();\r\n        }\r\n\r\n        const promises = new Array<Promise<any>>();\r\n\r\n        pbrMaterial.subSurface.useGltfStyleTextures = true;\r\n\r\n        if (extension.diffuseTransmissionTexture) {\r\n            (extension.diffuseTransmissionTexture as ITextureInfo).nonColorData = true;\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/diffuseTransmissionTexture`, extension.diffuseTransmissionTexture).then((texture: BaseTexture) => {\r\n                    texture.name = `${babylonMaterial.name} (Diffuse Transmission)`;\r\n                    pbrMaterial.subSurface.translucencyIntensityTexture = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        if (extension.diffuseTransmissionColorFactor !== undefined) {\r\n            pbrMaterial.subSurface.translucencyColor = Color3.FromArray(extension.diffuseTransmissionColorFactor);\r\n        } else {\r\n            pbrMaterial.subSurface.translucencyColor = Color3.White();\r\n        }\r\n\r\n        if (extension.diffuseTransmissionColorTexture) {\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/diffuseTransmissionColorTexture`, extension.diffuseTransmissionColorTexture).then((texture: BaseTexture) => {\r\n                    texture.name = `${babylonMaterial.name} (Diffuse Transmission Color)`;\r\n                    pbrMaterial.subSurface.translucencyColorTexture = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        return Promise.all(promises).then(() => {});\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_diffuse_transmission(loader));\r\n","/* eslint-disable @typescript-eslint/naming-convention */\r\nimport type { Nullable } from \"core/types\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\r\nimport type { IMaterial, ITextureInfo } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IKHRMaterialsVolume } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_materials_volume\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_volume extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_volume\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_volume/README.md)\r\n * @since 5.0.0\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_volume implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 173;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n        if (this.enabled) {\r\n            // We need to disable instance usage because the attenuation factor depends on the node scale of each individual mesh\r\n            this._loader._disableInstancedMesh++;\r\n        }\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        if (this.enabled) {\r\n            this._loader._disableInstancedMesh--;\r\n        }\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsVolume>(context, material, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));\r\n            promises.push(this._loadVolumePropertiesAsync(extensionContext, material, babylonMaterial, extension));\r\n            // eslint-disable-next-line github/no-then\r\n            return await Promise.all(promises).then(() => {});\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadVolumePropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material, extension: IKHRMaterialsVolume): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        // If transparency isn't enabled already, this extension shouldn't do anything.\r\n        // i.e. it requires either the KHR_materials_transmission or KHR_materials_diffuse_transmission extensions.\r\n        if ((!babylonMaterial.subSurface.isRefractionEnabled && !babylonMaterial.subSurface.isTranslucencyEnabled) || !extension.thicknessFactor) {\r\n            return Promise.resolve();\r\n        }\r\n\r\n        // IOR in this extension only affects interior.\r\n        babylonMaterial.subSurface.volumeIndexOfRefraction = babylonMaterial.indexOfRefraction;\r\n        const attenuationDistance = extension.attenuationDistance !== undefined ? extension.attenuationDistance : Number.MAX_VALUE;\r\n        babylonMaterial.subSurface.tintColorAtDistance = attenuationDistance;\r\n        if (extension.attenuationColor !== undefined && extension.attenuationColor.length == 3) {\r\n            babylonMaterial.subSurface.tintColor.copyFromFloats(extension.attenuationColor[0], extension.attenuationColor[1], extension.attenuationColor[2]);\r\n        }\r\n\r\n        babylonMaterial.subSurface.minimumThickness = 0.0;\r\n        babylonMaterial.subSurface.maximumThickness = extension.thicknessFactor;\r\n        babylonMaterial.subSurface.useThicknessAsDepth = true;\r\n        if (extension.thicknessTexture) {\r\n            (extension.thicknessTexture as ITextureInfo).nonColorData = true;\r\n            // eslint-disable-next-line github/no-then\r\n            return this._loader.loadTextureInfoAsync(`${context}/thicknessTexture`, extension.thicknessTexture).then((texture: BaseTexture) => {\r\n                texture.name = `${babylonMaterial.name} (Thickness)`;\r\n                babylonMaterial.subSurface.thicknessTexture = texture;\r\n                babylonMaterial.subSurface.useGltfStyleTextures = true;\r\n            });\r\n        } else {\r\n            return Promise.resolve();\r\n        }\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_volume(loader));\r\n","/* eslint-disable @typescript-eslint/naming-convention */\r\nimport type { Nullable } from \"core/types\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\nimport type { IMaterial } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IKHRMaterialsDispersion } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_materials_dispersion\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_dispersion extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_dispersion\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/87bd64a7f5e23c84b6aef2e6082069583ed0ddb4/extensions/2.0/Khronos/KHR_materials_dispersion/README.md)\r\n * @experimental\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_dispersion implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 174;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsDispersion>(context, material, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));\r\n            promises.push(this._loadDispersionPropertiesAsync(extensionContext, material, babylonMaterial, extension));\r\n            // eslint-disable-next-line github/no-then\r\n            return await Promise.all(promises).then(() => {});\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadDispersionPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material, extension: IKHRMaterialsDispersion): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        // If transparency isn't enabled already, this extension shouldn't do anything.\r\n        // i.e. it requires either the KHR_materials_transmission or KHR_materials_diffuse_transmission extensions.\r\n        if (!babylonMaterial.subSurface.isRefractionEnabled || !extension.dispersion) {\r\n            return Promise.resolve();\r\n        }\r\n        babylonMaterial.subSurface.isDispersionEnabled = true;\r\n        babylonMaterial.subSurface.dispersion = extension.dispersion;\r\n        return Promise.resolve();\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_dispersion(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\n\r\nimport type { IMaterial } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IEXTMaterialsDiffuseRoughness } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\nimport { Constants } from \"core/Engines/constants\";\r\n\r\nconst NAME = \"EXT_materials_diffuse_roughness\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the EXT_materials_diffuse_roughness extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"EXT_materials_diffuse_roughness\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/fdee35425ae560ea378092e38977216d63a094ec/extensions/2.0/Khronos/EXT_materials_diffuse_roughness/README.md)\r\n * @experimental\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class EXT_materials_diffuse_roughness implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 190;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IEXTMaterialsDiffuseRoughness>(context, material, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));\r\n            promises.push(this._loadDiffuseRoughnessPropertiesAsync(extensionContext, extension, babylonMaterial));\r\n            // eslint-disable-next-line github/no-then\r\n            return await Promise.all(promises).then(() => {});\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadDiffuseRoughnessPropertiesAsync(context: string, properties: IEXTMaterialsDiffuseRoughness, babylonMaterial: Material): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        const promises = new Array<Promise<any>>();\r\n\r\n        babylonMaterial.brdf.baseDiffuseModel = Constants.MATERIAL_DIFFUSE_MODEL_E_OREN_NAYAR;\r\n\r\n        if (properties.diffuseRoughnessFactor != undefined) {\r\n            babylonMaterial.baseDiffuseRoughness = properties.diffuseRoughnessFactor;\r\n        } else {\r\n            babylonMaterial.baseDiffuseRoughness = 0;\r\n        }\r\n\r\n        if (properties.diffuseRoughnessTexture) {\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/diffuseRoughnessTexture`, properties.diffuseRoughnessTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Diffuse Roughness)`;\r\n                    babylonMaterial.baseDiffuseRoughnessTexture = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        // eslint-disable-next-line github/no-then\r\n        return Promise.all(promises).then(() => {});\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new EXT_materials_diffuse_roughness(loader));\r\n","import type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport type { GLTFLoader } from \"../glTFLoader\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_mesh_quantization\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_mesh_quantization extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_mesh_quantization\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_mesh_quantization/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_mesh_quantization implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this.enabled = loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {}\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_mesh_quantization(loader));\r\n","import type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader, ArrayItem } from \"../glTFLoader\";\r\nimport type { ITexture } from \"../glTFLoaderInterfaces\";\r\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\r\nimport type { Nullable } from \"core/types\";\r\nimport type { IKHRTextureBasisU } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_texture_basisu\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_texture_basisu extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_texture_basisu\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_texture_basisu/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_texture_basisu implements IGLTFLoaderExtension {\r\n    /** The name of this extension. */\r\n    public readonly name = NAME;\r\n\r\n    /** Defines whether this extension is enabled. */\r\n    public enabled: boolean;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public _loadTextureAsync(context: string, texture: ITexture, assign: (babylonTexture: BaseTexture) => void): Nullable<Promise<BaseTexture>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRTextureBasisU, BaseTexture>(context, texture, this.name, async (extensionContext, extension) => {\r\n            const sampler = texture.sampler == undefined ? GLTFLoader.DefaultSampler : ArrayItem.Get(`${context}/sampler`, this._loader.gltf.samplers, texture.sampler);\r\n            const image = ArrayItem.Get(`${extensionContext}/source`, this._loader.gltf.images, extension.source);\r\n            return await this._loader._createTextureAsync(\r\n                context,\r\n                sampler,\r\n                image,\r\n                (babylonTexture) => {\r\n                    assign(babylonTexture);\r\n                },\r\n                texture._textureInfo.nonColorData ? { useRGBAIfASTCBC7NotAvailableWhenUASTC: true } : undefined,\r\n                !texture._textureInfo.nonColorData\r\n            );\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_texture_basisu(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\r\nimport { Texture } from \"core/Materials/Textures/texture\";\r\n\r\nimport type { ITextureInfo } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IKHRTextureTransform } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_texture_transform\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_texture_transform extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_texture_transform\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_texture_transform/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_texture_transform implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadTextureInfoAsync(context: string, textureInfo: ITextureInfo, assign: (babylonTexture: BaseTexture) => void): Nullable<Promise<BaseTexture>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRTextureTransform, BaseTexture>(context, textureInfo, this.name, async (extensionContext, extension) => {\r\n            return await this._loader.loadTextureInfoAsync(context, textureInfo, (babylonTexture) => {\r\n                if (!(babylonTexture instanceof Texture)) {\r\n                    throw new Error(`${extensionContext}: Texture type not supported`);\r\n                }\r\n\r\n                if (extension.offset) {\r\n                    babylonTexture.uOffset = extension.offset[0];\r\n                    babylonTexture.vOffset = extension.offset[1];\r\n                }\r\n\r\n                // Always rotate around the origin.\r\n                babylonTexture.uRotationCenter = 0;\r\n                babylonTexture.vRotationCenter = 0;\r\n\r\n                if (extension.rotation) {\r\n                    babylonTexture.wAng = -extension.rotation;\r\n                }\r\n\r\n                if (extension.scale) {\r\n                    babylonTexture.uScale = extension.scale[0];\r\n                    babylonTexture.vScale = extension.scale[1];\r\n                }\r\n\r\n                if (extension.texCoord != undefined) {\r\n                    babylonTexture.coordinatesIndex = extension.texCoord;\r\n                }\r\n\r\n                assign(babylonTexture);\r\n            });\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_texture_transform(loader));\r\n","import type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport type { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IKHRXmpJsonLd_Gltf, IKHRXmpJsonLd_Node } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_xmp_json_ld\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_xmp_json_ld extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_xmp_json_ld\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_xmp_json_ld/README.md)\r\n * @since 5.0.0\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_xmp_json_ld implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 100;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * Called after the loader state changes to LOADING.\r\n     */\r\n    public onLoading(): void {\r\n        if (this._loader.rootBabylonMesh === null) {\r\n            return;\r\n        }\r\n\r\n        const xmpGltf = this._loader.gltf.extensions?.KHR_xmp_json_ld as IKHRXmpJsonLd_Gltf;\r\n        const xmpNode = this._loader.gltf.asset?.extensions?.KHR_xmp_json_ld as IKHRXmpJsonLd_Node;\r\n        if (xmpGltf && xmpNode) {\r\n            const packet = +xmpNode.packet;\r\n            if (xmpGltf.packets && packet < xmpGltf.packets.length) {\r\n                this._loader.rootBabylonMesh.metadata = this._loader.rootBabylonMesh.metadata || {};\r\n                this._loader.rootBabylonMesh.metadata.xmp = xmpGltf.packets[packet];\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_xmp_json_ld(loader));\r\n","/* eslint-disable @typescript-eslint/naming-convention */\r\n\r\nimport { Animation } from \"core/Animations/animation\";\r\nimport type { ICamera, IKHRLightsPunctual_Light, IMaterial } from \"../glTFLoaderInterfaces\";\r\nimport type { IAnimatable } from \"core/Animations/animatable.interface\";\r\nimport { AnimationPropertyInfo } from \"../glTFLoaderAnimation\";\r\nimport { Color3 } from \"core/Maths/math.color\";\r\nimport { SetInterpolationForKey } from \"./objectModelMapping\";\r\n\r\nfunction getColor3(_target: any, source: Float32Array, offset: number, scale: number): Color3 {\r\n    return Color3.FromArray(source, offset).scale(scale);\r\n}\r\n\r\nfunction getAlpha(_target: any, source: Float32Array, offset: number, scale: number): number {\r\n    return source[offset + 3] * scale;\r\n}\r\n\r\nfunction getFloat(_target: any, source: Float32Array, offset: number, scale: number): number {\r\n    return source[offset] * scale;\r\n}\r\n\r\nfunction getMinusFloat(_target: any, source: Float32Array, offset: number, scale: number): number {\r\n    return -source[offset] * scale;\r\n}\r\n\r\nfunction getNextFloat(_target: any, source: Float32Array, offset: number, scale: number): number {\r\n    return source[offset + 1] * scale;\r\n}\r\n\r\nfunction getFloatBy2(_target: any, source: Float32Array, offset: number, scale: number): number {\r\n    return source[offset] * scale * 2;\r\n}\r\n\r\nfunction getTextureTransformTree(textureName: string) {\r\n    return {\r\n        scale: [\r\n            new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, `${textureName}.uScale`, getFloat, () => 2),\r\n            new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, `${textureName}.vScale`, getNextFloat, () => 2),\r\n        ],\r\n        offset: [\r\n            new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, `${textureName}.uOffset`, getFloat, () => 2),\r\n            new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, `${textureName}.vOffset`, getNextFloat, () => 2),\r\n        ],\r\n        rotation: [new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, `${textureName}.wAng`, getMinusFloat, () => 1)],\r\n    };\r\n}\r\n\r\nclass CameraAnimationPropertyInfo extends AnimationPropertyInfo {\r\n    /** @internal */\r\n    public buildAnimations(target: ICamera, name: string, fps: number, keys: any[]) {\r\n        return [{ babylonAnimatable: target._babylonCamera!, babylonAnimation: this._buildAnimation(name, fps, keys) }];\r\n    }\r\n}\r\n\r\nclass MaterialAnimationPropertyInfo extends AnimationPropertyInfo {\r\n    /** @internal */\r\n    public buildAnimations(target: IMaterial, name: string, fps: number, keys: any[]) {\r\n        const babylonAnimations: { babylonAnimatable: IAnimatable; babylonAnimation: Animation }[] = [];\r\n        for (const fillMode in target._data!) {\r\n            babylonAnimations.push({\r\n                babylonAnimatable: target._data[fillMode].babylonMaterial,\r\n                babylonAnimation: this._buildAnimation(name, fps, keys),\r\n            });\r\n        }\r\n        return babylonAnimations;\r\n    }\r\n}\r\n\r\nclass LightAnimationPropertyInfo extends AnimationPropertyInfo {\r\n    /** @internal */\r\n    public buildAnimations(target: IKHRLightsPunctual_Light, name: string, fps: number, keys: any[]) {\r\n        return [{ babylonAnimatable: target._babylonLight!, babylonAnimation: this._buildAnimation(name, fps, keys) }];\r\n    }\r\n}\r\n\r\nSetInterpolationForKey(\"/cameras/{}/orthographic/xmag\", [\r\n    new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"orthoLeft\", getMinusFloat, () => 1),\r\n    new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"orthoRight\", getNextFloat, () => 1),\r\n]);\r\n\r\nSetInterpolationForKey(\"/cameras/{}/orthographic/ymag\", [\r\n    new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"orthoBottom\", getMinusFloat, () => 1),\r\n    new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"orthoTop\", getNextFloat, () => 1),\r\n]);\r\n\r\nSetInterpolationForKey(\"/cameras/{}/orthographic/zfar\", [new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"maxZ\", getFloat, () => 1)]);\r\nSetInterpolationForKey(\"/cameras/{}/orthographic/znear\", [new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"minZ\", getFloat, () => 1)]);\r\n\r\nSetInterpolationForKey(\"/cameras/{}/perspective/yfov\", [new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"fov\", getFloat, () => 1)]);\r\nSetInterpolationForKey(\"/cameras/{}/perspective/zfar\", [new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"maxZ\", getFloat, () => 1)]);\r\nSetInterpolationForKey(\"/cameras/{}/perspective/znear\", [new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"minZ\", getFloat, () => 1)]);\r\n\r\n// add interpolation to the materials mapping\r\nSetInterpolationForKey(\"/materials/{}/pbrMetallicRoughness/baseColorFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_COLOR3, \"albedoColor\", getColor3, () => 4),\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"alpha\", getAlpha, () => 4),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/pbrMetallicRoughness/metallicFactor\", [new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"metallic\", getFloat, () => 1)]);\r\nSetInterpolationForKey(\"/materials/{}/pbrMetallicRoughness/metallicFactor\", [new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"roughness\", getFloat, () => 1)]);\r\nconst baseColorTextureInterpolation = getTextureTransformTree(\"albedoTexture\");\r\nSetInterpolationForKey(\"/materials/{}/pbrMetallicRoughness/baseColorTexture/extensions/KHR_texture_transform/scale\", baseColorTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/pbrMetallicRoughness/baseColorTexture/extensions/KHR_texture_transform/offset\", baseColorTextureInterpolation.offset);\r\nSetInterpolationForKey(\"/materials/{}/pbrMetallicRoughness/baseColorTexture/extensions/KHR_texture_transform/rotation\", baseColorTextureInterpolation.rotation);\r\n\r\nconst metallicRoughnessTextureInterpolation = getTextureTransformTree(\"metallicTexture\");\r\nSetInterpolationForKey(\"//materials/{}/pbrMetallicRoughness/metallicRoughnessTexture/scale\", metallicRoughnessTextureInterpolation.scale);\r\nSetInterpolationForKey(\"//materials/{}/pbrMetallicRoughness/metallicRoughnessTexture/offset\", metallicRoughnessTextureInterpolation.offset);\r\nSetInterpolationForKey(\"//materials/{}/pbrMetallicRoughness/metallicRoughnessTexture/rotation\", metallicRoughnessTextureInterpolation.rotation);\r\n\r\nSetInterpolationForKey(\"/materials/{}/emissiveFactor\", [new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_COLOR3, \"emissiveColor\", getColor3, () => 3)]);\r\nconst normalTextureInterpolation = getTextureTransformTree(\"bumpTexture\");\r\nSetInterpolationForKey(\"/materials/{}/normalTexture/scale\", [new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"bumpTexture.level\", getFloat, () => 1)]);\r\n\r\nSetInterpolationForKey(\"/materials/{}/normalTexture/extensions/KHR_texture_transform/scale\", normalTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/normalTexture/extensions/KHR_texture_transform/offset\", normalTextureInterpolation.offset);\r\nSetInterpolationForKey(\"/materials/{}/normalTexture/extensions/KHR_texture_transform/rotation\", normalTextureInterpolation.rotation);\r\n\r\nSetInterpolationForKey(\"/materials/{}/occlusionTexture/strength\", [new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"ambientTextureStrength\", getFloat, () => 1)]);\r\n\r\nconst occlusionTextureInterpolation = getTextureTransformTree(\"ambientTexture\");\r\nSetInterpolationForKey(\"/materials/{}/occlusionTexture/extensions/KHR_texture_transform/scale\", occlusionTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/occlusionTexture/extensions/KHR_texture_transform/offset\", occlusionTextureInterpolation.offset);\r\nSetInterpolationForKey(\"/materials/{}/occlusionTexture/extensions/KHR_texture_transform/rotation\", occlusionTextureInterpolation.rotation);\r\nconst emissiveTextureInterpolation = getTextureTransformTree(\"emissiveTexture\");\r\nSetInterpolationForKey(\"/materials/{}/emissiveTexture/extensions/KHR_texture_transform/scale\", emissiveTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/emissiveTexture/extensions/KHR_texture_transform/offset\", emissiveTextureInterpolation.offset);\r\nSetInterpolationForKey(\"/materials/{}/emissiveTexture/extensions/KHR_texture_transform/rotation\", emissiveTextureInterpolation.rotation);\r\n\r\n// materials extensions\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_anisotropy/anisotropyStrength\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"anisotropy.intensity\", getFloat, () => 1),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_anisotropy/anisotropyRotation\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"anisotropy.angle\", getFloat, () => 1),\r\n]);\r\nconst anisotropyTextureInterpolation = getTextureTransformTree(\"anisotropy.texture\");\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_anisotropy/anisotropyTexture/extensions/KHR_texture_transform/scale\", anisotropyTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_anisotropy/anisotropyTexture/extensions/KHR_texture_transform/offset\", anisotropyTextureInterpolation.offset);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_anisotropy/anisotropyTexture/extensions/KHR_texture_transform/rotation\", anisotropyTextureInterpolation.rotation);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_clearcoat/clearcoatFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"clearCoat.intensity\", getFloat, () => 1),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_clearcoat/clearcoatRoughnessFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"clearCoat.roughness\", getFloat, () => 1),\r\n]);\r\nconst clearcoatTextureInterpolation = getTextureTransformTree(\"clearCoat.texture\");\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_clearcoat/clearcoatTexture/extensions/KHR_texture_transform/scale\", clearcoatTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_clearcoat/clearcoatTexture/extensions/KHR_texture_transform/offset\", clearcoatTextureInterpolation.offset);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_clearcoat/clearcoatTexture/extensions/KHR_texture_transform/rotation\", clearcoatTextureInterpolation.rotation);\r\nconst clearcoatNormalTextureInterpolation = getTextureTransformTree(\"clearCoat.bumpTexture\");\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_clearcoat/clearcoatNormalTexture/scale\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"clearCoat.bumpTexture.level\", getFloat, () => 1),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_clearcoat/clearcoatNormalTexture/extensions/KHR_texture_transform/scale\", clearcoatNormalTextureInterpolation.scale);\r\nSetInterpolationForKey(\r\n    \"/materials/{}/extensions/KHR_materials_clearcoat/clearcoatNormalTexture/extensions/KHR_texture_transform/offset\",\r\n    clearcoatNormalTextureInterpolation.offset\r\n);\r\nSetInterpolationForKey(\r\n    \"/materials/{}/extensions/KHR_materials_clearcoat/clearcoatNormalTexture/extensions/KHR_texture_transform/rotation\",\r\n    clearcoatNormalTextureInterpolation.rotation\r\n);\r\nconst clearcoatRoughnessTextureInterpolation = getTextureTransformTree(\"clearCoat.textureRoughness\");\r\nSetInterpolationForKey(\r\n    \"/materials/{}/extensions/KHR_materials_clearcoat/clearcoatRoughnessTexture/extensions/KHR_texture_transform/scale\",\r\n    clearcoatRoughnessTextureInterpolation.scale\r\n);\r\nSetInterpolationForKey(\r\n    \"/materials/{}/extensions/KHR_materials_clearcoat/clearcoatRoughnessTexture/extensions/KHR_texture_transform/offset\",\r\n    clearcoatRoughnessTextureInterpolation.offset\r\n);\r\nSetInterpolationForKey(\r\n    \"/materials/{}/extensions/KHR_materials_clearcoat/clearcoatRoughnessTexture/extensions/KHR_texture_transform/rotation\",\r\n    clearcoatRoughnessTextureInterpolation.rotation\r\n);\r\n\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_dispersion/dispersionFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"subSurface.dispersion\", getFloat, () => 1),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_emissive_strength/emissiveStrength\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"emissiveIntensity\", getFloat, () => 1),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_ior/ior\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"indexOfRefraction\", getFloat, () => 1),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_iridescence/iridescenceFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"iridescence.intensity\", getFloat, () => 1),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_iridescence/iridescenceIor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"iridescence.indexOfRefraction\", getFloat, () => 1),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_iridescence/iridescenceThicknessMinimum\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"iridescence.minimumThickness\", getFloat, () => 1),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_iridescence/iridescenceThicknessMaximum\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"iridescence.maximumThickness\", getFloat, () => 1),\r\n]);\r\n\r\nconst iridescenceTextureInterpolation = getTextureTransformTree(\"iridescence.texture\");\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_iridescence/iridescenceTexture/extensions/KHR_texture_transform/scale\", iridescenceTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_iridescence/iridescenceTexture/extensions/KHR_texture_transform/offset\", iridescenceTextureInterpolation.offset);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_iridescence/iridescenceTexture/extensions/KHR_texture_transform/rotation\", iridescenceTextureInterpolation.rotation);\r\n\r\nconst iridescenceThicknessTextureInterpolation = getTextureTransformTree(\"iridescence.thicknessTexture\");\r\nSetInterpolationForKey(\r\n    \"/materials/{}/extensions/KHR_materials_iridescence/iridescenceThicknessTexture/extensions/KHR_texture_transform/scale\",\r\n    iridescenceThicknessTextureInterpolation.scale\r\n);\r\nSetInterpolationForKey(\r\n    \"/materials/{}/extensions/KHR_materials_iridescence/iridescenceThicknessTexture/extensions/KHR_texture_transform/offset\",\r\n    iridescenceThicknessTextureInterpolation.offset\r\n);\r\nSetInterpolationForKey(\r\n    \"/materials/{}/extensions/KHR_materials_iridescence/iridescenceThicknessTexture/extensions/KHR_texture_transform/rotation\",\r\n    iridescenceThicknessTextureInterpolation.rotation\r\n);\r\n\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_sheen/sheenColorFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_COLOR3, \"sheen.color\", getColor3, () => 3),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_sheen/sheenRoughnessFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"sheen.roughness\", getFloat, () => 1),\r\n]);\r\n\r\nconst sheenTextureInterpolation = getTextureTransformTree(\"sheen.texture\");\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_sheen/sheenColorTexture/extensions/KHR_texture_transform/scale\", sheenTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_sheen/sheenColorTexture/extensions/KHR_texture_transform/offset\", sheenTextureInterpolation.offset);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_sheen/sheenColorTexture/extensions/KHR_texture_transform/rotation\", sheenTextureInterpolation.rotation);\r\n\r\nconst sheenRoughnessTextureInterpolation = getTextureTransformTree(\"sheen.textureRoughness\");\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_sheen/sheenRoughnessTexture/extensions/KHR_texture_transform/scale\", sheenRoughnessTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_sheen/sheenRoughnessTexture/extensions/KHR_texture_transform/offset\", sheenRoughnessTextureInterpolation.offset);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_sheen/sheenRoughnessTexture/extensions/KHR_texture_transform/rotation\", sheenRoughnessTextureInterpolation.rotation);\r\n\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_specular/specularFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"metallicF0Factor\", getFloat, () => 1),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_specular/specularColorFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_COLOR3, \"metallicReflectanceColor\", getColor3, () => 3),\r\n]);\r\n\r\nconst specularTextureInterpolation = getTextureTransformTree(\"metallicReflectanceTexture\");\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_specular/specularTexture/extensions/KHR_texture_transform/scale\", specularTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_specular/specularTexture/extensions/KHR_texture_transform/offset\", specularTextureInterpolation.offset);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_specular/specularTexture/extensions/KHR_texture_transform/rotation\", specularTextureInterpolation.rotation);\r\nconst specularColorTextureInterpolation = getTextureTransformTree(\"reflectanceTexture\");\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_specular/specularColorTexture/extensions/KHR_texture_transform/scale\", specularColorTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_specular/specularColorTexture/extensions/KHR_texture_transform/offset\", specularColorTextureInterpolation.offset);\r\nSetInterpolationForKey(\r\n    \"/materials/{}/extensions/KHR_materials_specular/specularColorTexture/extensions/KHR_texture_transform/rotation\",\r\n    specularColorTextureInterpolation.rotation\r\n);\r\n\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_transmission/transmissionFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"subSurface.refractionIntensity\", getFloat, () => 1),\r\n]);\r\nconst transmissionTextureInterpolation = getTextureTransformTree(\"subSurface.refractionIntensityTexture\");\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_transmission/transmissionTexture/extensions/KHR_texture_transform/scale\", transmissionTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_transmission/transmissionTexture/extensions/KHR_texture_transform/offset\", transmissionTextureInterpolation.offset);\r\nSetInterpolationForKey(\r\n    \"/materials/{}/extensions/KHR_materials_transmission/transmissionTexture/extensions/KHR_texture_transform/rotation\",\r\n    transmissionTextureInterpolation.rotation\r\n);\r\n\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_volume/attenuationColor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_COLOR3, \"subSurface.tintColor\", getColor3, () => 3),\r\n]);\r\n\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_volume/attenuationDistance\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"subSurface.tintColorAtDistance\", getFloat, () => 1),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_volume/thicknessFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"subSurface.maximumThickness\", getFloat, () => 1),\r\n]);\r\n\r\nconst thicknessTextureInterpolation = getTextureTransformTree(\"subSurface.thicknessTexture\");\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_volume/thicknessTexture/extensions/KHR_texture_transform/scale\", thicknessTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_volume/thicknessTexture/extensions/KHR_texture_transform/offset\", thicknessTextureInterpolation.offset);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_volume/thicknessTexture/extensions/KHR_texture_transform/rotation\", thicknessTextureInterpolation.rotation);\r\n\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_diffuse_transmission/diffuseTransmissionFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"subSurface.translucencyIntensity\", getFloat, () => 1),\r\n]);\r\n\r\nconst diffuseTransmissionTextureInterpolation = getTextureTransformTree(\"subSurface.translucencyIntensityTexture\");\r\nSetInterpolationForKey(\r\n    \"materials/{}/extensions/KHR_materials_diffuse_transmission/diffuseTransmissionTexture/extensions/KHR_texture_transform/scale\",\r\n    diffuseTransmissionTextureInterpolation.scale\r\n);\r\nSetInterpolationForKey(\r\n    \"materials/{}/extensions/KHR_materials_diffuse_transmission/diffuseTransmissionTexture/extensions/KHR_texture_transform/offset\",\r\n    diffuseTransmissionTextureInterpolation.offset\r\n);\r\nSetInterpolationForKey(\r\n    \"materials/{}/extensions/KHR_materials_diffuse_transmission/diffuseTransmissionTexture/extensions/KHR_texture_transform/rotation\",\r\n    diffuseTransmissionTextureInterpolation.rotation\r\n);\r\n\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_diffuse_transmission/diffuseTransmissionColorFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_COLOR3, \"subSurface.translucencyColor\", getColor3, () => 3),\r\n]);\r\n\r\nconst diffuseTransmissionColorTextureInterpolation = getTextureTransformTree(\"subSurface.translucencyColorTexture\");\r\nSetInterpolationForKey(\r\n    \"materials/{}/extensions/KHR_materials_diffuse_transmission/diffuseTransmissionColorTexture/extensions/KHR_texture_transform/scale\",\r\n    diffuseTransmissionColorTextureInterpolation.scale\r\n);\r\nSetInterpolationForKey(\r\n    \"materials/{}/extensions/KHR_materials_diffuse_transmission/diffuseTransmissionColorTexture/extensions/KHR_texture_transform/offset\",\r\n    diffuseTransmissionColorTextureInterpolation.offset\r\n);\r\nSetInterpolationForKey(\r\n    \"materials/{}/extensions/KHR_materials_diffuse_transmission/diffuseTransmissionColorTexture/extensions/KHR_texture_transform/rotation\",\r\n    diffuseTransmissionColorTextureInterpolation.rotation\r\n);\r\n\r\nSetInterpolationForKey(\"/extensions/KHR_lights_punctual/lights/{}/color\", [new LightAnimationPropertyInfo(Animation.ANIMATIONTYPE_COLOR3, \"diffuse\", getColor3, () => 3)]);\r\nSetInterpolationForKey(\"/extensions/KHR_lights_punctual/lights/{}/intensity\", [new LightAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"intensity\", getFloat, () => 1)]);\r\nSetInterpolationForKey(\"/extensions/KHR_lights_punctual/lights/{}/range\", [new LightAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"range\", getFloat, () => 1)]);\r\nSetInterpolationForKey(\"/extensions/KHR_lights_punctual/lights/{}/spot/innerConeAngle\", [\r\n    new LightAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"innerAngle\", getFloatBy2, () => 1),\r\n]);\r\nSetInterpolationForKey(\"/extensions/KHR_lights_punctual/lights/{}/spot/outerConeAngle\", [\r\n    new LightAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"angle\", getFloatBy2, () => 1),\r\n]);\r\n\r\nSetInterpolationForKey(\"/nodes/{}/extensions/EXT_lights_ies/color\", [new LightAnimationPropertyInfo(Animation.ANIMATIONTYPE_COLOR3, \"diffuse\", getColor3, () => 3)]);\r\nSetInterpolationForKey(\"/nodes/{}/extensions/EXT_lights_ies/multiplier\", [new LightAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"intensity\", getFloat, () => 1)]);\r\n","import type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport type { GLTFLoader } from \"../glTFLoader\";\r\nimport type { Nullable } from \"core/types\";\r\nimport type { Animation } from \"core/Animations/animation\";\r\nimport type { IAnimatable } from \"core/Animations/animatable.interface\";\r\nimport type { IAnimation, IAnimationChannel } from \"../glTFLoaderInterfaces\";\r\nimport type { IKHRAnimationPointer } from \"babylonjs-gltf2interface\";\r\nimport { AnimationChannelTargetPath } from \"babylonjs-gltf2interface\";\r\nimport { Logger } from \"core/Misc/logger\";\r\nimport type { GLTFPathToObjectConverter } from \"./gltfPathToObjectConverter\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\nimport { GetPathToObjectConverter } from \"./objectModelMapping\";\r\nimport \"./KHR_animation_pointer.data\";\r\n\r\nconst NAME = \"KHR_animation_pointer\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_animation_pointer extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_animation_pointer\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification PR](https://github.com/KhronosGroup/glTF/pull/2147)\r\n * !!! Experimental Extension Subject to Changes !!!\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_animation_pointer implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    private _loader: GLTFLoader;\r\n    private _pathToObjectConverter?: GLTFPathToObjectConverter<any, any, any>;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this._pathToObjectConverter = GetPathToObjectConverter(this._loader.gltf);\r\n    }\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public get enabled(): boolean {\r\n        return this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n        delete this._pathToObjectConverter; // GC\r\n    }\r\n\r\n    /**\r\n     * Loads a glTF animation channel.\r\n     * @param context The context when loading the asset\r\n     * @param animationContext The context of the animation when loading the asset\r\n     * @param animation The glTF animation property\r\n     * @param channel The glTF animation channel property\r\n     * @param onLoad Called for each animation loaded\r\n     * @returns A void promise that resolves when the load is complete or null if not handled\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public _loadAnimationChannelAsync(\r\n        context: string,\r\n        animationContext: string,\r\n        animation: IAnimation,\r\n        channel: IAnimationChannel,\r\n        onLoad: (babylonAnimatable: IAnimatable, babylonAnimation: Animation) => void\r\n    ): Nullable<Promise<void>> {\r\n        const extension = channel.target.extensions?.KHR_animation_pointer as IKHRAnimationPointer;\r\n        if (!extension || !this._pathToObjectConverter) {\r\n            return null;\r\n        }\r\n\r\n        if (channel.target.path !== AnimationChannelTargetPath.POINTER) {\r\n            Logger.Warn(`${context}/target/path: Value (${channel.target.path}) must be (${AnimationChannelTargetPath.POINTER}) when using the ${this.name} extension`);\r\n        }\r\n\r\n        if (channel.target.node != undefined) {\r\n            Logger.Warn(`${context}/target/node: Value (${channel.target.node}) must not be present when using the ${this.name} extension`);\r\n        }\r\n\r\n        const extensionContext = `${context}/extensions/${this.name}`;\r\n\r\n        const pointer = extension.pointer;\r\n        if (!pointer) {\r\n            throw new Error(`${extensionContext}: Pointer is missing`);\r\n        }\r\n\r\n        try {\r\n            const obj = this._pathToObjectConverter.convert(pointer);\r\n            if (!obj.info.interpolation) {\r\n                throw new Error(`${extensionContext}/pointer: Interpolation is missing`);\r\n            }\r\n            return this._loader._loadAnimationChannelFromTargetInfoAsync(\r\n                context,\r\n                animationContext,\r\n                animation,\r\n                channel,\r\n                {\r\n                    object: obj.object,\r\n                    info: obj.info.interpolation,\r\n                },\r\n                onLoad\r\n            );\r\n        } catch (e) {\r\n            Logger.Warn(`${extensionContext}/pointer: Invalid pointer (${pointer}) skipped`);\r\n            return null;\r\n        }\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_animation_pointer(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport { Vector3 } from \"core/Maths/math.vector\";\r\nimport { Tools } from \"core/Misc/tools\";\r\nimport type { AnimationGroup } from \"core/Animations/animationGroup\";\r\nimport { AnimationEvent } from \"core/Animations/animationEvent\";\r\nimport type { TransformNode } from \"core/Meshes/transformNode\";\r\nimport { Sound } from \"core/Audio/sound\";\r\nimport { WeightedSound } from \"core/Audio/weightedsound\";\r\n\r\nimport type { IArrayItem, IScene, INode, IAnimation } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader, ArrayItem } from \"../glTFLoader\";\r\nimport type { IMSFTAudioEmitter_Clip, IMSFTAudioEmitter_Emitter, IMSFTAudioEmitter_EmittersReference, IMSFTAudioEmitter_AnimationEvent } from \"babylonjs-gltf2interface\";\r\nimport { IMSFTAudioEmitter_AnimationEventAction } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nimport \"core/Audio/audioSceneComponent\";\r\n\r\nconst NAME = \"MSFT_audio_emitter\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the MSFT_audio_emitter extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"MSFT_audio_emitter\"]: {};\r\n    }\r\n}\r\n\r\ninterface ILoaderClip extends IMSFTAudioEmitter_Clip, IArrayItem {\r\n    _objectURL?: Promise<string>;\r\n}\r\n\r\ninterface ILoaderEmitter extends IMSFTAudioEmitter_Emitter, IArrayItem {\r\n    _babylonData?: {\r\n        sound?: WeightedSound;\r\n        loaded: Promise<void>;\r\n    };\r\n    _babylonSounds: Sound[];\r\n}\r\n\r\ninterface IMSFTAudioEmitter {\r\n    clips: ILoaderClip[];\r\n    emitters: ILoaderEmitter[];\r\n}\r\n\r\ninterface ILoaderAnimationEvent extends IMSFTAudioEmitter_AnimationEvent, IArrayItem {}\r\n\r\ninterface ILoaderAnimationEvents {\r\n    events: ILoaderAnimationEvent[];\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/najadojo/glTF/blob/MSFT_audio_emitter/extensions/2.0/Vendor/MSFT_audio_emitter/README.md)\r\n * !!! Experimental Extension Subject to Changes !!!\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class MSFT_audio_emitter implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    private _loader: GLTFLoader;\r\n    private _clips: Array<ILoaderClip>;\r\n    private _emitters: Array<ILoaderEmitter>;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n        (this._clips as any) = null;\r\n        (this._emitters as any) = null;\r\n    }\r\n\r\n    /** @internal */\r\n    public onLoading(): void {\r\n        const extensions = this._loader.gltf.extensions;\r\n        if (extensions && extensions[this.name]) {\r\n            const extension = extensions[this.name] as IMSFTAudioEmitter;\r\n\r\n            this._clips = extension.clips;\r\n            this._emitters = extension.emitters;\r\n\r\n            ArrayItem.Assign(this._clips);\r\n            ArrayItem.Assign(this._emitters);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadSceneAsync(context: string, scene: IScene): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IMSFTAudioEmitter_EmittersReference>(context, scene, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n\r\n            promises.push(this._loader.loadSceneAsync(context, scene));\r\n\r\n            for (const emitterIndex of extension.emitters) {\r\n                const emitter = ArrayItem.Get(`${extensionContext}/emitters`, this._emitters, emitterIndex);\r\n                if (\r\n                    emitter.refDistance != undefined ||\r\n                    emitter.maxDistance != undefined ||\r\n                    emitter.rolloffFactor != undefined ||\r\n                    emitter.distanceModel != undefined ||\r\n                    emitter.innerAngle != undefined ||\r\n                    emitter.outerAngle != undefined\r\n                ) {\r\n                    throw new Error(`${extensionContext}: Direction or Distance properties are not allowed on emitters attached to a scene`);\r\n                }\r\n\r\n                promises.push(this._loadEmitterAsync(`${extensionContext}/emitters/${emitter.index}`, emitter));\r\n            }\r\n\r\n            await Promise.all(promises);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadNodeAsync(context: string, node: INode, assign: (babylonTransformNode: TransformNode) => void): Nullable<Promise<TransformNode>> {\r\n        return GLTFLoader.LoadExtensionAsync<IMSFTAudioEmitter_EmittersReference, TransformNode>(context, node, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n\r\n            const babylonMesh = await this._loader.loadNodeAsync(extensionContext, node, (babylonMesh) => {\r\n                for (const emitterIndex of extension.emitters) {\r\n                    const emitter = ArrayItem.Get(`${extensionContext}/emitters`, this._emitters, emitterIndex);\r\n                    promises.push(\r\n                        // eslint-disable-next-line github/no-then\r\n                        this._loadEmitterAsync(`${extensionContext}/emitters/${emitter.index}`, emitter).then(() => {\r\n                            for (const sound of emitter._babylonSounds) {\r\n                                sound.attachToMesh(babylonMesh);\r\n                                if (emitter.innerAngle != undefined || emitter.outerAngle != undefined) {\r\n                                    sound.setLocalDirectionToMesh(Vector3.Forward());\r\n                                    sound.setDirectionalCone(\r\n                                        2 * Tools.ToDegrees(emitter.innerAngle == undefined ? Math.PI : emitter.innerAngle),\r\n                                        2 * Tools.ToDegrees(emitter.outerAngle == undefined ? Math.PI : emitter.outerAngle),\r\n                                        0\r\n                                    );\r\n                                }\r\n                            }\r\n                        })\r\n                    );\r\n                }\r\n\r\n                assign(babylonMesh);\r\n            });\r\n            await Promise.all(promises);\r\n            return babylonMesh;\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadAnimationAsync(context: string, animation: IAnimation): Nullable<Promise<AnimationGroup>> {\r\n        return GLTFLoader.LoadExtensionAsync<ILoaderAnimationEvents, AnimationGroup>(context, animation, this.name, async (extensionContext, extension) => {\r\n            const babylonAnimationGroup = await this._loader.loadAnimationAsync(context, animation);\r\n            const promises = new Array<Promise<any>>();\r\n            ArrayItem.Assign(extension.events);\r\n            for (const event of extension.events) {\r\n                promises.push(this._loadAnimationEventAsync(`${extensionContext}/events/${event.index}`, context, animation, event, babylonAnimationGroup));\r\n            }\r\n            await Promise.all(promises);\r\n            return babylonAnimationGroup;\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadClipAsync(context: string, clip: ILoaderClip): Promise<string> {\r\n        if (clip._objectURL) {\r\n            return clip._objectURL;\r\n        }\r\n\r\n        let promise: Promise<ArrayBufferView>;\r\n        if (clip.uri) {\r\n            promise = this._loader.loadUriAsync(context, clip, clip.uri);\r\n        } else {\r\n            const bufferView = ArrayItem.Get(`${context}/bufferView`, this._loader.gltf.bufferViews, clip.bufferView);\r\n            promise = this._loader.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView);\r\n        }\r\n\r\n        // eslint-disable-next-line github/no-then\r\n        clip._objectURL = promise.then((data) => {\r\n            return URL.createObjectURL(new Blob([data], { type: clip.mimeType }));\r\n        });\r\n\r\n        return clip._objectURL;\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadEmitterAsync(context: string, emitter: ILoaderEmitter): Promise<void> {\r\n        emitter._babylonSounds = emitter._babylonSounds || [];\r\n        if (!emitter._babylonData) {\r\n            const clipPromises = new Array<Promise<any>>();\r\n            const name = emitter.name || `emitter${emitter.index}`;\r\n            const options = {\r\n                loop: false,\r\n                autoplay: false,\r\n                volume: emitter.volume == undefined ? 1 : emitter.volume,\r\n            };\r\n\r\n            for (let i = 0; i < emitter.clips.length; i++) {\r\n                const clipContext = `/extensions/${this.name}/clips`;\r\n                const clip = ArrayItem.Get(clipContext, this._clips, emitter.clips[i].clip);\r\n                clipPromises.push(\r\n                    // eslint-disable-next-line github/no-then\r\n                    this._loadClipAsync(`${clipContext}/${emitter.clips[i].clip}`, clip).then((objectURL: string) => {\r\n                        const sound = (emitter._babylonSounds[i] = new Sound(name, objectURL, this._loader.babylonScene, null, options));\r\n                        sound.refDistance = emitter.refDistance || 1;\r\n                        sound.maxDistance = emitter.maxDistance || 256;\r\n                        sound.rolloffFactor = emitter.rolloffFactor || 1;\r\n                        sound.distanceModel = emitter.distanceModel || \"exponential\";\r\n                    })\r\n                );\r\n            }\r\n\r\n            // eslint-disable-next-line github/no-then\r\n            const promise = Promise.all(clipPromises).then(() => {\r\n                const weights = emitter.clips.map((clip) => {\r\n                    return clip.weight || 1;\r\n                });\r\n                const weightedSound = new WeightedSound(emitter.loop || false, emitter._babylonSounds, weights);\r\n                if (emitter.innerAngle) {\r\n                    weightedSound.directionalConeInnerAngle = 2 * Tools.ToDegrees(emitter.innerAngle);\r\n                }\r\n                if (emitter.outerAngle) {\r\n                    weightedSound.directionalConeOuterAngle = 2 * Tools.ToDegrees(emitter.outerAngle);\r\n                }\r\n                if (emitter.volume) {\r\n                    weightedSound.volume = emitter.volume;\r\n                }\r\n                emitter._babylonData!.sound = weightedSound;\r\n            });\r\n\r\n            emitter._babylonData = {\r\n                loaded: promise,\r\n            };\r\n        }\r\n\r\n        return emitter._babylonData.loaded;\r\n    }\r\n\r\n    private _getEventAction(\r\n        context: string,\r\n        sound: WeightedSound,\r\n        action: IMSFTAudioEmitter_AnimationEventAction,\r\n        time: number,\r\n        startOffset?: number\r\n    ): (currentFrame: number) => void {\r\n        switch (action) {\r\n            case IMSFTAudioEmitter_AnimationEventAction.play: {\r\n                return (currentFrame: number) => {\r\n                    const frameOffset = (startOffset || 0) + (currentFrame - time);\r\n                    sound.play(frameOffset);\r\n                };\r\n            }\r\n            case IMSFTAudioEmitter_AnimationEventAction.stop: {\r\n                return () => {\r\n                    sound.stop();\r\n                };\r\n            }\r\n            case IMSFTAudioEmitter_AnimationEventAction.pause: {\r\n                return () => {\r\n                    sound.pause();\r\n                };\r\n            }\r\n            default: {\r\n                throw new Error(`${context}: Unsupported action ${action}`);\r\n            }\r\n        }\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadAnimationEventAsync(\r\n        context: string,\r\n        animationContext: string,\r\n        animation: IAnimation,\r\n        event: ILoaderAnimationEvent,\r\n        babylonAnimationGroup: AnimationGroup\r\n    ): Promise<void> {\r\n        if (babylonAnimationGroup.targetedAnimations.length == 0) {\r\n            return Promise.resolve();\r\n        }\r\n        const babylonAnimation = babylonAnimationGroup.targetedAnimations[0];\r\n        const emitterIndex = event.emitter;\r\n        const emitter = ArrayItem.Get(`/extensions/${this.name}/emitters`, this._emitters, emitterIndex);\r\n        // eslint-disable-next-line github/no-then\r\n        return this._loadEmitterAsync(context, emitter).then(() => {\r\n            const sound = emitter._babylonData!.sound;\r\n            if (sound) {\r\n                const babylonAnimationEvent = new AnimationEvent(event.time, this._getEventAction(context, sound, event.action, event.time, event.startOffset));\r\n                babylonAnimation.animation.addEvent(babylonAnimationEvent);\r\n                // Make sure all started audio stops when this animation is terminated.\r\n                babylonAnimationGroup.onAnimationGroupEndObservable.add(() => {\r\n                    sound.stop();\r\n                });\r\n                babylonAnimationGroup.onAnimationGroupPauseObservable.add(() => {\r\n                    sound.pause();\r\n                });\r\n            }\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new MSFT_audio_emitter(loader));\r\n","/* eslint-disable github/no-then */\r\nimport type { Nullable } from \"core/types\";\r\nimport { Observable } from \"core/Misc/observable\";\r\nimport { Deferred } from \"core/Misc/deferred\";\r\nimport type { Material } from \"core/Materials/material\";\r\nimport type { TransformNode } from \"core/Meshes/transformNode\";\r\nimport type { Mesh } from \"core/Meshes/mesh\";\r\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\r\nimport type { INode, IMaterial, IBuffer, IScene } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader, ArrayItem } from \"../glTFLoader\";\r\nimport type { IProperty, IMSFTLOD } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"MSFT_lod\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the MSFT_lod extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"MSFT_lod\"]: Partial<{\r\n            /**\r\n             * Maximum number of LODs to load, starting from the lowest LOD.\r\n             */\r\n            maxLODsToLoad: number;\r\n        }>;\r\n    }\r\n}\r\n\r\ninterface IBufferInfo {\r\n    start: number;\r\n    end: number;\r\n    loaded: Deferred<ArrayBufferView>;\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Vendor/MSFT_lod/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class MSFT_lod implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 100;\r\n\r\n    /**\r\n     * Maximum number of LODs to load, starting from the lowest LOD.\r\n     */\r\n    public maxLODsToLoad = 10;\r\n\r\n    /**\r\n     * Observable raised when all node LODs of one level are loaded.\r\n     * The event data is the index of the loaded LOD starting from zero.\r\n     * Dispose the loader to cancel the loading of the next level of LODs.\r\n     */\r\n    public onNodeLODsLoadedObservable = new Observable<number>();\r\n\r\n    /**\r\n     * Observable raised when all material LODs of one level are loaded.\r\n     * The event data is the index of the loaded LOD starting from zero.\r\n     * Dispose the loader to cancel the loading of the next level of LODs.\r\n     */\r\n    public onMaterialLODsLoadedObservable = new Observable<number>();\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    private _bufferLODs = new Array<IBufferInfo>();\r\n\r\n    private _nodeIndexLOD: Nullable<number> = null;\r\n    private _nodeSignalLODs = new Array<Deferred<void>>();\r\n    private _nodePromiseLODs = new Array<Array<Promise<any>>>();\r\n    private _nodeBufferLODs = new Array<IBufferInfo>();\r\n\r\n    private _materialIndexLOD: Nullable<number> = null;\r\n    private _materialSignalLODs = new Array<Deferred<void>>();\r\n    private _materialPromiseLODs = new Array<Array<Promise<any>>>();\r\n    private _materialBufferLODs = new Array<IBufferInfo>();\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        // Options takes precedence. The maxLODsToLoad extension property is retained for back compat.\r\n        // For new extensions, they should only use options.\r\n        this.maxLODsToLoad = this._loader.parent.extensionOptions[NAME]?.maxLODsToLoad ?? this.maxLODsToLoad;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n\r\n        this._nodeIndexLOD = null;\r\n        this._nodeSignalLODs.length = 0;\r\n        this._nodePromiseLODs.length = 0;\r\n        this._nodeBufferLODs.length = 0;\r\n\r\n        this._materialIndexLOD = null;\r\n        this._materialSignalLODs.length = 0;\r\n        this._materialPromiseLODs.length = 0;\r\n        this._materialBufferLODs.length = 0;\r\n\r\n        this.onMaterialLODsLoadedObservable.clear();\r\n        this.onNodeLODsLoadedObservable.clear();\r\n    }\r\n\r\n    /** @internal */\r\n    public onReady(): void {\r\n        for (let indexLOD = 0; indexLOD < this._nodePromiseLODs.length; indexLOD++) {\r\n            const promise = Promise.all(this._nodePromiseLODs[indexLOD]).then(() => {\r\n                if (indexLOD !== 0) {\r\n                    this._loader.endPerformanceCounter(`Node LOD ${indexLOD}`);\r\n                    this._loader.log(`Loaded node LOD ${indexLOD}`);\r\n                }\r\n\r\n                this.onNodeLODsLoadedObservable.notifyObservers(indexLOD);\r\n\r\n                if (indexLOD !== this._nodePromiseLODs.length - 1) {\r\n                    this._loader.startPerformanceCounter(`Node LOD ${indexLOD + 1}`);\r\n                    this._loadBufferLOD(this._nodeBufferLODs, indexLOD + 1);\r\n                    if (this._nodeSignalLODs[indexLOD]) {\r\n                        this._nodeSignalLODs[indexLOD].resolve();\r\n                    }\r\n                }\r\n            });\r\n\r\n            this._loader._completePromises.push(promise);\r\n        }\r\n\r\n        for (let indexLOD = 0; indexLOD < this._materialPromiseLODs.length; indexLOD++) {\r\n            const promise = Promise.all(this._materialPromiseLODs[indexLOD]).then(() => {\r\n                if (indexLOD !== 0) {\r\n                    this._loader.endPerformanceCounter(`Material LOD ${indexLOD}`);\r\n                    this._loader.log(`Loaded material LOD ${indexLOD}`);\r\n                }\r\n\r\n                this.onMaterialLODsLoadedObservable.notifyObservers(indexLOD);\r\n\r\n                if (indexLOD !== this._materialPromiseLODs.length - 1) {\r\n                    this._loader.startPerformanceCounter(`Material LOD ${indexLOD + 1}`);\r\n                    this._loadBufferLOD(this._materialBufferLODs, indexLOD + 1);\r\n                    if (this._materialSignalLODs[indexLOD]) {\r\n                        this._materialSignalLODs[indexLOD].resolve();\r\n                    }\r\n                }\r\n            });\r\n\r\n            this._loader._completePromises.push(promise);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadSceneAsync(context: string, scene: IScene): Nullable<Promise<void>> {\r\n        const promise = this._loader.loadSceneAsync(context, scene);\r\n        this._loadBufferLOD(this._bufferLODs, 0);\r\n        return promise;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadNodeAsync(context: string, node: INode, assign: (babylonTransformNode: TransformNode) => void): Nullable<Promise<TransformNode>> {\r\n        return GLTFLoader.LoadExtensionAsync<IMSFTLOD, TransformNode>(context, node, this.name, async (extensionContext, extension) => {\r\n            let firstPromise: Promise<TransformNode>;\r\n\r\n            const nodeLODs = this._getLODs(extensionContext, node, this._loader.gltf.nodes, extension.ids);\r\n            this._loader.logOpen(`${extensionContext}`);\r\n\r\n            for (let indexLOD = 0; indexLOD < nodeLODs.length; indexLOD++) {\r\n                const nodeLOD = nodeLODs[indexLOD];\r\n\r\n                if (indexLOD !== 0) {\r\n                    this._nodeIndexLOD = indexLOD;\r\n                    this._nodeSignalLODs[indexLOD] = this._nodeSignalLODs[indexLOD] || new Deferred();\r\n                }\r\n\r\n                const assignWrap = (babylonTransformNode: TransformNode) => {\r\n                    assign(babylonTransformNode);\r\n                    babylonTransformNode.setEnabled(false);\r\n                };\r\n\r\n                const promise = this._loader.loadNodeAsync(`/nodes/${nodeLOD.index}`, nodeLOD, assignWrap).then((babylonMesh) => {\r\n                    if (indexLOD !== 0) {\r\n                        // TODO: should not rely on _babylonTransformNode\r\n                        const previousNodeLOD = nodeLODs[indexLOD - 1];\r\n                        if (previousNodeLOD._babylonTransformNode) {\r\n                            this._disposeTransformNode(previousNodeLOD._babylonTransformNode);\r\n                            delete previousNodeLOD._babylonTransformNode;\r\n                        }\r\n                    }\r\n\r\n                    babylonMesh.setEnabled(true);\r\n                    return babylonMesh;\r\n                });\r\n\r\n                this._nodePromiseLODs[indexLOD] = this._nodePromiseLODs[indexLOD] || [];\r\n\r\n                if (indexLOD === 0) {\r\n                    firstPromise = promise;\r\n                } else {\r\n                    this._nodeIndexLOD = null;\r\n                    this._nodePromiseLODs[indexLOD].push(promise);\r\n                }\r\n            }\r\n\r\n            this._loader.logClose();\r\n            return await firstPromise!;\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public _loadMaterialAsync(\r\n        context: string,\r\n        material: IMaterial,\r\n        babylonMesh: Nullable<Mesh>,\r\n        babylonDrawMode: number,\r\n        assign: (babylonMaterial: Material) => void\r\n    ): Nullable<Promise<Material>> {\r\n        // Don't load material LODs if already loading a node LOD.\r\n        if (this._nodeIndexLOD) {\r\n            return null;\r\n        }\r\n\r\n        return GLTFLoader.LoadExtensionAsync<IMSFTLOD, Material>(context, material, this.name, async (extensionContext, extension) => {\r\n            let firstPromise: Promise<Material>;\r\n\r\n            const materialLODs = this._getLODs(extensionContext, material, this._loader.gltf.materials, extension.ids);\r\n            this._loader.logOpen(`${extensionContext}`);\r\n\r\n            for (let indexLOD = 0; indexLOD < materialLODs.length; indexLOD++) {\r\n                const materialLOD = materialLODs[indexLOD];\r\n\r\n                if (indexLOD !== 0) {\r\n                    this._materialIndexLOD = indexLOD;\r\n                }\r\n\r\n                const promise = this._loader\r\n                    ._loadMaterialAsync(`/materials/${materialLOD.index}`, materialLOD, babylonMesh, babylonDrawMode, (babylonMaterial) => {\r\n                        if (indexLOD === 0) {\r\n                            assign(babylonMaterial);\r\n                        }\r\n                    })\r\n                    .then((babylonMaterial) => {\r\n                        if (indexLOD !== 0) {\r\n                            assign(babylonMaterial);\r\n\r\n                            // TODO: should not rely on _data\r\n                            const previousDataLOD = materialLODs[indexLOD - 1]._data!;\r\n                            if (previousDataLOD[babylonDrawMode]) {\r\n                                this._disposeMaterials([previousDataLOD[babylonDrawMode].babylonMaterial]);\r\n                                delete previousDataLOD[babylonDrawMode];\r\n                            }\r\n                        }\r\n\r\n                        return babylonMaterial;\r\n                    });\r\n\r\n                this._materialPromiseLODs[indexLOD] = this._materialPromiseLODs[indexLOD] || [];\r\n\r\n                if (indexLOD === 0) {\r\n                    firstPromise = promise;\r\n                } else {\r\n                    this._materialIndexLOD = null;\r\n                    this._materialPromiseLODs[indexLOD].push(promise);\r\n                }\r\n            }\r\n\r\n            this._loader.logClose();\r\n            return await firstPromise!;\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public _loadUriAsync(context: string, property: IProperty, uri: string): Nullable<Promise<ArrayBufferView>> {\r\n        // Defer the loading of uris if loading a node or material LOD.\r\n        if (this._nodeIndexLOD !== null) {\r\n            this._loader.log(`deferred`);\r\n            const previousIndexLOD = this._nodeIndexLOD - 1;\r\n            this._nodeSignalLODs[previousIndexLOD] = this._nodeSignalLODs[previousIndexLOD] || new Deferred<void>();\r\n            return this._nodeSignalLODs[this._nodeIndexLOD - 1].promise.then(async () => {\r\n                return await this._loader.loadUriAsync(context, property, uri);\r\n            });\r\n        } else if (this._materialIndexLOD !== null) {\r\n            this._loader.log(`deferred`);\r\n            const previousIndexLOD = this._materialIndexLOD - 1;\r\n            this._materialSignalLODs[previousIndexLOD] = this._materialSignalLODs[previousIndexLOD] || new Deferred<void>();\r\n            return this._materialSignalLODs[previousIndexLOD].promise.then(async () => {\r\n                return await this._loader.loadUriAsync(context, property, uri);\r\n            });\r\n        }\r\n\r\n        return null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadBufferAsync(context: string, buffer: IBuffer, byteOffset: number, byteLength: number): Nullable<Promise<ArrayBufferView>> {\r\n        if (this._loader.parent.useRangeRequests && !buffer.uri) {\r\n            if (!this._loader.bin) {\r\n                throw new Error(`${context}: Uri is missing or the binary glTF is missing its binary chunk`);\r\n            }\r\n\r\n            const loadAsync = async (bufferLODs: Array<IBufferInfo>, indexLOD: number) => {\r\n                const start = byteOffset;\r\n                const end = start + byteLength - 1;\r\n                let bufferLOD = bufferLODs[indexLOD];\r\n                if (bufferLOD) {\r\n                    bufferLOD.start = Math.min(bufferLOD.start, start);\r\n                    bufferLOD.end = Math.max(bufferLOD.end, end);\r\n                } else {\r\n                    bufferLOD = { start: start, end: end, loaded: new Deferred() };\r\n                    bufferLODs[indexLOD] = bufferLOD;\r\n                }\r\n\r\n                return await bufferLOD.loaded.promise.then((data) => {\r\n                    return new Uint8Array(data.buffer, data.byteOffset + byteOffset - bufferLOD.start, byteLength);\r\n                });\r\n            };\r\n\r\n            this._loader.log(`deferred`);\r\n\r\n            if (this._nodeIndexLOD !== null) {\r\n                return loadAsync(this._nodeBufferLODs, this._nodeIndexLOD);\r\n            } else if (this._materialIndexLOD !== null) {\r\n                return loadAsync(this._materialBufferLODs, this._materialIndexLOD);\r\n            } else {\r\n                return loadAsync(this._bufferLODs, 0);\r\n            }\r\n        }\r\n\r\n        return null;\r\n    }\r\n\r\n    private _loadBufferLOD(bufferLODs: Array<IBufferInfo>, indexLOD: number): void {\r\n        const bufferLOD = bufferLODs[indexLOD];\r\n        if (bufferLOD) {\r\n            this._loader.log(`Loading buffer range [${bufferLOD.start}-${bufferLOD.end}]`);\r\n            this._loader.bin!.readAsync(bufferLOD.start, bufferLOD.end - bufferLOD.start + 1).then(\r\n                (data) => {\r\n                    bufferLOD.loaded.resolve(data);\r\n                },\r\n                (error) => {\r\n                    bufferLOD.loaded.reject(error);\r\n                }\r\n            );\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @returns an array of LOD properties from lowest to highest.\r\n     * @param context\r\n     * @param property\r\n     * @param array\r\n     * @param ids\r\n     */\r\n    private _getLODs<T>(context: string, property: T, array: ArrayLike<T> | undefined, ids: number[]): T[] {\r\n        if (this.maxLODsToLoad <= 0) {\r\n            throw new Error(\"maxLODsToLoad must be greater than zero\");\r\n        }\r\n\r\n        const properties: T[] = [];\r\n\r\n        for (let i = ids.length - 1; i >= 0; i--) {\r\n            properties.push(ArrayItem.Get(`${context}/ids/${ids[i]}`, array, ids[i]));\r\n            if (properties.length === this.maxLODsToLoad) {\r\n                return properties;\r\n            }\r\n        }\r\n\r\n        properties.push(property);\r\n        return properties;\r\n    }\r\n\r\n    private _disposeTransformNode(babylonTransformNode: TransformNode): void {\r\n        const babylonMaterials: Material[] = [];\r\n        const babylonMaterial = (babylonTransformNode as Mesh).material;\r\n        if (babylonMaterial) {\r\n            babylonMaterials.push(babylonMaterial);\r\n        }\r\n        for (const babylonMesh of babylonTransformNode.getChildMeshes()) {\r\n            if (babylonMesh.material) {\r\n                babylonMaterials.push(babylonMesh.material);\r\n            }\r\n        }\r\n\r\n        babylonTransformNode.dispose();\r\n\r\n        const babylonMaterialsToDispose = babylonMaterials.filter((babylonMaterial) => this._loader.babylonScene.meshes.every((mesh) => mesh.material != babylonMaterial));\r\n        this._disposeMaterials(babylonMaterialsToDispose);\r\n    }\r\n\r\n    private _disposeMaterials(babylonMaterials: Material[]): void {\r\n        const babylonTextures: { [uniqueId: number]: BaseTexture } = {};\r\n\r\n        for (const babylonMaterial of babylonMaterials) {\r\n            for (const babylonTexture of babylonMaterial.getActiveTextures()) {\r\n                babylonTextures[babylonTexture.uniqueId] = babylonTexture;\r\n            }\r\n\r\n            babylonMaterial.dispose();\r\n        }\r\n\r\n        for (const uniqueId in babylonTextures) {\r\n            for (const babylonMaterial of this._loader.babylonScene.materials) {\r\n                if (babylonMaterial.hasTexture(babylonTextures[uniqueId])) {\r\n                    delete babylonTextures[uniqueId];\r\n                }\r\n            }\r\n        }\r\n\r\n        for (const uniqueId in babylonTextures) {\r\n            babylonTextures[uniqueId].dispose();\r\n        }\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new MSFT_lod(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport type { Material } from \"core/Materials/material\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\n\r\nimport type { IMaterial } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"MSFT_minecraftMesh\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the MSFT_minecraftMesh extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"MSFT_minecraftMesh\"]: {};\r\n    }\r\n}\r\n\r\n/** @internal */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class MSFT_minecraftMesh implements IGLTFLoaderExtension {\r\n    /** @internal */\r\n    public readonly name = NAME;\r\n\r\n    /** @internal */\r\n    public enabled: boolean;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /** @internal */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /** @internal */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtraAsync<boolean>(context, material, this.name, async (extraContext, extra) => {\r\n            if (extra) {\r\n                if (!(babylonMaterial instanceof PBRMaterial)) {\r\n                    throw new Error(`${extraContext}: Material type not supported`);\r\n                }\r\n\r\n                const promise = this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial);\r\n\r\n                if (babylonMaterial.needAlphaBlending()) {\r\n                    babylonMaterial.forceDepthWrite = true;\r\n                    babylonMaterial.separateCullingPass = true;\r\n                }\r\n\r\n                babylonMaterial.backFaceCulling = babylonMaterial.forceDepthWrite;\r\n                babylonMaterial.twoSidedLighting = true;\r\n\r\n                return await promise;\r\n            }\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new MSFT_minecraftMesh(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport type { Material } from \"core/Materials/material\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\n\r\nimport type { IMaterial } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"MSFT_sRGBFactors\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the MSFT_sRGBFactors extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"MSFT_sRGBFactors\"]: {};\r\n    }\r\n}\r\n\r\n/** @internal */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class MSFT_sRGBFactors implements IGLTFLoaderExtension {\r\n    /** @internal */\r\n    public readonly name = NAME;\r\n\r\n    /** @internal */\r\n    public enabled: boolean;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /** @internal */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /** @internal*/\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtraAsync<boolean>(context, material, this.name, async (extraContext, extra) => {\r\n            if (extra) {\r\n                if (!(babylonMaterial instanceof PBRMaterial)) {\r\n                    throw new Error(`${extraContext}: Material type not supported`);\r\n                }\r\n\r\n                const promise = this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial);\r\n\r\n                const useExactSrgbConversions = babylonMaterial.getScene().getEngine().useExactSrgbConversions;\r\n                if (!babylonMaterial.albedoTexture) {\r\n                    babylonMaterial.albedoColor.toLinearSpaceToRef(babylonMaterial.albedoColor, useExactSrgbConversions);\r\n                }\r\n\r\n                if (!babylonMaterial.reflectivityTexture) {\r\n                    babylonMaterial.reflectivityColor.toLinearSpaceToRef(babylonMaterial.reflectivityColor, useExactSrgbConversions);\r\n                }\r\n\r\n                return await promise;\r\n            }\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new MSFT_sRGBFactors(loader));\r\n","/* eslint-disable @typescript-eslint/naming-convention */\nimport type { IKHRInteractivity_Declaration, IKHRInteractivity_Graph, IKHRInteractivity_Node } from \"babylonjs-gltf2interface\";\nimport { FlowGraphBlockNames } from \"core/FlowGraph/Blocks/flowGraphBlockNames\";\nimport { Logger } from \"core/Misc/logger\";\nimport type { ISerializedFlowGraphBlock, ISerializedFlowGraphContext } from \"core/FlowGraph/typeDefinitions\";\nimport type { InteractivityEvent, InteractivityGraphToFlowGraphParser } from \"./interactivityGraphParser\";\nimport type { IGLTF } from \"../../glTFLoaderInterfaces\";\nimport { FlowGraphTypes, getAnimationTypeByFlowGraphType } from \"core/FlowGraph/flowGraphRichTypes\";\n\ninterface IGLTFToFlowGraphMappingObject<I = any, O = any> {\n    /**\n     * The name of the property in the FlowGraph block.\n     */\n    name: string;\n    /**\n     * The type of the property in the glTF specs.\n     * If not provided will be inferred.\n     */\n    gltfType?: string;\n    /**\n     * The type of the property in the FlowGraph block.\n     * If not defined it equals the glTF type.\n     */\n    flowGraphType?: string;\n    /**\n     * A function that transforms the data from the glTF to the FlowGraph block.\n     */\n    dataTransformer?: (data: I[], parser: InteractivityGraphToFlowGraphParser) => O[];\n    /**\n     * If the property is in the options passed to the constructor of the block.\n     */\n    inOptions?: boolean;\n\n    /**\n     * If the property is a pointer to a value.\n     * This will add an extra JsonPointerParser block to the graph.\n     */\n    isPointer?: boolean;\n\n    /**\n     * If the property is an index to a value.\n     * if defined this will be the name of the array to find the object in.\n     */\n    isVariable?: boolean;\n\n    /**\n     * the name of the class type this value will be mapped to.\n     * This is used if we generate more than one block for a single glTF node.\n     * Defaults to the first block in the mapping.\n     */\n    toBlock?: FlowGraphBlockNames;\n\n    /**\n     * Used in configuration values. If defined, this will be the default value, if no value is provided.\n     */\n    defaultValue?: O;\n}\n\nexport interface IGLTFToFlowGraphMapping {\n    /**\n     * The type of the FlowGraph block(s).\n     * Typically will be a single element in an array.\n     * When adding blocks defined in this module use the KHR_interactivity prefix.\n     */\n    blocks: (FlowGraphBlockNames | string)[];\n    /**\n     * The inputs of the glTF node mapped to the FlowGraph block.\n     */\n    inputs?: {\n        /**\n         * The value inputs of the glTF node mapped to the FlowGraph block.\n         */\n        values?: { [originName: string]: IGLTFToFlowGraphMappingObject };\n        /**\n         * The flow inputs of the glTF node mapped to the FlowGraph block.\n         */\n        flows?: { [originName: string]: IGLTFToFlowGraphMappingObject };\n    };\n    /**\n     * The outputs of the glTF node mapped to the FlowGraph block.\n     */\n    outputs?: {\n        /**\n         * The value outputs of the glTF node mapped to the FlowGraph block.\n         */\n        values?: { [originName: string]: IGLTFToFlowGraphMappingObject };\n        /**\n         * The flow outputs of the glTF node mapped to the FlowGraph block.\n         */\n        flows?: { [originName: string]: IGLTFToFlowGraphMappingObject };\n    };\n    /**\n     * The configuration of the glTF node mapped to the FlowGraph block.\n     * This information is usually passed to the constructor of the block.\n     */\n    configuration?: { [originName: string]: IGLTFToFlowGraphMappingObject };\n\n    /**\n     * If we generate more than one block for a single glTF node, this mapping will be used to map\n     * between the flowGraph classes.\n     */\n    typeToTypeMapping?: { [originName: string]: IGLTFToFlowGraphMappingObject };\n\n    /**\n     * The connections between two or more blocks.\n     * This is used to connect the blocks in the graph\n     */\n    interBlockConnectors?: {\n        /**\n         * The name of the input connection in the first block.\n         */\n        input: string;\n        /**\n         * The name of the output connection in the second block.\n         */\n        output: string;\n\n        /**\n         * The index of the block in the array of blocks that corresponds to the input.\n         */\n        inputBlockIndex: number;\n        /**\n         * The index of the block in the array of blocks that corresponds to the output.\n         */\n        outputBlockIndex: number;\n        /**\n         * If the connection is a variable connection or a flow connection.\n         */\n        isVariable?: boolean;\n    }[];\n\n    /**\n     * This optional function will allow to validate the node, according to the glTF specs.\n     * For example, if a node has a configuration object, it must be present and correct.\n     * This is a basic node-based validation.\n     * This function is expected to return false and log the error if the node is not valid.\n     * Note that this function can also modify the node, if needed.\n     *\n     * @param gltfBlock the glTF node to validate\n     * @param glTFObject the glTF object\n     * @returns true if validated, false if not.\n     */\n    validation?: (gltfBlock: IKHRInteractivity_Node, interactivityGraph: IKHRInteractivity_Graph, glTFObject?: IGLTF) => { valid: boolean; error?: string };\n\n    /**\n     * This is used if we need extra information for the constructor/options that is not provided directly by the glTF node.\n     * This function can return more than one node, if extra nodes are needed for this block to function correctly.\n     * Returning more than one block will usually happen when a json pointer was provided.\n     *\n     * @param gltfBlock the glTF node\n     * @param mapping the mapping object\n     * @param arrays the arrays of the interactivity object\n     * @param serializedObjects the serialized object\n     * @returns an array of serialized nodes that will be added to the graph.\n     */\n    extraProcessor?: (\n        gltfBlock: IKHRInteractivity_Node,\n        declaration: IKHRInteractivity_Declaration,\n        mapping: IGLTFToFlowGraphMapping,\n        parser: InteractivityGraphToFlowGraphParser,\n        serializedObjects: ISerializedFlowGraphBlock[],\n        context: ISerializedFlowGraphContext,\n        globalGLTF?: IGLTF\n    ) => ISerializedFlowGraphBlock[];\n}\n\nexport function getMappingForFullOperationName(fullOperationName: string) {\n    const [op, extension] = fullOperationName.split(\":\");\n    return getMappingForDeclaration({ op, extension });\n}\n\nexport function getMappingForDeclaration(declaration: IKHRInteractivity_Declaration, returnNoOpIfNotAvailable: boolean = true): IGLTFToFlowGraphMapping | undefined {\n    const mapping = declaration.extension ? gltfExtensionsToFlowGraphMapping[declaration.extension]?.[declaration.op] : gltfToFlowGraphMapping[declaration.op];\n    if (!mapping) {\n        Logger.Warn(`No mapping found for operation ${declaration.op} and extension ${declaration.extension || \"KHR_interactivity\"}`);\n        if (returnNoOpIfNotAvailable) {\n            const inputs: IGLTFToFlowGraphMapping[\"inputs\"] = {};\n            const outputs: IGLTFToFlowGraphMapping[\"outputs\"] = {\n                flows: {},\n            };\n            if (declaration.inputValueSockets) {\n                inputs.values = {};\n                for (const key in declaration.inputValueSockets) {\n                    inputs.values[key] = {\n                        name: key,\n                    };\n                }\n            }\n            if (declaration.outputValueSockets) {\n                outputs.values = {};\n                Object.keys(declaration.outputValueSockets).forEach((key) => {\n                    outputs.values![key] = {\n                        name: key,\n                    };\n                });\n            }\n            return {\n                blocks: [], // no blocks, just mapping\n                inputs,\n                outputs,\n            };\n        }\n    }\n    return mapping;\n}\n\n/**\n * This function will add new mapping to glTF interactivity.\n * Other extensions can define new types of blocks, this is the way to let interactivity know how to parse them.\n * @param key the type of node, i.e. \"variable/get\"\n * @param extension the extension of the interactivity operation, i.e. \"KHR_selectability\"\n * @param mapping The mapping object. See documentation or examples below.\n */\nexport function addNewInteractivityFlowGraphMapping(key: string, extension: string, mapping: IGLTFToFlowGraphMapping) {\n    gltfExtensionsToFlowGraphMapping[extension] ||= {};\n    gltfExtensionsToFlowGraphMapping[extension][key] = mapping;\n}\n\nconst gltfExtensionsToFlowGraphMapping: { [extension: string]: { [key: string]: IGLTFToFlowGraphMapping } } = {\n    /**\n     * This is the BABYLON extension for glTF interactivity.\n     * It defines babylon-specific blocks and operations.\n     */\n    BABYLON: {\n        /**\n         * flow/log is a flow node that logs input to the console.\n         * It has \"in\" and \"out\" flows, and takes a message as input.\n         * The message can be any type of value.\n         * The message is logged to the console when the \"in\" flow is triggered.\n         * The \"out\" flow is triggered when the message is logged.\n         */\n        \"flow/log\": {\n            blocks: [FlowGraphBlockNames.ConsoleLog],\n            inputs: {\n                values: {\n                    message: { name: \"message\" },\n                },\n            },\n        },\n    },\n};\n\n// this mapper is just a way to convert the glTF nodes to FlowGraph nodes in terms of input/output connection names and values.\nconst gltfToFlowGraphMapping: { [key: string]: IGLTFToFlowGraphMapping } = {\n    \"event/onStart\": {\n        blocks: [FlowGraphBlockNames.SceneReadyEvent],\n        outputs: {\n            flows: {\n                out: { name: \"done\" },\n            },\n        },\n    },\n    \"event/onTick\": {\n        blocks: [FlowGraphBlockNames.SceneTickEvent],\n        inputs: {},\n        outputs: {\n            values: {\n                timeSinceLastTick: { name: \"deltaTime\", gltfType: \"number\" /*, dataTransformer: (time: number) => time / 1000*/ },\n            },\n            flows: {\n                out: { name: \"done\" },\n            },\n        },\n    },\n    \"event/send\": {\n        blocks: [FlowGraphBlockNames.SendCustomEvent],\n        extraProcessor(gltfBlock, declaration, _mapping, parser, serializedObjects) {\n            // set eventId and eventData. The configuration object of the glTF should have a single object.\n            // validate that we are running it on the right block.\n            if (declaration.op !== \"event/send\" || !gltfBlock.configuration || Object.keys(gltfBlock.configuration).length !== 1) {\n                throw new Error(\"Receive event should have a single configuration object, the event itself\");\n            }\n            const eventConfiguration = gltfBlock.configuration[\"event\"];\n            const eventId = eventConfiguration.value[0];\n            if (typeof eventId !== \"number\") {\n                throw new Error(\"Event id should be a number\");\n            }\n            const event: InteractivityEvent = parser.arrays.events[eventId];\n            const serializedObject = serializedObjects[0];\n            serializedObject.config ||= {};\n            serializedObject.config.eventId = event.eventId;\n            serializedObject.config.eventData = event.eventData;\n            return serializedObjects;\n        },\n    },\n    \"event/receive\": {\n        blocks: [FlowGraphBlockNames.ReceiveCustomEvent],\n        outputs: {\n            flows: {\n                out: { name: \"done\" },\n            },\n        },\n        validation(gltfBlock, interactivityGraph) {\n            if (!gltfBlock.configuration) {\n                Logger.Error(\"Receive event should have a configuration object\");\n                return { valid: false, error: \"Receive event should have a configuration object\" };\n            }\n            const eventConfiguration = gltfBlock.configuration[\"event\"];\n            if (!eventConfiguration) {\n                Logger.Error(\"Receive event should have a single configuration object, the event itself\");\n                return { valid: false, error: \"Receive event should have a single configuration object, the event itself\" };\n            }\n            const eventId = eventConfiguration.value[0];\n            if (typeof eventId !== \"number\") {\n                Logger.Error(\"Event id should be a number\");\n                return { valid: false, error: \"Event id should be a number\" };\n            }\n            const event = interactivityGraph.events?.[eventId];\n            if (!event) {\n                Logger.Error(`Event with id ${eventId} not found`);\n                return { valid: false, error: `Event with id ${eventId} not found` };\n            }\n            return { valid: true };\n        },\n        extraProcessor(gltfBlock, declaration, _mapping, parser, serializedObjects) {\n            // set eventId and eventData. The configuration object of the glTF should have a single object.\n            // validate that we are running it on the right block.\n            if (declaration.op !== \"event/receive\" || !gltfBlock.configuration || Object.keys(gltfBlock.configuration).length !== 1) {\n                throw new Error(\"Receive event should have a single configuration object, the event itself\");\n            }\n            const eventConfiguration = gltfBlock.configuration[\"event\"];\n            const eventId = eventConfiguration.value[0];\n            if (typeof eventId !== \"number\") {\n                throw new Error(\"Event id should be a number\");\n            }\n            const event: InteractivityEvent = parser.arrays.events[eventId];\n            const serializedObject = serializedObjects[0];\n            serializedObject.config ||= {};\n            serializedObject.config.eventId = event.eventId;\n            serializedObject.config.eventData = event.eventData;\n            return serializedObjects;\n        },\n    },\n    \"math/E\": getSimpleInputMapping(FlowGraphBlockNames.E),\n    \"math/Pi\": getSimpleInputMapping(FlowGraphBlockNames.PI),\n    \"math/Inf\": getSimpleInputMapping(FlowGraphBlockNames.Inf),\n    \"math/NaN\": getSimpleInputMapping(FlowGraphBlockNames.NaN),\n    \"math/abs\": getSimpleInputMapping(FlowGraphBlockNames.Abs),\n    \"math/sign\": getSimpleInputMapping(FlowGraphBlockNames.Sign),\n    \"math/trunc\": getSimpleInputMapping(FlowGraphBlockNames.Trunc),\n    \"math/floor\": getSimpleInputMapping(FlowGraphBlockNames.Floor),\n    \"math/ceil\": getSimpleInputMapping(FlowGraphBlockNames.Ceil),\n    \"math/round\": {\n        blocks: [FlowGraphBlockNames.Round],\n        configuration: {},\n        inputs: {\n            values: {\n                a: { name: \"a\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n        extraProcessor(gltfBlock, declaration, _mapping, parser, serializedObjects) {\n            // configure it to work the way glTF specifies\n            serializedObjects[0].config ||= {};\n            serializedObjects[0].config.roundHalfAwayFromZero = true;\n            return serializedObjects;\n        },\n    },\n    \"math/fract\": getSimpleInputMapping(FlowGraphBlockNames.Fraction),\n    \"math/neg\": getSimpleInputMapping(FlowGraphBlockNames.Negation),\n    \"math/add\": getSimpleInputMapping(FlowGraphBlockNames.Add, [\"a\", \"b\"], true),\n    \"math/sub\": getSimpleInputMapping(FlowGraphBlockNames.Subtract, [\"a\", \"b\"], true),\n    \"math/mul\": {\n        blocks: [FlowGraphBlockNames.Multiply],\n        extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects) {\n            // configure it to work the way glTF specifies\n            serializedObjects[0].config ||= {};\n            serializedObjects[0].config.useMatrixPerComponent = true;\n            serializedObjects[0].config.preventIntegerFloatArithmetic = true;\n            // try to infer the type or fallback to Integer\n            // check the gltf block for the inputs, see if they have a type\n            let type = -1;\n            Object.keys(_gltfBlock.values || {}).find((value) => {\n                if (_gltfBlock.values?.[value].type !== undefined) {\n                    type = _gltfBlock.values[value].type;\n                    return true;\n                }\n                return false;\n            });\n            if (type !== -1) {\n                serializedObjects[0].config.type = _parser.arrays.types[type].flowGraphType;\n            }\n            return serializedObjects;\n        },\n        validation(gltfBlock) {\n            if (gltfBlock.values) {\n                // make sure types are the same\n                return ValidateTypes(gltfBlock);\n            }\n            return { valid: true };\n        },\n    },\n    \"math/div\": getSimpleInputMapping(FlowGraphBlockNames.Divide, [\"a\", \"b\"], true),\n    \"math/rem\": getSimpleInputMapping(FlowGraphBlockNames.Modulo, [\"a\", \"b\"]),\n    \"math/min\": getSimpleInputMapping(FlowGraphBlockNames.Min, [\"a\", \"b\"]),\n    \"math/max\": getSimpleInputMapping(FlowGraphBlockNames.Max, [\"a\", \"b\"]),\n    \"math/clamp\": getSimpleInputMapping(FlowGraphBlockNames.Clamp, [\"a\", \"b\", \"c\"]),\n    \"math/saturate\": getSimpleInputMapping(FlowGraphBlockNames.Saturate),\n    \"math/mix\": getSimpleInputMapping(FlowGraphBlockNames.MathInterpolation, [\"a\", \"b\", \"c\"]),\n    \"math/eq\": getSimpleInputMapping(FlowGraphBlockNames.Equality, [\"a\", \"b\"]),\n    \"math/lt\": getSimpleInputMapping(FlowGraphBlockNames.LessThan, [\"a\", \"b\"]),\n    \"math/le\": getSimpleInputMapping(FlowGraphBlockNames.LessThanOrEqual, [\"a\", \"b\"]),\n    \"math/gt\": getSimpleInputMapping(FlowGraphBlockNames.GreaterThan, [\"a\", \"b\"]),\n    \"math/ge\": getSimpleInputMapping(FlowGraphBlockNames.GreaterThanOrEqual, [\"a\", \"b\"]),\n    \"math/isNaN\": getSimpleInputMapping(FlowGraphBlockNames.IsNaN),\n    \"math/isInf\": getSimpleInputMapping(FlowGraphBlockNames.IsInfinity),\n    \"math/select\": {\n        blocks: [FlowGraphBlockNames.Conditional],\n        inputs: {\n            values: {\n                condition: { name: \"condition\" },\n                // Should we validate those have the same type here, or assume it is already validated?\n                a: { name: \"onTrue\" },\n                b: { name: \"onFalse\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"output\" },\n            },\n        },\n    },\n    \"math/random\": {\n        blocks: [FlowGraphBlockNames.Random],\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n    },\n    \"math/sin\": getSimpleInputMapping(FlowGraphBlockNames.Sin),\n    \"math/cos\": getSimpleInputMapping(FlowGraphBlockNames.Cos),\n    \"math/tan\": getSimpleInputMapping(FlowGraphBlockNames.Tan),\n    \"math/asin\": getSimpleInputMapping(FlowGraphBlockNames.Asin),\n    \"math/acos\": getSimpleInputMapping(FlowGraphBlockNames.Acos),\n    \"math/atan\": getSimpleInputMapping(FlowGraphBlockNames.Atan),\n    \"math/atan2\": getSimpleInputMapping(FlowGraphBlockNames.Atan2, [\"a\", \"b\"]),\n    \"math/sinh\": getSimpleInputMapping(FlowGraphBlockNames.Sinh),\n    \"math/cosh\": getSimpleInputMapping(FlowGraphBlockNames.Cosh),\n    \"math/tanh\": getSimpleInputMapping(FlowGraphBlockNames.Tanh),\n    \"math/asinh\": getSimpleInputMapping(FlowGraphBlockNames.Asinh),\n    \"math/acosh\": getSimpleInputMapping(FlowGraphBlockNames.Acosh),\n    \"math/atanh\": getSimpleInputMapping(FlowGraphBlockNames.Atanh),\n    \"math/exp\": getSimpleInputMapping(FlowGraphBlockNames.Exponential),\n    \"math/log\": getSimpleInputMapping(FlowGraphBlockNames.Log),\n    \"math/log2\": getSimpleInputMapping(FlowGraphBlockNames.Log2),\n    \"math/log10\": getSimpleInputMapping(FlowGraphBlockNames.Log10),\n    \"math/sqrt\": getSimpleInputMapping(FlowGraphBlockNames.SquareRoot),\n    \"math/cbrt\": getSimpleInputMapping(FlowGraphBlockNames.CubeRoot),\n    \"math/pow\": getSimpleInputMapping(FlowGraphBlockNames.Power, [\"a\", \"b\"]),\n    \"math/length\": getSimpleInputMapping(FlowGraphBlockNames.Length),\n    \"math/normalize\": getSimpleInputMapping(FlowGraphBlockNames.Normalize),\n    \"math/dot\": getSimpleInputMapping(FlowGraphBlockNames.Dot, [\"a\", \"b\"]),\n    \"math/cross\": getSimpleInputMapping(FlowGraphBlockNames.Cross, [\"a\", \"b\"]),\n    \"math/rotate2D\": {\n        blocks: [FlowGraphBlockNames.Rotate2D],\n        inputs: {\n            values: {\n                a: { name: \"a\" },\n                angle: { name: \"b\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n    },\n    \"math/rotate3D\": {\n        blocks: [FlowGraphBlockNames.Rotate3D],\n        inputs: {\n            values: {\n                a: { name: \"a\" },\n                rotation: { name: \"b\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n    },\n    \"math/transform\": {\n        // glTF transform is vectorN with matrixN\n        blocks: [FlowGraphBlockNames.TransformVector],\n        inputs: {\n            values: {\n                a: { name: \"a\" },\n                b: { name: \"b\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n    },\n    \"math/combine2\": {\n        blocks: [FlowGraphBlockNames.CombineVector2],\n        inputs: {\n            values: {\n                a: { name: \"input_0\", gltfType: \"number\" },\n                b: { name: \"input_1\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n    },\n    \"math/combine3\": {\n        blocks: [FlowGraphBlockNames.CombineVector3],\n        inputs: {\n            values: {\n                a: { name: \"input_0\", gltfType: \"number\" },\n                b: { name: \"input_1\", gltfType: \"number\" },\n                c: { name: \"input_2\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n    },\n    \"math/combine4\": {\n        blocks: [FlowGraphBlockNames.CombineVector4],\n        inputs: {\n            values: {\n                a: { name: \"input_0\", gltfType: \"number\" },\n                b: { name: \"input_1\", gltfType: \"number\" },\n                c: { name: \"input_2\", gltfType: \"number\" },\n                d: { name: \"input_3\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n    },\n    // one input, N outputs! outputs named using numbers.\n    \"math/extract2\": {\n        blocks: [FlowGraphBlockNames.ExtractVector2],\n        inputs: {\n            values: {\n                a: { name: \"input\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                \"0\": { name: \"output_0\" },\n                \"1\": { name: \"output_1\" },\n            },\n        },\n    },\n    \"math/extract3\": {\n        blocks: [FlowGraphBlockNames.ExtractVector3],\n        inputs: {\n            values: {\n                a: { name: \"input\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                \"0\": { name: \"output_0\" },\n                \"1\": { name: \"output_1\" },\n                \"2\": { name: \"output_2\" },\n            },\n        },\n    },\n    \"math/extract4\": {\n        blocks: [FlowGraphBlockNames.ExtractVector4],\n        inputs: {\n            values: {\n                a: { name: \"input\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                \"0\": { name: \"output_0\" },\n                \"1\": { name: \"output_1\" },\n                \"2\": { name: \"output_2\" },\n                \"3\": { name: \"output_3\" },\n            },\n        },\n    },\n    \"math/transpose\": getSimpleInputMapping(FlowGraphBlockNames.Transpose),\n    \"math/determinant\": getSimpleInputMapping(FlowGraphBlockNames.Determinant),\n    \"math/inverse\": getSimpleInputMapping(FlowGraphBlockNames.InvertMatrix),\n    \"math/matMul\": getSimpleInputMapping(FlowGraphBlockNames.MatrixMultiplication, [\"a\", \"b\"]),\n    \"math/matCompose\": {\n        blocks: [FlowGraphBlockNames.MatrixCompose],\n        inputs: {\n            values: {\n                translation: { name: \"position\", gltfType: \"float3\" },\n                rotation: { name: \"rotationQuaternion\", gltfType: \"float4\" },\n                scale: { name: \"scaling\", gltfType: \"float3\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n        extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects, context) {\n            // configure it to work the way glTF specifies\n            const d = serializedObjects[0].dataInputs.find((input) => input.name === \"rotationQuaternion\");\n            if (!d) {\n                throw new Error(\"Rotation quaternion input not found\");\n            }\n            // if value is defined, set the type to quaternion\n            if (context._connectionValues[d.uniqueId]) {\n                context._connectionValues[d.uniqueId].type = FlowGraphTypes.Quaternion;\n            }\n            return serializedObjects;\n        },\n    },\n    \"math/matDecompose\": {\n        blocks: [FlowGraphBlockNames.MatrixDecompose],\n        inputs: {\n            values: {\n                a: { name: \"input\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                translation: { name: \"position\" },\n                rotation: { name: \"rotationQuaternion\" },\n                scale: { name: \"scaling\" },\n            },\n        },\n    },\n    \"math/quatConjugate\": getSimpleInputMapping(FlowGraphBlockNames.Conjugate, [\"a\"]),\n    \"math/quatMul\": {\n        blocks: [FlowGraphBlockNames.Multiply],\n        inputs: {\n            values: {\n                a: { name: \"a\", gltfType: \"vector4\" },\n                b: { name: \"b\", gltfType: \"vector4\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n        extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects) {\n            serializedObjects[0].config ||= {};\n            serializedObjects[0].config.type = FlowGraphTypes.Quaternion;\n            return serializedObjects;\n        },\n    },\n    \"math/quatAngleBetween\": getSimpleInputMapping(FlowGraphBlockNames.AngleBetween, [\"a\", \"b\"]),\n    \"math/quatFromAxisAngle\": {\n        blocks: [FlowGraphBlockNames.QuaternionFromAxisAngle],\n        inputs: {\n            values: {\n                axis: { name: \"a\", gltfType: \"float3\" },\n                angle: { name: \"b\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n    },\n    \"math/quatToAxisAngle\": getSimpleInputMapping(FlowGraphBlockNames.AxisAngleFromQuaternion, [\"a\"]),\n    \"math/quatFromDirections\": getSimpleInputMapping(FlowGraphBlockNames.QuaternionFromDirections, [\"a\", \"b\"]),\n    \"math/combine2x2\": {\n        blocks: [FlowGraphBlockNames.CombineMatrix2D],\n        inputs: {\n            values: {\n                a: { name: \"input_0\", gltfType: \"number\" },\n                b: { name: \"input_1\", gltfType: \"number\" },\n                c: { name: \"input_2\", gltfType: \"number\" },\n                d: { name: \"input_3\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n        extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects) {\n            // configure it to work the way glTF specifies\n            serializedObjects[0].config ||= {};\n            serializedObjects[0].config.inputIsColumnMajor = true;\n            return serializedObjects;\n        },\n    },\n    \"math/extract2x2\": {\n        blocks: [FlowGraphBlockNames.ExtractMatrix2D],\n        inputs: {\n            values: {\n                a: { name: \"input\", gltfType: \"float2x2\" },\n            },\n        },\n        outputs: {\n            values: {\n                \"0\": { name: \"output_0\" },\n                \"1\": { name: \"output_1\" },\n                \"2\": { name: \"output_2\" },\n                \"3\": { name: \"output_3\" },\n            },\n        },\n    },\n    \"math/combine3x3\": {\n        blocks: [FlowGraphBlockNames.CombineMatrix3D],\n        inputs: {\n            values: {\n                a: { name: \"input_0\", gltfType: \"number\" },\n                b: { name: \"input_1\", gltfType: \"number\" },\n                c: { name: \"input_2\", gltfType: \"number\" },\n                d: { name: \"input_3\", gltfType: \"number\" },\n                e: { name: \"input_4\", gltfType: \"number\" },\n                f: { name: \"input_5\", gltfType: \"number\" },\n                g: { name: \"input_6\", gltfType: \"number\" },\n                h: { name: \"input_7\", gltfType: \"number\" },\n                i: { name: \"input_8\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n        extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects) {\n            // configure it to work the way glTF specifies\n            serializedObjects[0].config ||= {};\n            serializedObjects[0].config.inputIsColumnMajor = true;\n            return serializedObjects;\n        },\n    },\n    \"math/extract3x3\": {\n        blocks: [FlowGraphBlockNames.ExtractMatrix3D],\n        inputs: {\n            values: {\n                a: { name: \"input\", gltfType: \"float3x3\" },\n            },\n        },\n        outputs: {\n            values: {\n                \"0\": { name: \"output_0\" },\n                \"1\": { name: \"output_1\" },\n                \"2\": { name: \"output_2\" },\n                \"3\": { name: \"output_3\" },\n                \"4\": { name: \"output_4\" },\n                \"5\": { name: \"output_5\" },\n                \"6\": { name: \"output_6\" },\n                \"7\": { name: \"output_7\" },\n                \"8\": { name: \"output_8\" },\n            },\n        },\n    },\n    \"math/combine4x4\": {\n        blocks: [FlowGraphBlockNames.CombineMatrix],\n        inputs: {\n            values: {\n                a: { name: \"input_0\", gltfType: \"number\" },\n                b: { name: \"input_1\", gltfType: \"number\" },\n                c: { name: \"input_2\", gltfType: \"number\" },\n                d: { name: \"input_3\", gltfType: \"number\" },\n                e: { name: \"input_4\", gltfType: \"number\" },\n                f: { name: \"input_5\", gltfType: \"number\" },\n                g: { name: \"input_6\", gltfType: \"number\" },\n                h: { name: \"input_7\", gltfType: \"number\" },\n                i: { name: \"input_8\", gltfType: \"number\" },\n                j: { name: \"input_9\", gltfType: \"number\" },\n                k: { name: \"input_10\", gltfType: \"number\" },\n                l: { name: \"input_11\", gltfType: \"number\" },\n                m: { name: \"input_12\", gltfType: \"number\" },\n                n: { name: \"input_13\", gltfType: \"number\" },\n                o: { name: \"input_14\", gltfType: \"number\" },\n                p: { name: \"input_15\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n        extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects) {\n            // configure it to work the way glTF specifies\n            serializedObjects[0].config ||= {};\n            serializedObjects[0].config.inputIsColumnMajor = true;\n            return serializedObjects;\n        },\n    },\n    \"math/extract4x4\": {\n        blocks: [FlowGraphBlockNames.ExtractMatrix],\n        configuration: {},\n        inputs: {\n            values: {\n                a: { name: \"input\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                \"0\": { name: \"output_0\" },\n                \"1\": { name: \"output_1\" },\n                \"2\": { name: \"output_2\" },\n                \"3\": { name: \"output_3\" },\n                \"4\": { name: \"output_4\" },\n                \"5\": { name: \"output_5\" },\n                \"6\": { name: \"output_6\" },\n                \"7\": { name: \"output_7\" },\n                \"8\": { name: \"output_8\" },\n                \"9\": { name: \"output_9\" },\n                \"10\": { name: \"output_10\" },\n                \"11\": { name: \"output_11\" },\n                \"12\": { name: \"output_12\" },\n                \"13\": { name: \"output_13\" },\n                \"14\": { name: \"output_14\" },\n                \"15\": { name: \"output_15\" },\n            },\n        },\n    },\n    \"math/not\": {\n        blocks: [FlowGraphBlockNames.BitwiseNot],\n        inputs: {\n            values: {\n                a: { name: \"a\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n        extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects, context) {\n            // configure it to work the way glTF specifies\n            serializedObjects[0].config ||= {};\n            // try to infer the type or fallback to Integer\n            const socketIn = serializedObjects[0].dataInputs[0];\n            serializedObjects[0].config.valueType = context._connectionValues[socketIn.uniqueId]?.type ?? FlowGraphTypes.Integer;\n            return serializedObjects;\n        },\n    },\n    \"math/and\": {\n        blocks: [FlowGraphBlockNames.BitwiseAnd],\n        inputs: {\n            values: {\n                a: { name: \"a\" },\n                b: { name: \"b\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n        extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects, context) {\n            // configure it to work the way glTF specifies\n            serializedObjects[0].config ||= {};\n            // try to infer the type or fallback to Integer\n            const socketInA = serializedObjects[0].dataInputs[0];\n            const socketInB = serializedObjects[0].dataInputs[1];\n            serializedObjects[0].config.valueType =\n                context._connectionValues[socketInA.uniqueId]?.type ?? context._connectionValues[socketInB.uniqueId]?.type ?? FlowGraphTypes.Integer;\n            return serializedObjects;\n        },\n    },\n    \"math/or\": {\n        blocks: [FlowGraphBlockNames.BitwiseOr],\n        inputs: {\n            values: {\n                a: { name: \"a\" },\n                b: { name: \"b\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n        extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects, context) {\n            // configure it to work the way glTF specifies\n            serializedObjects[0].config ||= {};\n            // try to infer the type or fallback to Integer\n            const socketInA = serializedObjects[0].dataInputs[0];\n            const socketInB = serializedObjects[0].dataInputs[1];\n            serializedObjects[0].config.valueType =\n                context._connectionValues[socketInA.uniqueId]?.type ?? context._connectionValues[socketInB.uniqueId]?.type ?? FlowGraphTypes.Integer;\n            return serializedObjects;\n        },\n    },\n    \"math/xor\": {\n        blocks: [FlowGraphBlockNames.BitwiseXor],\n        inputs: {\n            values: {\n                a: { name: \"a\" },\n                b: { name: \"b\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n        extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects, context) {\n            // configure it to work the way glTF specifies\n            serializedObjects[0].config ||= {};\n            // try to infer the type or fallback to Integer\n            const socketInA = serializedObjects[0].dataInputs[0];\n            const socketInB = serializedObjects[0].dataInputs[1];\n            serializedObjects[0].config.valueType =\n                context._connectionValues[socketInA.uniqueId]?.type ?? context._connectionValues[socketInB.uniqueId]?.type ?? FlowGraphTypes.Integer;\n            return serializedObjects;\n        },\n    },\n    \"math/asr\": getSimpleInputMapping(FlowGraphBlockNames.BitwiseRightShift, [\"a\", \"b\"]),\n    \"math/lsl\": getSimpleInputMapping(FlowGraphBlockNames.BitwiseLeftShift, [\"a\", \"b\"]),\n    \"math/clz\": getSimpleInputMapping(FlowGraphBlockNames.LeadingZeros),\n    \"math/ctz\": getSimpleInputMapping(FlowGraphBlockNames.TrailingZeros),\n    \"math/popcnt\": getSimpleInputMapping(FlowGraphBlockNames.OneBitsCounter),\n    \"math/rad\": getSimpleInputMapping(FlowGraphBlockNames.DegToRad),\n    \"math/deg\": getSimpleInputMapping(FlowGraphBlockNames.RadToDeg),\n    \"type/boolToInt\": getSimpleInputMapping(FlowGraphBlockNames.BooleanToInt),\n    \"type/boolToFloat\": getSimpleInputMapping(FlowGraphBlockNames.BooleanToFloat),\n    \"type/intToBool\": getSimpleInputMapping(FlowGraphBlockNames.IntToBoolean),\n    \"type/intToFloat\": getSimpleInputMapping(FlowGraphBlockNames.IntToFloat),\n    \"type/floatToInt\": getSimpleInputMapping(FlowGraphBlockNames.FloatToInt),\n    \"type/floatToBool\": getSimpleInputMapping(FlowGraphBlockNames.FloatToBoolean),\n\n    // flows\n    \"flow/sequence\": {\n        blocks: [FlowGraphBlockNames.Sequence],\n        extraProcessor(gltfBlock, _declaration, _mapping, _arrays, serializedObjects) {\n            const serializedObject = serializedObjects[0];\n            serializedObject.config ||= {};\n            serializedObject.config.outputSignalCount = Object.keys(gltfBlock.flows || []).length;\n            serializedObject.signalOutputs.forEach((output, index) => {\n                output.name = \"out_\" + index;\n            });\n            return serializedObjects;\n        },\n    },\n    \"flow/branch\": {\n        blocks: [FlowGraphBlockNames.Branch],\n        outputs: {\n            flows: {\n                true: { name: \"onTrue\" },\n                false: { name: \"onFalse\" },\n            },\n        },\n    },\n    \"flow/switch\": {\n        blocks: [FlowGraphBlockNames.Switch],\n        configuration: {\n            cases: { name: \"cases\", inOptions: true, defaultValue: [] },\n        },\n        inputs: {\n            values: {\n                selection: { name: \"case\" },\n                default: { name: \"default\" },\n            },\n        },\n        validation(gltfBlock) {\n            if (gltfBlock.configuration && gltfBlock.configuration.cases) {\n                const cases = gltfBlock.configuration.cases.value;\n                const onlyIntegers = cases.every((caseValue) => {\n                    // case value should be an integer. Since Number.isInteger(1.0) is true, we need to check if toString has only digits.\n                    return typeof caseValue === \"number\" && /^-?\\d+$/.test(caseValue.toString());\n                });\n                if (!onlyIntegers) {\n                    Logger.Warn(\"Switch cases should be integers. Using empty array instead.\");\n                    gltfBlock.configuration.cases.value = [] as number[];\n                    return { valid: true };\n                }\n                // check for duplicates\n                const uniqueCases = new Set(cases);\n                gltfBlock.configuration.cases.value = Array.from(uniqueCases) as number[];\n            }\n            return { valid: true };\n        },\n        extraProcessor(gltfBlock, declaration, _mapping, _arrays, serializedObjects) {\n            // convert all names of output flow to out_$1 apart from \"default\"\n            if (declaration.op !== \"flow/switch\" || !gltfBlock.flows || Object.keys(gltfBlock.flows).length === 0) {\n                throw new Error(\"Switch should have a single configuration object, the cases array\");\n            }\n            const serializedObject = serializedObjects[0];\n            serializedObject.signalOutputs.forEach((output) => {\n                if (output.name !== \"default\") {\n                    output.name = \"out_\" + output.name;\n                }\n            });\n            return serializedObjects;\n        },\n    },\n    \"flow/while\": {\n        blocks: [FlowGraphBlockNames.WhileLoop],\n        outputs: {\n            flows: {\n                loopBody: { name: \"executionFlow\" },\n            },\n        },\n    },\n    \"flow/for\": {\n        blocks: [FlowGraphBlockNames.ForLoop],\n        configuration: {\n            initialIndex: { name: \"initialIndex\", gltfType: \"number\", inOptions: true, defaultValue: 0 },\n        },\n        inputs: {\n            values: {\n                startIndex: { name: \"startIndex\", gltfType: \"number\" },\n                endIndex: { name: \"endIndex\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                index: { name: \"index\" },\n            },\n            flows: {\n                loopBody: { name: \"executionFlow\" },\n            },\n        },\n        extraProcessor(_gltfBlock, _declaration, _mapping, _arrays, serializedObjects) {\n            const serializedObject = serializedObjects[0];\n            serializedObject.config ||= {};\n            serializedObject.config.incrementIndexWhenLoopDone = true;\n            return serializedObjects;\n        },\n    },\n    \"flow/doN\": {\n        blocks: [FlowGraphBlockNames.DoN],\n        configuration: {},\n        inputs: {\n            values: {\n                n: { name: \"maxExecutions\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                currentCount: { name: \"executionCount\" },\n            },\n        },\n    },\n    \"flow/multiGate\": {\n        blocks: [FlowGraphBlockNames.MultiGate],\n        configuration: {\n            isRandom: { name: \"isRandom\", gltfType: \"boolean\", inOptions: true, defaultValue: false },\n            isLoop: { name: \"isLoop\", gltfType: \"boolean\", inOptions: true, defaultValue: false },\n        },\n        extraProcessor(gltfBlock, declaration, _mapping, _arrays, serializedObjects) {\n            if (declaration.op !== \"flow/multiGate\" || !gltfBlock.flows || Object.keys(gltfBlock.flows).length === 0) {\n                throw new Error(\"MultiGate should have a single configuration object, the number of output flows\");\n            }\n            const serializedObject = serializedObjects[0];\n            serializedObject.config ||= {};\n            serializedObject.config.outputSignalCount = Object.keys(gltfBlock.flows).length;\n            serializedObject.signalOutputs.forEach((output, index) => {\n                output.name = \"out_\" + index;\n            });\n            return serializedObjects;\n        },\n    },\n    \"flow/waitAll\": {\n        blocks: [FlowGraphBlockNames.WaitAll],\n        configuration: {\n            inputFlows: { name: \"inputSignalCount\", gltfType: \"number\", inOptions: true, defaultValue: 0 },\n        },\n        inputs: {\n            flows: {\n                reset: { name: \"reset\" },\n                \"[segment]\": { name: \"in_$1\" },\n            },\n        },\n        validation(gltfBlock) {\n            // check that the configuration value is an integer\n            if (typeof gltfBlock.configuration?.inputFlows?.value[0] !== \"number\") {\n                gltfBlock.configuration = gltfBlock.configuration || {\n                    inputFlows: { value: [0] },\n                };\n                gltfBlock.configuration.inputFlows.value = [0];\n            }\n            return { valid: true };\n        },\n    },\n    \"flow/throttle\": {\n        blocks: [FlowGraphBlockNames.Throttle],\n        outputs: {\n            flows: {\n                err: { name: \"error\" },\n            },\n        },\n    },\n    \"flow/setDelay\": {\n        blocks: [FlowGraphBlockNames.SetDelay],\n        outputs: {\n            flows: {\n                err: { name: \"error\" },\n            },\n        },\n    },\n    \"flow/cancelDelay\": {\n        blocks: [FlowGraphBlockNames.CancelDelay],\n    },\n    \"variable/get\": {\n        blocks: [FlowGraphBlockNames.GetVariable],\n        validation(gltfBlock) {\n            if (!gltfBlock.configuration?.variable?.value) {\n                Logger.Error(\"Variable get block should have a variable configuration\");\n                return { valid: false, error: \"Variable get block should have a variable configuration\" };\n            }\n            return { valid: true };\n        },\n        configuration: {\n            variable: {\n                name: \"variable\",\n                gltfType: \"number\",\n                flowGraphType: \"string\",\n                inOptions: true,\n                isVariable: true,\n                dataTransformer(index, parser) {\n                    return [parser.getVariableName(index[0])];\n                },\n            },\n        },\n    },\n    \"variable/set\": {\n        blocks: [FlowGraphBlockNames.SetVariable],\n        configuration: {\n            variable: {\n                name: \"variable\",\n                gltfType: \"number\",\n                flowGraphType: \"string\",\n                inOptions: true,\n                isVariable: true,\n                dataTransformer(index: number[], parser): string[] {\n                    return [parser.getVariableName(index[0])];\n                },\n            },\n        },\n    },\n    \"variable/setMultiple\": {\n        blocks: [FlowGraphBlockNames.SetVariable],\n        configuration: {\n            variables: {\n                name: \"variables\",\n                gltfType: \"number\",\n                flowGraphType: \"string\",\n                inOptions: true,\n                dataTransformer(index: number[][], parser): string[][] {\n                    return [index[0].map((i) => parser.getVariableName(i))];\n                },\n            },\n        },\n        extraProcessor(_gltfBlock, _declaration, _mapping, parser, serializedObjects) {\n            // variable/get configuration\n            const serializedGetVariable = serializedObjects[0];\n            serializedGetVariable.dataInputs.forEach((input) => {\n                input.name = parser.getVariableName(+input.name);\n            });\n\n            return serializedObjects;\n        },\n    },\n    \"variable/interpolate\": {\n        blocks: [\n            FlowGraphBlockNames.ValueInterpolation,\n            FlowGraphBlockNames.Context,\n            FlowGraphBlockNames.PlayAnimation,\n            FlowGraphBlockNames.BezierCurveEasing,\n            FlowGraphBlockNames.GetVariable,\n        ],\n        configuration: {\n            variable: {\n                name: \"propertyName\",\n                inOptions: true,\n                isVariable: true,\n                dataTransformer(index, parser) {\n                    return [parser.getVariableName(index[0])];\n                },\n            },\n            useSlerp: {\n                name: \"animationType\",\n                inOptions: true,\n                defaultValue: false,\n                dataTransformer: (value) => {\n                    if (value[0] === true) {\n                        return [FlowGraphTypes.Quaternion];\n                    } else {\n                        return [undefined];\n                    }\n                },\n            },\n        },\n        inputs: {\n            values: {\n                value: { name: \"value_1\" },\n                duration: { name: \"duration_1\", gltfType: \"number\" },\n                p1: { name: \"controlPoint1\", toBlock: FlowGraphBlockNames.BezierCurveEasing },\n                p2: { name: \"controlPoint2\", toBlock: FlowGraphBlockNames.BezierCurveEasing },\n            },\n            flows: {\n                in: { name: \"in\", toBlock: FlowGraphBlockNames.PlayAnimation },\n            },\n        },\n        outputs: {\n            flows: {\n                err: { name: \"error\", toBlock: FlowGraphBlockNames.PlayAnimation },\n                out: { name: \"out\", toBlock: FlowGraphBlockNames.PlayAnimation },\n                done: { name: \"done\", toBlock: FlowGraphBlockNames.PlayAnimation },\n            },\n        },\n        interBlockConnectors: [\n            {\n                input: \"object\",\n                output: \"userVariables\",\n                inputBlockIndex: 2,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n            {\n                input: \"animation\",\n                output: \"animation\",\n                inputBlockIndex: 2,\n                outputBlockIndex: 0,\n                isVariable: true,\n            },\n            {\n                input: \"easingFunction\",\n                output: \"easingFunction\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 3,\n                isVariable: true,\n            },\n            {\n                input: \"value_0\",\n                output: \"value\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 4,\n                isVariable: true,\n            },\n        ],\n        extraProcessor(gltfBlock, _declaration, _mapping, parser, serializedObjects) {\n            // is useSlerp is used, animationType should be set to be quaternion!\n            const serializedValueInterpolation = serializedObjects[0];\n            const propertyIndex = gltfBlock.configuration?.variable.value[0];\n            if (typeof propertyIndex !== \"number\") {\n                Logger.Error(\"Variable index is not defined for variable interpolation block\");\n                throw new Error(\"Variable index is not defined for variable interpolation block\");\n            }\n            const variable = parser.arrays.staticVariables[propertyIndex];\n            // if not set by useSlerp\n            if (typeof serializedValueInterpolation.config.animationType.value === \"undefined\") {\n                // get the value type\n                parser.arrays.staticVariables;\n                serializedValueInterpolation.config.animationType.value = getAnimationTypeByFlowGraphType(variable.type);\n            }\n\n            // variable/get configuration\n            const serializedGetVariable = serializedObjects[4];\n            serializedGetVariable.config ||= {};\n            serializedGetVariable.config.variable ||= {};\n            serializedGetVariable.config.variable.value = parser.getVariableName(propertyIndex);\n\n            // get the control points from the easing block\n            serializedObjects[3].config ||= {};\n\n            return serializedObjects;\n        },\n    },\n    \"pointer/get\": {\n        blocks: [FlowGraphBlockNames.GetProperty, FlowGraphBlockNames.JsonPointerParser],\n        configuration: {\n            pointer: { name: \"jsonPointer\", toBlock: FlowGraphBlockNames.JsonPointerParser },\n        },\n        inputs: {\n            values: {\n                \"[segment]\": { name: \"$1\", toBlock: FlowGraphBlockNames.JsonPointerParser },\n            },\n        },\n        interBlockConnectors: [\n            {\n                input: \"object\",\n                output: \"object\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n            {\n                input: \"propertyName\",\n                output: \"propertyName\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n            {\n                input: \"customGetFunction\",\n                output: \"getFunction\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n        ],\n        extraProcessor(gltfBlock, _declaration, _mapping, parser, serializedObjects) {\n            serializedObjects.forEach((serializedObject) => {\n                // check if it is the json pointer block\n                if (serializedObject.className === FlowGraphBlockNames.JsonPointerParser) {\n                    serializedObject.config ||= {};\n                    serializedObject.config.outputValue = true;\n                }\n            });\n            return serializedObjects;\n        },\n    },\n    \"pointer/set\": {\n        blocks: [FlowGraphBlockNames.SetProperty, FlowGraphBlockNames.JsonPointerParser],\n        configuration: {\n            pointer: { name: \"jsonPointer\", toBlock: FlowGraphBlockNames.JsonPointerParser },\n        },\n        inputs: {\n            values: {\n                // must be defined due to the array taking over\n                value: { name: \"value\" },\n                \"[segment]\": { name: \"$1\", toBlock: FlowGraphBlockNames.JsonPointerParser },\n            },\n        },\n        outputs: {\n            flows: {\n                err: { name: \"error\" },\n            },\n        },\n        interBlockConnectors: [\n            {\n                input: \"object\",\n                output: \"object\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n            {\n                input: \"propertyName\",\n                output: \"propertyName\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n            {\n                input: \"customSetFunction\",\n                output: \"setFunction\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n        ],\n        extraProcessor(gltfBlock, _declaration, _mapping, parser, serializedObjects) {\n            serializedObjects.forEach((serializedObject) => {\n                // check if it is the json pointer block\n                if (serializedObject.className === FlowGraphBlockNames.JsonPointerParser) {\n                    serializedObject.config ||= {};\n                    serializedObject.config.outputValue = true;\n                }\n            });\n            return serializedObjects;\n        },\n    },\n    \"pointer/interpolate\": {\n        // interpolate, parse the pointer and play the animation generated. 3 blocks!\n        blocks: [FlowGraphBlockNames.ValueInterpolation, FlowGraphBlockNames.JsonPointerParser, FlowGraphBlockNames.PlayAnimation, FlowGraphBlockNames.BezierCurveEasing],\n        configuration: {\n            pointer: { name: \"jsonPointer\", toBlock: FlowGraphBlockNames.JsonPointerParser },\n        },\n        inputs: {\n            values: {\n                value: { name: \"value_1\" },\n                \"[segment]\": { name: \"$1\", toBlock: FlowGraphBlockNames.JsonPointerParser },\n                duration: { name: \"duration_1\", gltfType: \"number\" /*, inOptions: true */ },\n                p1: { name: \"controlPoint1\", toBlock: FlowGraphBlockNames.BezierCurveEasing },\n                p2: { name: \"controlPoint2\", toBlock: FlowGraphBlockNames.BezierCurveEasing },\n            },\n            flows: {\n                in: { name: \"in\", toBlock: FlowGraphBlockNames.PlayAnimation },\n            },\n        },\n        outputs: {\n            flows: {\n                err: { name: \"error\", toBlock: FlowGraphBlockNames.PlayAnimation },\n                out: { name: \"out\", toBlock: FlowGraphBlockNames.PlayAnimation },\n                done: { name: \"done\", toBlock: FlowGraphBlockNames.PlayAnimation },\n            },\n        },\n        interBlockConnectors: [\n            {\n                input: \"object\",\n                output: \"object\",\n                inputBlockIndex: 2,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n            {\n                input: \"propertyName\",\n                output: \"propertyName\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n            {\n                input: \"customBuildAnimation\",\n                output: \"generateAnimationsFunction\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n            {\n                input: \"animation\",\n                output: \"animation\",\n                inputBlockIndex: 2,\n                outputBlockIndex: 0,\n                isVariable: true,\n            },\n            {\n                input: \"easingFunction\",\n                output: \"easingFunction\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 3,\n                isVariable: true,\n            },\n            {\n                input: \"value_0\",\n                output: \"value\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n        ],\n        extraProcessor(gltfBlock, _declaration, _mapping, parser, serializedObjects) {\n            serializedObjects.forEach((serializedObject) => {\n                // check if it is the json pointer block\n                if (serializedObject.className === FlowGraphBlockNames.JsonPointerParser) {\n                    serializedObject.config ||= {};\n                    serializedObject.config.outputValue = true;\n                } else if (serializedObject.className === FlowGraphBlockNames.ValueInterpolation) {\n                    serializedObject.config ||= {};\n                    Object.keys(gltfBlock.values || []).forEach((key) => {\n                        const value = gltfBlock.values?.[key];\n                        if (key === \"value\" && value) {\n                            // get the type of the value\n                            const type = value.type;\n                            if (type !== undefined) {\n                                serializedObject.config.animationType = parser.arrays.types[type].flowGraphType;\n                            }\n                        }\n                    });\n                }\n            });\n            return serializedObjects;\n        },\n    },\n    \"animation/start\": {\n        blocks: [FlowGraphBlockNames.PlayAnimation, FlowGraphBlockNames.ArrayIndex, \"KHR_interactivity/FlowGraphGLTFDataProvider\"],\n        inputs: {\n            values: {\n                animation: { name: \"index\", gltfType: \"number\", toBlock: FlowGraphBlockNames.ArrayIndex },\n                speed: { name: \"speed\", gltfType: \"number\" },\n                startTime: { name: \"from\", gltfType: \"number\", dataTransformer: (time: number[], parser) => [time[0] * parser._animationTargetFps] },\n                endTime: { name: \"to\", gltfType: \"number\", dataTransformer: (time: number[], parser) => [time[0] * parser._animationTargetFps] },\n            },\n        },\n        outputs: {\n            flows: {\n                err: { name: \"error\" },\n            },\n        },\n        interBlockConnectors: [\n            {\n                input: \"animationGroup\",\n                output: \"value\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n            {\n                input: \"array\",\n                output: \"animationGroups\",\n                inputBlockIndex: 1,\n                outputBlockIndex: 2,\n                isVariable: true,\n            },\n        ],\n        extraProcessor(_gltfBlock, _declaration, _mapping, _arrays, serializedObjects, _context, globalGLTF) {\n            // add the glTF to the configuration of the last serialized object\n            const serializedObject = serializedObjects[serializedObjects.length - 1];\n            serializedObject.config ||= {};\n            serializedObject.config.glTF = globalGLTF;\n            return serializedObjects;\n        },\n    },\n    \"animation/stop\": {\n        blocks: [FlowGraphBlockNames.StopAnimation, FlowGraphBlockNames.ArrayIndex, \"KHR_interactivity/FlowGraphGLTFDataProvider\"],\n        inputs: {\n            values: {\n                animation: { name: \"index\", gltfType: \"number\", toBlock: FlowGraphBlockNames.ArrayIndex },\n            },\n        },\n        outputs: {\n            flows: {\n                err: { name: \"error\" },\n            },\n        },\n        interBlockConnectors: [\n            {\n                input: \"animationGroup\",\n                output: \"value\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n            {\n                input: \"array\",\n                output: \"animationGroups\",\n                inputBlockIndex: 1,\n                outputBlockIndex: 2,\n                isVariable: true,\n            },\n        ],\n        extraProcessor(_gltfBlock, _declaration, _mapping, _arrays, serializedObjects, _context, globalGLTF) {\n            // add the glTF to the configuration of the last serialized object\n            const serializedObject = serializedObjects[serializedObjects.length - 1];\n            serializedObject.config ||= {};\n            serializedObject.config.glTF = globalGLTF;\n            return serializedObjects;\n        },\n    },\n    \"animation/stopAt\": {\n        blocks: [FlowGraphBlockNames.StopAnimation, FlowGraphBlockNames.ArrayIndex, \"KHR_interactivity/FlowGraphGLTFDataProvider\"],\n        configuration: {},\n        inputs: {\n            values: {\n                animation: { name: \"index\", gltfType: \"number\", toBlock: FlowGraphBlockNames.ArrayIndex },\n                stopTime: { name: \"stopAtFrame\", gltfType: \"number\", dataTransformer: (time: number[], parser) => [time[0] * parser._animationTargetFps] },\n            },\n        },\n        outputs: {\n            flows: {\n                err: { name: \"error\" },\n            },\n        },\n        interBlockConnectors: [\n            {\n                input: \"animationGroup\",\n                output: \"value\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n            {\n                input: \"array\",\n                output: \"animationGroups\",\n                inputBlockIndex: 1,\n                outputBlockIndex: 2,\n                isVariable: true,\n            },\n        ],\n        extraProcessor(_gltfBlock, _declaration, _mapping, _arrays, serializedObjects, _context, globalGLTF) {\n            // add the glTF to the configuration of the last serialized object\n            const serializedObject = serializedObjects[serializedObjects.length - 1];\n            serializedObject.config ||= {};\n            serializedObject.config.glTF = globalGLTF;\n            return serializedObjects;\n        },\n    },\n    \"math/switch\": {\n        blocks: [FlowGraphBlockNames.DataSwitch],\n        configuration: {\n            cases: { name: \"cases\", inOptions: true, defaultValue: [] },\n        },\n        inputs: {\n            values: {\n                selection: { name: \"case\" },\n            },\n        },\n        validation(gltfBlock) {\n            if (gltfBlock.configuration && gltfBlock.configuration.cases) {\n                const cases = gltfBlock.configuration.cases.value;\n                const onlyIntegers = cases.every((caseValue) => {\n                    // case value should be an integer. Since Number.isInteger(1.0) is true, we need to check if toString has only digits.\n                    return typeof caseValue === \"number\" && /^-?\\d+$/.test(caseValue.toString());\n                });\n                if (!onlyIntegers) {\n                    Logger.Warn(\"Switch cases should be integers. Using empty array instead.\");\n                    gltfBlock.configuration.cases.value = [] as number[];\n                    return { valid: true };\n                }\n                // check for duplicates\n                const uniqueCases = new Set(cases);\n                gltfBlock.configuration.cases.value = Array.from(uniqueCases) as number[];\n            }\n            return { valid: true };\n        },\n        extraProcessor(_gltfBlock, _declaration, _mapping, _arrays, serializedObjects) {\n            const serializedObject = serializedObjects[0];\n            serializedObject.dataInputs.forEach((input) => {\n                if (input.name !== \"default\" && input.name !== \"case\") {\n                    input.name = \"in_\" + input.name;\n                }\n            });\n            serializedObject.config ||= {};\n            serializedObject.config.treatCasesAsIntegers = true;\n            return serializedObjects;\n        },\n    },\n    \"debug/log\": {\n        blocks: [FlowGraphBlockNames.ConsoleLog],\n        configuration: {\n            message: { name: \"messageTemplate\", inOptions: true },\n        },\n    },\n};\n\nfunction getSimpleInputMapping(type: FlowGraphBlockNames, inputs: string[] = [\"a\"], inferType?: boolean): IGLTFToFlowGraphMapping {\n    return {\n        blocks: [type],\n        inputs: {\n            values: inputs.reduce(\n                (acc, input) => {\n                    acc[input] = { name: input };\n                    return acc;\n                },\n                {} as { [key: string]: { name: string } }\n            ),\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n        extraProcessor(gltfBlock, _declaration, _mapping, _parser, serializedObjects) {\n            if (inferType) {\n                // configure it to work the way glTF specifies\n                serializedObjects[0].config ||= {};\n                serializedObjects[0].config.preventIntegerFloatArithmetic = true;\n                // try to infer the type or fallback to Integer\n                // check the gltf block for the inputs, see if they have a type\n                let type = -1;\n                Object.keys(gltfBlock.values || {}).find((value) => {\n                    if (gltfBlock.values?.[value].type !== undefined) {\n                        type = gltfBlock.values[value].type;\n                        return true;\n                    }\n                    return false;\n                });\n                if (type !== -1) {\n                    serializedObjects[0].config.type = _parser.arrays.types[type].flowGraphType;\n                }\n            }\n            return serializedObjects;\n        },\n        validation(gltfBlock) {\n            if (inferType) {\n                // make sure types are the same\n                return ValidateTypes(gltfBlock);\n            }\n            return { valid: true };\n        },\n    };\n}\n\nfunction ValidateTypes(gltfBlock: IKHRInteractivity_Node): { valid: boolean; error?: string } {\n    if (gltfBlock.values) {\n        const types = Object.keys(gltfBlock.values)\n            .map((key) => gltfBlock.values![key].type)\n            .filter((type) => type !== undefined);\n        const allSameType = types.every((type) => type === types[0]);\n        if (!allSameType) {\n            return { valid: false, error: \"All inputs must be of the same type\" };\n        }\n    }\n    return { valid: true };\n}\n\nexport function getAllSupportedNativeNodeTypes(): string[] {\n    return Object.keys(gltfToFlowGraphMapping);\n}\n\n/**\n * \n * These are the nodes from the specs:\n\n### Math Nodes\n1. **Constants**\n   - E (`math/E`) FlowGraphBlockNames.E\n   - Pi (`math/Pi`) FlowGraphBlockNames.PI\n   - Infinity (`math/Inf`) FlowGraphBlockNames.Inf\n   - Not a Number (`math/NaN`) FlowGraphBlockNames.NaN\n2. **Arithmetic Nodes**\n   - Absolute Value (`math/abs`) FlowGraphBlockNames.Abs\n   - Sign (`math/sign`) FlowGraphBlockNames.Sign\n   - Truncate (`math/trunc`) FlowGraphBlockNames.Trunc\n   - Floor (`math/floor`) FlowGraphBlockNames.Floor\n   - Ceil (`math/ceil`) FlowGraphBlockNames.Ceil\n   - Round (`math/round`)  FlowGraphBlockNames.Round\n   - Fraction (`math/fract`) FlowGraphBlockNames.Fract\n   - Negation (`math/neg`) FlowGraphBlockNames.Negation\n   - Addition (`math/add`) FlowGraphBlockNames.Add\n   - Subtraction (`math/sub`) FlowGraphBlockNames.Subtract\n   - Multiplication (`math/mul`) FlowGraphBlockNames.Multiply\n   - Division (`math/div`) FlowGraphBlockNames.Divide\n   - Remainder (`math/rem`) FlowGraphBlockNames.Modulo\n   - Minimum (`math/min`) FlowGraphBlockNames.Min\n   - Maximum (`math/max`) FlowGraphBlockNames.Max\n   - Clamp (`math/clamp`) FlowGraphBlockNames.Clamp\n   - Saturate (`math/saturate`) FlowGraphBlockNames.Saturate\n   - Interpolate (`math/mix`) FlowGraphBlockNames.MathInterpolation\n3. **Comparison Nodes**\n   - Equality (`math/eq`) FlowGraphBlockNames.Equality\n   - Less Than (`math/lt`) FlowGraphBlockNames.LessThan\n   - Less Than Or Equal To (`math/le`) FlowGraphBlockNames.LessThanOrEqual\n   - Greater Than (`math/gt`) FlowGraphBlockNames.GreaterThan\n   - Greater Than Or Equal To (`math/ge`) FlowGraphBlockNames.GreaterThanOrEqual\n4. **Special Nodes**\n   - Is Not a Number (`math/isNaN`) FlowGraphBlockNames.IsNaN\n   - Is Infinity (`math/isInf`) FlowGraphBlockNames.IsInfinity\n   - Select (`math/select`) FlowGraphBlockNames.Conditional\n   - Switch (`math/switch`) FlowGraphBlockNames.DataSwitch\n   - Random (`math/random`) FlowGraphBlockNames.Random\n5. **Angle and Trigonometry Nodes**\n   - Degrees-To-Radians (`math/rad`) FlowGraphBlockNames.DegToRad\n   - Radians-To-Degrees (`math/deg`) FlowGraphBlockNames.RadToDeg\n   - Sine (`math/sin`)  FlowGraphBlockNames.Sin\n   - Cosine (`math/cos`) FlowGraphBlockNames.Cos\n   - Tangent (`math/tan`) FlowGraphBlockNames.Tan\n   - Arcsine (`math/asin`) FlowGraphBlockNames.Asin\n   - Arccosine (`math/acos`) FlowGraphBlockNames.Acos\n   - Arctangent (`math/atan`) FlowGraphBlockNames.Atan\n   - Arctangent 2 (`math/atan2`) FlowGraphBlockNames.Atan2\n6. **Hyperbolic Nodes**\n   - Hyperbolic Sine (`math/sinh`) FlowGraphBlockNames.Sinh\n   - Hyperbolic Cosine (`math/cosh`) FlowGraphBlockNames.Cosh\n   - Hyperbolic Tangent (`math/tanh`) FlowGraphBlockNames.Tanh\n   - Inverse Hyperbolic Sine (`math/asinh`) FlowGraphBlockNames.Asinh\n   - Inverse Hyperbolic Cosine (`math/acosh`) FlowGraphBlockNames.Acosh\n   - Inverse Hyperbolic Tangent (`math/atanh`) FlowGraphBlockNames.Atanh\n7. **Exponential Nodes**\n   - Exponent (`math/exp`) FlowGraphBlockNames.Exponential\n   - Natural Logarithm (`math/log`) FlowGraphBlockNames.Log\n   - Base-2 Logarithm (`math/log2`) FlowGraphBlockNames.Log2\n   - Base-10 Logarithm (`math/log10`) FlowGraphBlockNames.Log10\n   - Square Root (`math/sqrt`) FlowGraphBlockNames.SquareRoot\n   - Cube Root (`math/cbrt`) FlowGraphBlockNames.CubeRoot\n   - Power (`math/pow`) FlowGraphBlockNames.Power\n8. **Vector Nodes**\n   - Length (`math/length`) FlowGraphBlockNames.Length\n   - Normalize (`math/normalize`) FlowGraphBlockNames.Normalize\n   - Dot Product (`math/dot`) FlowGraphBlockNames.Dot\n   - Cross Product (`math/cross`) FlowGraphBlockNames.Cross\n   - Rotate 2D (`math/rotate2D`) FlowGraphBlockNames.Rotate2D\n   - Rotate 3D (`math/rotate3D`) FlowGraphBlockNames.Rotate3D\n   - Transform (`math/transform`) FlowGraphBlockNames.TransformVector\n9. **Matrix Nodes**\n   - Transpose (`math/transpose`) FlowGraphBlockNames.Transpose\n   - Determinant (`math/determinant`) FlowGraphBlockNames.Determinant\n   - Inverse (`math/inverse`) FlowGraphBlockNames.InvertMatrix\n   - Multiplication (`math/matMul`) FlowGraphBlockNames.MatrixMultiplication\n   - Compose (`math/matCompose`) FlowGraphBlockNames.MatrixCompose\n   - Decompose (`math/matDecompose`) FlowGraphBlockNames.MatrixDecompose\n10. **Quaternion Nodes**\n    - Conjugate (`math/quatConjugate`) FlowGraphBlockNames.Conjugate\n    - Multiplication (`math/quatMul`) FlowGraphBlockNames.Multiply\n    - Angle Between Quaternions (`math/quatAngleBetween`) FlowGraphBlockNames.AngleBetween\n    - Quaternion From Axis Angle (`math/quatFromAxisAngle`) FlowGraphBlockNames.QuaternionFromAxisAngle\n    - Quaternion To Axis Angle (`math/quatToAxisAngle`) FlowGraphBlockNames.QuaternionToAxisAngle\n    - Quaternion From Two Directional Vectors (`math/quatFromDirections`) FlowGraphBlockNames.QuaternionFromDirections\n11. **Swizzle Nodes**\n    - Combine (`math/combine2`, `math/combine3`, `math/combine4`, `math/combine2x2`, `math/combine3x3`, `math/combine4x4`)\n        FlowGraphBlockNames.CombineVector2, FlowGraphBlockNames.CombineVector3, FlowGraphBlockNames.CombineVector4\n        FlowGraphBlockNames.CombineMatrix2D, FlowGraphBlockNames.CombineMatrix3D, FlowGraphBlockNames.CombineMatrix\n    - Extract (`math/extract2`, `math/extract3`, `math/extract4`, `math/extract2x2`, `math/extract3x3`, `math/extract4x4`)\n        FlowGraphBlockNames.ExtractVector2, FlowGraphBlockNames.ExtractVector3, FlowGraphBlockNames.ExtractVector4\n        FlowGraphBlockNames.ExtractMatrix2D, FlowGraphBlockNames.ExtractMatrix3D, FlowGraphBlockNames.ExtractMatrix\n12. **Integer Arithmetic Nodes**\n    - Absolute Value (`math/abs`) FlowGraphBlockNames.Abs\n    - Sign (`math/sign`) FlowGraphBlockNames.Sign\n    - Negation (`math/neg`) FlowGraphBlockNames.Negation\n    - Addition (`math/add`) FlowGraphBlockNames.Add\n    - Subtraction (`math/sub`) FlowGraphBlockNames.Subtract\n    - Multiplication (`math/mul`) FlowGraphBlockNames.Multiply\n    - Division (`math/div`) FlowGraphBlockNames.Divide\n    - Remainder (`math/rem`) FlowGraphBlockNames.Modulo\n    - Minimum (`math/min`) FlowGraphBlockNames.Min\n    - Maximum (`math/max`) FlowGraphBlockNames.Max\n    - Clamp (`math/clamp`) FlowGraphBlockNames.Clamp\n13. **Integer Comparison Nodes**\n    - Equality (`math/eq`) FlowGraphBlockNames.Equality\n    - Less Than (`math/lt`) FlowGraphBlockNames.LessThan\n    - Less Than Or Equal To (`math/le`) FlowGraphBlockNames.LessThanOrEqual\n    - Greater Than (`math/gt`) FlowGraphBlockNames.GreaterThan\n    - Greater Than Or Equal To (`math/ge`) FlowGraphBlockNames.GreaterThanOrEqual\n14. **Integer Bitwise Nodes**\n    - Bitwise NOT (`math/not`) FlowGraphBlockNames.BitwiseNot\n    - Bitwise AND (`math/and`) FlowGraphBlockNames.BitwiseAnd\n    - Bitwise OR (`math/or`) FlowGraphBlockNames.BitwiseOr\n    - Bitwise XOR (`math/xor`) FlowGraphBlockNames.BitwiseXor\n    - Right Shift (`math/asr`) FlowGraphBlockNames.BitwiseRightShift\n    - Left Shift (`math/lsl`) FlowGraphBlockNames.BitwiseLeftShift\n    - Count Leading Zeros (`math/clz`) FlowGraphBlockNames.LeadingZeros\n    - Count Trailing Zeros (`math/ctz`) FlowGraphBlockNames.TrailingZeros\n    - Count One Bits (`math/popcnt`) FlowGraphBlockNames.OneBitsCounter\n15. **Boolean Arithmetic Nodes**\n    - Equality (`math/eq`) FlowGraphBlockNames.Equality\n    - Boolean NOT (`math/not`) FlowGraphBlockNames.BitwiseNot\n    - Boolean AND (`math/and`) FlowGraphBlockNames.BitwiseAnd\n    - Boolean OR (`math/or`) FlowGraphBlockNames.BitwiseOr\n    - Boolean XOR (`math/xor`) FlowGraphBlockNames.BitwiseXor\n\n### Type Conversion Nodes\n1. **Boolean Conversion Nodes**\n   - Boolean to Integer (`type/boolToInt`) FlowGraphBlockNames.BooleanToInt\n   - Boolean to Float (`type/boolToFloat`) FlowGraphBlockNames.BooleanToFloat\n2. **Integer Conversion Nodes**\n   - Integer to Boolean (`type/intToBool`) FlowGraphBlockNames.IntToBoolean\n   - Integer to Float (`type/intToFloat`) FlowGraphBlockNames.IntToFloat\n3. **Float Conversion Nodes**\n   - Float to Boolean (`type/floatToBool`) FlowGraphBlockNames.FloatToBoolean\n   - Float to Integer (`type/floatToInt`) FlowGraphBlockNames.FloatToInt\n\n### Control Flow Nodes\n1. **Sync Nodes**\n   - Sequence (`flow/sequence`) FlowGraphBlockNames.Sequence\n   - Branch (`flow/branch`) FlowGraphBlockNames.Branch\n   - Switch (`flow/switch`) FlowGraphBlockNames.Switch\n   - While Loop (`flow/while`) FlowGraphBlockNames.WhileLoop\n   - For Loop (`flow/for`) FlowGraphBlockNames.ForLoop\n   - Do N (`flow/doN`) FlowGraphBlockNames.DoN\n   - Multi Gate (`flow/multiGate`) FlowGraphBlockNames.MultiGate\n   - Wait All (`flow/waitAll`) FlowGraphBlockNames.WaitAll\n   - Throttle (`flow/throttle`) FlowGraphBlockNames.Throttle\n2. **Delay Nodes**\n   - Set Delay (`flow/setDelay`) FlowGraphBlockNames.SetDelay\n   - Cancel Delay (`flow/cancelDelay`) FlowGraphBlockNames.CancelDelay\n\n### State Manipulation Nodes\n1. **Custom Variable Access**\n   - Variable Get (`variable/get`) FlowGraphBlockNames.GetVariable\n   - Variable Set (`variable/set`) FlowGraphBlockNames.SetVariable\n   - Variable Interpolate (`variable/interpolate`)\n2. **Object Model Access** // TODO fully test this!!!\n   - JSON Pointer Template Parsing (`pointer/get`) [FlowGraphBlockNames.GetProperty, FlowGraphBlockNames.JsonPointerParser]\n   - Effective JSON Pointer Generation (`pointer/set`) [FlowGraphBlockNames.SetProperty, FlowGraphBlockNames.JsonPointerParser]\n   - Pointer Get (`pointer/get`) [FlowGraphBlockNames.GetProperty, FlowGraphBlockNames.JsonPointerParser]\n   - Pointer Set (`pointer/set`) [FlowGraphBlockNames.SetProperty, FlowGraphBlockNames.JsonPointerParser]\n   - Pointer Interpolate (`pointer/interpolate`) [FlowGraphBlockNames.ValueInterpolation, FlowGraphBlockNames.JsonPointerParser, FlowGraphBlockNames.PlayAnimation, FlowGraphBlockNames.Easing]\n\n### Animation Control Nodes\n1. **Animation Play** (`animation/start`) FlowGraphBlockNames.PlayAnimation\n2. **Animation Stop** (`animation/stop`) FlowGraphBlockNames.StopAnimation \n3. **Animation Stop At** (`animation/stopAt`) FlowGraphBlockNames.StopAnimation \n\n### Event Nodes\n1. **Lifecycle Event Nodes**\n   - On Start (`event/onStart`) FlowGraphBlockNames.SceneReadyEvent\n   - On Tick (`event/onTick`) FlowGraphBlockNames.SceneTickEvent\n2. **Custom Event Nodes**\n   - Receive (`event/receive`) FlowGraphBlockNames.ReceiveCustomEvent\n   - Send (`event/send`) FlowGraphBlockNames.SendCustomEvent\n\n */\n","import type { IKHRInteractivity_Graph, IKHRInteractivity_Node, IKHRInteractivity_OutputSocketReference, IKHRInteractivity_Variable } from \"babylonjs-gltf2interface\";\nimport type { IGLTF } from \"../../glTFLoaderInterfaces\";\nimport type { IGLTFToFlowGraphMapping } from \"./declarationMapper\";\nimport { getMappingForDeclaration, getMappingForFullOperationName } from \"./declarationMapper\";\nimport { Logger } from \"core/Misc/logger\";\nimport type { ISerializedFlowGraph, ISerializedFlowGraphBlock, ISerializedFlowGraphConnection, ISerializedFlowGraphContext } from \"core/FlowGraph/typeDefinitions\";\nimport { RandomGUID } from \"core/Misc/guid\";\nimport type { IFlowGraphBlockConfiguration } from \"core/FlowGraph/flowGraphBlock\";\nimport type { FlowGraphBlockNames } from \"core/FlowGraph/Blocks/flowGraphBlockNames\";\nimport { FlowGraphConnectionType } from \"core/FlowGraph/flowGraphConnection\";\nimport { FlowGraphTypes } from \"core/FlowGraph/flowGraphRichTypes\";\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport interface InteractivityEvent {\n    eventId: string;\n    eventData?: {\n        eventData: boolean;\n        id: string;\n        type: string;\n        value?: any;\n    }[];\n}\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const gltfTypeToBabylonType: {\n    [key: string]: { length: number; flowGraphType: FlowGraphTypes; elementType: \"number\" | \"boolean\" };\n} = {\n    float: { length: 1, flowGraphType: FlowGraphTypes.Number, elementType: \"number\" },\n    bool: { length: 1, flowGraphType: FlowGraphTypes.Boolean, elementType: \"boolean\" },\n    float2: { length: 2, flowGraphType: FlowGraphTypes.Vector2, elementType: \"number\" },\n    float3: { length: 3, flowGraphType: FlowGraphTypes.Vector3, elementType: \"number\" },\n    float4: { length: 4, flowGraphType: FlowGraphTypes.Vector4, elementType: \"number\" },\n    float4x4: { length: 16, flowGraphType: FlowGraphTypes.Matrix, elementType: \"number\" },\n    float2x2: { length: 4, flowGraphType: FlowGraphTypes.Matrix2D, elementType: \"number\" },\n    float3x3: { length: 9, flowGraphType: FlowGraphTypes.Matrix3D, elementType: \"number\" },\n    int: { length: 1, flowGraphType: FlowGraphTypes.Integer, elementType: \"number\" },\n};\n\nexport class InteractivityGraphToFlowGraphParser {\n    /**\n     * Note - the graph should be rejected if the same type is defined twice.\n     * We currently don't validate that.\n     */\n    private _types: { length: number; flowGraphType: FlowGraphTypes; elementType: \"number\" | \"boolean\" }[] = [];\n    private _mappings: { flowGraphMapping: IGLTFToFlowGraphMapping; fullOperationName: string }[] = [];\n    private _staticVariables: { type: FlowGraphTypes; value: any[] }[] = [];\n    private _events: InteractivityEvent[] = [];\n    private _internalEventsCounter: number = 0;\n    private _nodes: { blocks: ISerializedFlowGraphBlock[]; fullOperationName: string }[] = [];\n\n    constructor(\n        private _interactivityGraph: IKHRInteractivity_Graph,\n        private _gltf: IGLTF,\n        public _animationTargetFps: number = 60\n    ) {\n        // start with types\n        this._parseTypes();\n        // continue with declarations\n        this._parseDeclarations();\n        this._parseVariables();\n        this._parseEvents();\n        this._parseNodes();\n    }\n\n    public get arrays() {\n        return {\n            types: this._types,\n            mappings: this._mappings,\n            staticVariables: this._staticVariables,\n            events: this._events,\n            nodes: this._nodes,\n        };\n    }\n\n    private _parseTypes() {\n        if (!this._interactivityGraph.types) {\n            return;\n        }\n        for (const type of this._interactivityGraph.types) {\n            this._types.push(gltfTypeToBabylonType[type.signature]);\n        }\n    }\n\n    private _parseDeclarations() {\n        if (!this._interactivityGraph.declarations) {\n            return;\n        }\n        for (const declaration of this._interactivityGraph.declarations) {\n            // make sure we have the mapping for this operation\n            const mapping = getMappingForDeclaration(declaration);\n            // mapping is defined, because we generate an empty mapping if it's not found\n            if (!mapping) {\n                Logger.Error([\"No mapping found for declaration\", declaration]);\n                throw new Error(\"Error parsing declarations\");\n            }\n            this._mappings.push({\n                flowGraphMapping: mapping,\n                fullOperationName: declaration.extension ? declaration.op + \":\" + declaration.extension : declaration.op,\n            });\n        }\n    }\n\n    private _parseVariables() {\n        if (!this._interactivityGraph.variables) {\n            return;\n        }\n        for (const variable of this._interactivityGraph.variables) {\n            const parsed = this._parseVariable(variable);\n            // set the default values here\n            this._staticVariables.push(parsed);\n        }\n    }\n\n    private _parseVariable(variable: IKHRInteractivity_Variable, dataTransform?: (value: any, parser: InteractivityGraphToFlowGraphParser) => any) {\n        const type = this._types[variable.type];\n        if (!type) {\n            Logger.Error([\"No type found for variable\", variable]);\n            throw new Error(\"Error parsing variables\");\n        }\n        if (variable.value) {\n            if (variable.value.length !== type.length) {\n                Logger.Error([\"Invalid value length for variable\", variable, type]);\n                throw new Error(\"Error parsing variables\");\n            }\n        }\n        const value = variable.value || [];\n        if (!value.length) {\n            switch (type.flowGraphType) {\n                case FlowGraphTypes.Boolean:\n                    value.push(false);\n                    break;\n                case FlowGraphTypes.Integer:\n                    value.push(0);\n                    break;\n                case FlowGraphTypes.Number:\n                    value.push(NaN);\n                    break;\n                case FlowGraphTypes.Vector2:\n                    value.push(NaN, NaN);\n                    break;\n                case FlowGraphTypes.Vector3:\n                    value.push(NaN, NaN, NaN);\n                    break;\n                case FlowGraphTypes.Vector4:\n                case FlowGraphTypes.Matrix2D:\n                case FlowGraphTypes.Quaternion:\n                    value.fill(NaN, 0, 4);\n                    break;\n                case FlowGraphTypes.Matrix:\n                    value.fill(NaN, 0, 16);\n                    break;\n                case FlowGraphTypes.Matrix3D:\n                    value.fill(NaN, 0, 9);\n                    break;\n                default:\n                    break;\n            }\n        }\n        // in case of NaN, Infinity, we need to parse the string to the object itself\n        if (type.elementType === \"number\" && typeof value[0] === \"string\") {\n            value[0] = parseFloat(value[0]);\n        }\n        return { type: type.flowGraphType, value: dataTransform ? dataTransform(value, this) : value };\n    }\n\n    private _parseEvents() {\n        if (!this._interactivityGraph.events) {\n            return;\n        }\n        for (const event of this._interactivityGraph.events) {\n            const converted: InteractivityEvent = {\n                eventId: event.id || \"internalEvent_\" + this._internalEventsCounter++,\n            };\n            if (event.values) {\n                converted.eventData = Object.keys(event.values).map((key) => {\n                    const eventValue = event.values?.[key];\n                    if (!eventValue) {\n                        Logger.Error([\"No value found for event key\", key]);\n                        throw new Error(\"Error parsing events\");\n                    }\n                    const type = this._types[eventValue.type];\n                    if (!type) {\n                        Logger.Error([\"No type found for event value\", eventValue]);\n                        throw new Error(\"Error parsing events\");\n                    }\n                    const value = typeof eventValue.value !== \"undefined\" ? this._parseVariable(eventValue) : undefined;\n                    return {\n                        id: key,\n                        type: type.flowGraphType,\n                        eventData: true,\n                        value,\n                    };\n                });\n            }\n            this._events.push(converted);\n        }\n    }\n\n    private _parseNodes() {\n        if (!this._interactivityGraph.nodes) {\n            return;\n        }\n        for (const node of this._interactivityGraph.nodes) {\n            // some validation\n            if (typeof node.declaration !== \"number\") {\n                Logger.Error([\"No declaration found for node\", node]);\n                throw new Error(\"Error parsing nodes\");\n            }\n            const mapping = this._mappings[node.declaration];\n            if (!mapping) {\n                Logger.Error([\"No mapping found for node\", node]);\n                throw new Error(\"Error parsing nodes\");\n            }\n            if (mapping.flowGraphMapping.validation) {\n                const validationResult = mapping.flowGraphMapping.validation(node, this._interactivityGraph, this._gltf);\n                if (!validationResult.valid) {\n                    throw new Error(`Error validating interactivity node ${this._interactivityGraph.declarations?.[node.declaration].op} - ${validationResult.error}`);\n                }\n            }\n            const blocks: ISerializedFlowGraphBlock[] = [];\n            // create block(s) for this node using the mapping\n            for (const blockType of mapping.flowGraphMapping.blocks) {\n                const block = this._getEmptyBlock(blockType, mapping.fullOperationName);\n                this._parseNodeConfiguration(node, block, mapping.flowGraphMapping, blockType);\n                blocks.push(block);\n            }\n            this._nodes.push({ blocks, fullOperationName: mapping.fullOperationName });\n        }\n    }\n\n    private _getEmptyBlock(className: string, type: string): ISerializedFlowGraphBlock {\n        const uniqueId = RandomGUID();\n        const dataInputs: ISerializedFlowGraphConnection[] = [];\n        const dataOutputs: ISerializedFlowGraphConnection[] = [];\n        const signalInputs: ISerializedFlowGraphConnection[] = [];\n        const signalOutputs: ISerializedFlowGraphConnection[] = [];\n        const config: IFlowGraphBlockConfiguration = {};\n        const metadata = {};\n        return {\n            uniqueId,\n            className,\n            dataInputs,\n            dataOutputs,\n            signalInputs,\n            signalOutputs,\n            config,\n            type,\n            metadata,\n        };\n    }\n\n    private _parseNodeConfiguration(node: IKHRInteractivity_Node, block: ISerializedFlowGraphBlock, nodeMapping: IGLTFToFlowGraphMapping, blockType: FlowGraphBlockNames | string) {\n        const configuration = block.config;\n        if (node.configuration) {\n            const keys = Object.keys(node.configuration);\n            for (const key of keys) {\n                const value = node.configuration?.[key];\n                // value is always an array, never a number or string\n                if (!value) {\n                    Logger.Error([\"No value found for node configuration\", key]);\n                    throw new Error(\"Error parsing node configuration\");\n                }\n                const configMapping = nodeMapping.configuration?.[key];\n                const belongsToBlock = configMapping && configMapping.toBlock ? configMapping.toBlock === blockType : nodeMapping.blocks.indexOf(blockType) === 0;\n                if (belongsToBlock) {\n                    // get the right name for the configuration key\n                    const configKey = configMapping?.name || key;\n                    if ((!value || typeof value.value === \"undefined\") && typeof configMapping?.defaultValue !== \"undefined\") {\n                        configuration[configKey] = {\n                            value: configMapping.defaultValue,\n                        };\n                    } else if (value.value.length >= 0) {\n                        // supporting int[] and int/boolean/string\n                        configuration[configKey] = {\n                            value: value.value.length === 1 ? value.value[0] : value.value,\n                        };\n                    } else {\n                        Logger.Warn([\"Invalid value for node configuration\", value]);\n                    }\n                    // make sure we transform the data if needed\n                    if (configMapping && configMapping.dataTransformer) {\n                        configuration[configKey].value = configMapping.dataTransformer([configuration[configKey].value], this)[0];\n                    }\n                }\n            }\n        }\n    }\n\n    private _parseNodeConnections(context: ISerializedFlowGraphContext) {\n        for (let i = 0; i < this._nodes.length; i++) {\n            // get the corresponding gltf node\n            const gltfNode = this._interactivityGraph.nodes?.[i];\n            if (!gltfNode) {\n                // should never happen but let's still check\n                Logger.Error([\"No node found for interactivity node\", this._nodes[i]]);\n                throw new Error(\"Error parsing node connections\");\n            }\n            const flowGraphBlocks = this._nodes[i];\n            const outputMapper = this._mappings[gltfNode.declaration];\n            // validate\n            if (!outputMapper) {\n                Logger.Error([\"No mapping found for node\", gltfNode]);\n                throw new Error(\"Error parsing node connections\");\n            }\n            const flowsFromGLTF = gltfNode.flows || {};\n            const flowsKeys = Object.keys(flowsFromGLTF).sort(); // sorting as some operations require sorted keys\n            // connect the flows\n            for (const flowKey of flowsKeys) {\n                const flow = flowsFromGLTF[flowKey];\n                const flowMapping = outputMapper.flowGraphMapping.outputs?.flows?.[flowKey];\n                const socketOutName = flowMapping?.name || flowKey;\n                // create a serialized socket\n                const socketOut = this._createNewSocketConnection(socketOutName, true);\n                const block = (flowMapping && flowMapping.toBlock && flowGraphBlocks.blocks.find((b) => b.className === flowMapping.toBlock)) || flowGraphBlocks.blocks[0];\n                block.signalOutputs.push(socketOut);\n                // get the input node of this block\n                const inputNodeId = flow.node;\n                const nodeIn = this._nodes[inputNodeId];\n                if (!nodeIn) {\n                    Logger.Error([\"No node found for input node id\", inputNodeId]);\n                    throw new Error(\"Error parsing node connections\");\n                }\n                // get the mapper for the input node - in case it mapped to multiple blocks\n                const inputMapper = getMappingForFullOperationName(nodeIn.fullOperationName);\n                if (!inputMapper) {\n                    Logger.Error([\"No mapping found for input node\", nodeIn]);\n                    throw new Error(\"Error parsing node connections\");\n                }\n                let flowInMapping = inputMapper.inputs?.flows?.[flow.socket || \"in\"];\n                let arrayMapping = false;\n                if (!flowInMapping) {\n                    for (const key in inputMapper.inputs?.flows) {\n                        if (key.startsWith(\"[\") && key.endsWith(\"]\")) {\n                            arrayMapping = true;\n                            flowInMapping = inputMapper.inputs?.flows?.[key];\n                        }\n                    }\n                }\n                const nodeInSocketName = flowInMapping ? (arrayMapping ? flowInMapping.name.replace(\"$1\", flow.socket || \"\") : flowInMapping.name) : flow.socket || \"in\";\n                const inputBlock = (flowInMapping && flowInMapping.toBlock && nodeIn.blocks.find((b) => b.className === flowInMapping.toBlock)) || nodeIn.blocks[0];\n                // in all of the flow graph input connections, find the one with the same name as the socket\n                let socketIn = inputBlock.signalInputs.find((s) => s.name === nodeInSocketName);\n                // if the socket doesn't exist, create the input socket for the connection\n                if (!socketIn) {\n                    socketIn = this._createNewSocketConnection(nodeInSocketName);\n                    inputBlock.signalInputs.push(socketIn);\n                }\n                // connect the sockets\n                socketIn.connectedPointIds.push(socketOut.uniqueId);\n                socketOut.connectedPointIds.push(socketIn.uniqueId);\n            }\n            // connect the values\n            const valuesFromGLTF = gltfNode.values || {};\n            const valuesKeys = Object.keys(valuesFromGLTF);\n            for (const valueKey of valuesKeys) {\n                const value = valuesFromGLTF[valueKey];\n                let valueMapping = outputMapper.flowGraphMapping.inputs?.values?.[valueKey];\n                let arrayMapping = false;\n                if (!valueMapping) {\n                    for (const key in outputMapper.flowGraphMapping.inputs?.values) {\n                        if (key.startsWith(\"[\") && key.endsWith(\"]\")) {\n                            arrayMapping = true;\n                            valueMapping = outputMapper.flowGraphMapping.inputs?.values?.[key];\n                        }\n                    }\n                }\n                const socketInName = valueMapping ? (arrayMapping ? valueMapping.name.replace(\"$1\", valueKey) : valueMapping.name) : valueKey;\n                // create a serialized socket\n                const socketIn = this._createNewSocketConnection(socketInName);\n                const block = (valueMapping && valueMapping.toBlock && flowGraphBlocks.blocks.find((b) => b.className === valueMapping.toBlock)) || flowGraphBlocks.blocks[0];\n                block.dataInputs.push(socketIn);\n                if ((value as IKHRInteractivity_Variable).value !== undefined) {\n                    const convertedValue = this._parseVariable(value as IKHRInteractivity_Variable, valueMapping && valueMapping.dataTransformer);\n                    context._connectionValues[socketIn.uniqueId] = convertedValue;\n                } else if (typeof (value as IKHRInteractivity_OutputSocketReference).node !== \"undefined\") {\n                    const nodeOutId = (value as IKHRInteractivity_OutputSocketReference).node;\n                    const nodeOutSocketName = (value as IKHRInteractivity_OutputSocketReference).socket || \"value\";\n                    const nodeOut = this._nodes[nodeOutId];\n                    if (!nodeOut) {\n                        Logger.Error([\"No node found for output socket reference\", value]);\n                        throw new Error(\"Error parsing node connections\");\n                    }\n                    const outputMapper = getMappingForFullOperationName(nodeOut.fullOperationName);\n                    if (!outputMapper) {\n                        Logger.Error([\"No mapping found for output socket reference\", value]);\n                        throw new Error(\"Error parsing node connections\");\n                    }\n                    let valueMapping = outputMapper.outputs?.values?.[nodeOutSocketName];\n                    let arrayMapping = false;\n                    // check if there is an array mapping defined\n                    if (!valueMapping) {\n                        // search for a value mapping that has an array mapping\n                        for (const key in outputMapper.outputs?.values) {\n                            if (key.startsWith(\"[\") && key.endsWith(\"]\")) {\n                                arrayMapping = true;\n                                valueMapping = outputMapper.outputs?.values?.[key];\n                            }\n                        }\n                    }\n                    const socketOutName = valueMapping ? (arrayMapping ? valueMapping.name.replace(\"$1\", nodeOutSocketName) : valueMapping?.name) : nodeOutSocketName;\n                    const outBlock = (valueMapping && valueMapping.toBlock && nodeOut.blocks.find((b) => b.className === valueMapping.toBlock)) || nodeOut.blocks[0];\n                    let socketOut = outBlock.dataOutputs.find((s) => s.name === socketOutName);\n                    // if the socket doesn't exist, create it\n                    if (!socketOut) {\n                        socketOut = this._createNewSocketConnection(socketOutName, true);\n                        outBlock.dataOutputs.push(socketOut);\n                    }\n                    // connect the sockets\n                    socketIn.connectedPointIds.push(socketOut.uniqueId);\n                    socketOut.connectedPointIds.push(socketIn.uniqueId);\n                } else {\n                    Logger.Error([\"Invalid value for value connection\", value]);\n                    throw new Error(\"Error parsing node connections\");\n                }\n            }\n\n            // inter block connections\n            if (outputMapper.flowGraphMapping.interBlockConnectors) {\n                for (const connector of outputMapper.flowGraphMapping.interBlockConnectors) {\n                    const input = connector.input;\n                    const output = connector.output;\n                    const isVariable = connector.isVariable;\n                    this._connectFlowGraphNodes(input, output, flowGraphBlocks.blocks[connector.inputBlockIndex], flowGraphBlocks.blocks[connector.outputBlockIndex], isVariable);\n                }\n            }\n\n            if (outputMapper.flowGraphMapping.extraProcessor) {\n                const declaration = this._interactivityGraph.declarations?.[gltfNode.declaration];\n                if (!declaration) {\n                    Logger.Error([\"No declaration found for extra processor\", gltfNode]);\n                    throw new Error(\"Error parsing node connections\");\n                }\n                flowGraphBlocks.blocks = outputMapper.flowGraphMapping.extraProcessor(\n                    gltfNode,\n                    declaration,\n                    outputMapper.flowGraphMapping,\n                    this,\n                    flowGraphBlocks.blocks,\n                    context,\n                    this._gltf\n                );\n            }\n        }\n    }\n\n    private _createNewSocketConnection(name: string, isOutput?: boolean): ISerializedFlowGraphConnection {\n        return {\n            uniqueId: RandomGUID(),\n            name,\n            _connectionType: isOutput ? FlowGraphConnectionType.Output : FlowGraphConnectionType.Input,\n            connectedPointIds: [],\n        };\n    }\n\n    private _connectFlowGraphNodes(input: string, output: string, serializedInput: ISerializedFlowGraphBlock, serializedOutput: ISerializedFlowGraphBlock, isVariable?: boolean) {\n        const inputArray = isVariable ? serializedInput.dataInputs : serializedInput.signalInputs;\n        const outputArray = isVariable ? serializedOutput.dataOutputs : serializedOutput.signalOutputs;\n        const inputConnection = inputArray.find((s) => s.name === input) || this._createNewSocketConnection(input);\n        const outputConnection = outputArray.find((s) => s.name === output) || this._createNewSocketConnection(output, true);\n        // of not found add it to the array\n        if (!inputArray.find((s) => s.name === input)) {\n            inputArray.push(inputConnection);\n        }\n        if (!outputArray.find((s) => s.name === output)) {\n            outputArray.push(outputConnection);\n        }\n        // connect the sockets\n        inputConnection.connectedPointIds.push(outputConnection.uniqueId);\n        outputConnection.connectedPointIds.push(inputConnection.uniqueId);\n    }\n\n    public getVariableName(index: number) {\n        return \"staticVariable_\" + index;\n    }\n\n    public serializeToFlowGraph(): ISerializedFlowGraph {\n        const context: ISerializedFlowGraphContext = {\n            uniqueId: RandomGUID(),\n            _userVariables: {},\n            _connectionValues: {},\n        };\n        this._parseNodeConnections(context);\n        for (let i = 0; i < this._staticVariables.length; i++) {\n            const variable = this._staticVariables[i];\n            context._userVariables[this.getVariableName(i)] = variable;\n        }\n\n        const allBlocks = this._nodes.reduce((acc, val) => acc.concat(val.blocks), [] as ISerializedFlowGraphBlock[]);\n\n        return {\n            rightHanded: true,\n            allBlocks,\n            executionContexts: [context],\n        };\n    }\n}\n","/* eslint-disable @typescript-eslint/naming-convention */\r\nimport type { IKHRInteractivity } from \"babylonjs-gltf2interface\";\r\nimport type { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { FlowGraphCoordinator } from \"core/FlowGraph/flowGraphCoordinator\";\r\nimport { ParseFlowGraphAsync } from \"core/FlowGraph/flowGraphParser\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\nimport type { GLTFPathToObjectConverter } from \"./gltfPathToObjectConverter\";\r\nimport { AddObjectAccessorToKey, GetPathToObjectConverter } from \"./objectModelMapping\";\r\nimport { InteractivityGraphToFlowGraphParser } from \"./KHR_interactivity/interactivityGraphParser\";\r\nimport { addToBlockFactory } from \"core/FlowGraph/Blocks/flowGraphBlockFactory\";\r\nimport { Quaternion, Vector3 } from \"core/Maths/math.vector\";\r\nimport type { Scene } from \"core/scene\";\r\nimport type { IAnimation } from \"../glTFLoaderInterfaces\";\r\n\r\nconst NAME = \"KHR_interactivity\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_interactivity extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_interactivity\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * Loader extension for KHR_interactivity\r\n */\r\nexport class KHR_interactivity implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    private _pathConverter?: GLTFPathToObjectConverter<any, any, any>;\r\n\r\n    /**\r\n     * @internal\r\n     * @param _loader\r\n     */\r\n    constructor(private _loader: GLTFLoader) {\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n        this._pathConverter = GetPathToObjectConverter(this._loader.gltf);\r\n        // avoid starting animations automatically.\r\n        _loader._skipStartAnimationStep = true;\r\n\r\n        // Update object model with new pointers\r\n\r\n        const scene = _loader.babylonScene;\r\n        if (scene) {\r\n            _AddInteractivityObjectModel(scene);\r\n        }\r\n    }\r\n\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n        delete this._pathConverter;\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax, @typescript-eslint/no-misused-promises\r\n    public async onReady(): Promise<void> {\r\n        if (!this._loader.babylonScene || !this._pathConverter) {\r\n            return;\r\n        }\r\n        const scene = this._loader.babylonScene;\r\n        const interactivityDefinition = this._loader.gltf.extensions?.KHR_interactivity as IKHRInteractivity;\r\n        if (!interactivityDefinition) {\r\n            // This can technically throw, but it's not a critical error\r\n            return;\r\n        }\r\n\r\n        const coordinator = new FlowGraphCoordinator({ scene });\r\n        coordinator.dispatchEventsSynchronously = false; // glTF interactivity dispatches events asynchronously\r\n        const graphs = interactivityDefinition.graphs.map((graph) => {\r\n            const parser = new InteractivityGraphToFlowGraphParser(graph, this._loader.gltf, this._loader.parent.targetFps);\r\n            return parser.serializeToFlowGraph();\r\n        });\r\n        // parse each graph async\r\n        await Promise.all(graphs.map(async (graph) => await ParseFlowGraphAsync(graph, { coordinator, pathConverter: this._pathConverter })));\r\n\r\n        coordinator.start();\r\n    }\r\n}\r\n\r\n/**\r\n * @internal\r\n * populates the object model with the interactivity extension\r\n */\r\nexport function _AddInteractivityObjectModel(scene: Scene) {\r\n    // Note - all of those are read-only, as per the specs!\r\n\r\n    // active camera rotation\r\n    AddObjectAccessorToKey(\"/extensions/KHR_interactivity/?/activeCamera/rotation\", {\r\n        get: () => {\r\n            if (!scene.activeCamera) {\r\n                return new Quaternion(NaN, NaN, NaN, NaN);\r\n            }\r\n            const quat = Quaternion.FromRotationMatrix(scene.activeCamera.getWorldMatrix()).normalize();\r\n            if (!scene.useRightHandedSystem) {\r\n                quat.w *= -1; // glTF uses right-handed system, while babylon uses left-handed\r\n                quat.x *= -1; // glTF uses right-handed system, while babylon uses left-handed\r\n            }\r\n            return quat;\r\n        },\r\n        type: \"Quaternion\",\r\n        getTarget: () => scene.activeCamera,\r\n    });\r\n    // activeCamera position\r\n    AddObjectAccessorToKey(\"/extensions/KHR_interactivity/?/activeCamera/position\", {\r\n        get: () => {\r\n            if (!scene.activeCamera) {\r\n                return new Vector3(NaN, NaN, NaN);\r\n            }\r\n            const pos = scene.activeCamera.getWorldMatrix().getTranslation(); // not global position\r\n            if (!scene.useRightHandedSystem) {\r\n                pos.x *= -1; // glTF uses right-handed system, while babylon uses left-handed\r\n            }\r\n            return pos;\r\n        },\r\n        type: \"Vector3\",\r\n        getTarget: () => scene.activeCamera,\r\n    });\r\n\r\n    // /animations/{} pointers:\r\n    AddObjectAccessorToKey(\"/animations/{}/extensions/KHR_interactivity/isPlaying\", {\r\n        get: (animation: IAnimation) => {\r\n            return animation._babylonAnimationGroup?.isPlaying ?? false;\r\n        },\r\n        type: \"boolean\",\r\n        getTarget: (animation: IAnimation) => {\r\n            return animation._babylonAnimationGroup;\r\n        },\r\n    });\r\n    AddObjectAccessorToKey(\"/animations/{}/extensions/KHR_interactivity/minTime\", {\r\n        get: (animation: IAnimation) => {\r\n            return (animation._babylonAnimationGroup?.from ?? 0) / 60; // fixed factor for duration-to-frames conversion\r\n        },\r\n        type: \"number\",\r\n        getTarget: (animation: IAnimation) => {\r\n            return animation._babylonAnimationGroup;\r\n        },\r\n    });\r\n    AddObjectAccessorToKey(\"/animations/{}/extensions/KHR_interactivity/maxTime\", {\r\n        get: (animation: IAnimation) => {\r\n            return (animation._babylonAnimationGroup?.to ?? 0) / 60; // fixed factor for duration-to-frames conversion\r\n        },\r\n        type: \"number\",\r\n        getTarget: (animation: IAnimation) => {\r\n            return animation._babylonAnimationGroup;\r\n        },\r\n    });\r\n    // playhead\r\n    AddObjectAccessorToKey(\"/animations/{}/extensions/KHR_interactivity/playhead\", {\r\n        get: (animation: IAnimation) => {\r\n            return (animation._babylonAnimationGroup?.getCurrentFrame() ?? 0) / 60; // fixed factor for duration-to-frames conversion\r\n        },\r\n        type: \"number\",\r\n        getTarget: (animation: IAnimation) => {\r\n            return animation._babylonAnimationGroup;\r\n        },\r\n    });\r\n    //virtualPlayhead - TODO, do we support this property in our animations? getCurrentFrame  is the only method we have for this.\r\n    AddObjectAccessorToKey(\"/animations/{}/extensions/KHR_interactivity/virtualPlayhead\", {\r\n        get: (animation: IAnimation) => {\r\n            return (animation._babylonAnimationGroup?.getCurrentFrame() ?? 0) / 60; // fixed factor for duration-to-frames conversion\r\n        },\r\n        type: \"number\",\r\n        getTarget: (animation: IAnimation) => {\r\n            return animation._babylonAnimationGroup;\r\n        },\r\n    });\r\n}\r\n\r\n// Register flow graph blocks. Do it here so they are available when the extension is enabled.\r\naddToBlockFactory(NAME, \"FlowGraphGLTFDataProvider\", async () => {\r\n    return (await import(\"./KHR_interactivity/flowGraphGLTFDataProvider\")).FlowGraphGLTFDataProvider;\r\n});\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_interactivity(loader));\r\n","import type { AbstractMesh } from \"core/Meshes/abstractMesh\";\nimport type { GLTFLoader } from \"../glTFLoader\";\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\nimport type { INode } from \"../glTFLoaderInterfaces\";\nimport { AddObjectAccessorToKey } from \"./objectModelMapping\";\n\nconst NAME = \"KHR_node_visibility\";\n\ndeclare module \"../../glTFFileLoader\" {\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\n    export interface GLTFLoaderExtensionOptions {\n        /**\n         * Defines options for the KHR_node_visibility extension.\n         */\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\n        [\"KHR_node_visibility\"]: {};\n    }\n}\n\n// object model extension for visibility\nAddObjectAccessorToKey(\"/nodes/{}/extensions/KHR_node_visibility/visible\", {\n    get: (node: INode) => {\n        const tn = node._babylonTransformNode as any;\n        if (tn && tn.isVisible !== undefined) {\n            return tn.isVisible;\n        }\n        return true;\n    },\n    set: (value: boolean, node: INode) => {\n        node._primitiveBabylonMeshes?.forEach((mesh) => {\n            mesh.inheritVisibility = true;\n        });\n        if (node._babylonTransformNode) {\n            (node._babylonTransformNode as AbstractMesh).isVisible = value;\n        }\n        node._primitiveBabylonMeshes?.forEach((mesh) => {\n            mesh.isVisible = value;\n        });\n    },\n    getTarget: (node: INode) => node._babylonTransformNode,\n    getPropertyName: [() => \"isVisible\"],\n    type: \"boolean\",\n});\n\n/**\n * Loader extension for KHR_node_visibility\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport class KHR_node_visibility implements IGLTFLoaderExtension {\n    /**\n     * The name of this extension.\n     */\n    public readonly name = NAME;\n    /**\n     * Defines whether this extension is enabled.\n     */\n    public enabled: boolean;\n\n    private _loader: GLTFLoader;\n\n    /**\n     * @internal\n     */\n    constructor(loader: GLTFLoader) {\n        this._loader = loader;\n        this.enabled = loader.isExtensionUsed(NAME);\n    }\n\n    // eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-misused-promises\n    public async onReady(): Promise<void> {\n        this._loader.gltf.nodes?.forEach((node) => {\n            node._primitiveBabylonMeshes?.forEach((mesh) => {\n                mesh.inheritVisibility = true;\n            });\n            // When the JSON Pointer is used we need to change both the transform node and the primitive meshes to the new value.\n            if (node.extensions?.KHR_node_visibility) {\n                if (node.extensions?.KHR_node_visibility.visible === false) {\n                    if (node._babylonTransformNode) {\n                        (node._babylonTransformNode as AbstractMesh).isVisible = false;\n                    }\n                    node._primitiveBabylonMeshes?.forEach((mesh) => {\n                        mesh.isVisible = false;\n                    });\n                }\n            }\n        });\n    }\n\n    public dispose() {\n        (this._loader as any) = null;\n    }\n}\n\nunregisterGLTFExtension(NAME);\nregisterGLTFExtension(NAME, true, (loader) => new KHR_node_visibility(loader));\n","import { FlowGraphBlockNames } from \"core/FlowGraph/Blocks/flowGraphBlockNames\";\nimport type { GLTFLoader } from \"../glTFLoader\";\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\nimport { addNewInteractivityFlowGraphMapping } from \"./KHR_interactivity/declarationMapper\";\nimport type { INode } from \"../glTFLoaderInterfaces\";\nimport { AddObjectAccessorToKey } from \"./objectModelMapping\";\n\nconst NAME = \"KHR_node_selectability\";\n\ndeclare module \"../../glTFFileLoader\" {\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\n    export interface GLTFLoaderExtensionOptions {\n        /**\n         * Defines options for the KHR_selectability extension.\n         */\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\n        [\"KHR_node_selectability\"]: {};\n    }\n}\n\n// add the interactivity mapping for the onSelect event\naddNewInteractivityFlowGraphMapping(\"event/onSelect\", NAME, {\n    // using GetVariable as the nodeIndex is a configuration and not a value (i.e. it's not mutable)\n    blocks: [FlowGraphBlockNames.MeshPickEvent, FlowGraphBlockNames.GetVariable, FlowGraphBlockNames.IndexOf, \"KHR_interactivity/FlowGraphGLTFDataProvider\"],\n    configuration: {\n        stopPropagation: { name: \"stopPropagation\" },\n        nodeIndex: {\n            name: \"variable\",\n            toBlock: FlowGraphBlockNames.GetVariable,\n            dataTransformer(data) {\n                return [\"pickedMesh_\" + data[0]];\n            },\n        },\n    },\n    outputs: {\n        values: {\n            selectedNodeIndex: { name: \"index\", toBlock: FlowGraphBlockNames.IndexOf },\n            controllerIndex: { name: \"pointerId\" },\n            selectionPoint: { name: \"pickedPoint\" },\n            selectionRayOrigin: { name: \"pickOrigin\" },\n        },\n        flows: {\n            out: { name: \"done\" },\n        },\n    },\n    interBlockConnectors: [\n        {\n            input: \"asset\",\n            output: \"value\",\n            inputBlockIndex: 0,\n            outputBlockIndex: 1,\n            isVariable: true,\n        },\n        {\n            input: \"array\",\n            output: \"nodes\",\n            inputBlockIndex: 2,\n            outputBlockIndex: 3,\n            isVariable: true,\n        },\n        {\n            input: \"object\",\n            output: \"pickedMesh\",\n            inputBlockIndex: 2,\n            outputBlockIndex: 0,\n            isVariable: true,\n        },\n    ],\n    extraProcessor(gltfBlock, _declaration, _mapping, _arrays, serializedObjects, context, globalGLTF) {\n        // add the glTF to the configuration of the last serialized object\n        const serializedObject = serializedObjects[serializedObjects.length - 1];\n        serializedObject.config = serializedObject.config || {};\n        serializedObject.config.glTF = globalGLTF;\n        // find the listener nodeIndex value\n        const nodeIndex = gltfBlock.configuration?.[\"nodeIndex\"]?.value[0];\n        if (nodeIndex === undefined || typeof nodeIndex !== \"number\") {\n            throw new Error(\"nodeIndex not found in configuration\");\n        }\n        const variableName = \"pickedMesh_\" + nodeIndex;\n        // find the nodeIndex value\n        serializedObjects[1].config.variable = variableName;\n        context._userVariables[variableName] = {\n            className: \"Mesh\",\n            id: globalGLTF?.nodes?.[nodeIndex]._babylonTransformNode?.id,\n            uniqueId: globalGLTF?.nodes?.[nodeIndex]._babylonTransformNode?.uniqueId,\n        };\n        return serializedObjects;\n    },\n});\n\n// object model extension for selectable\nAddObjectAccessorToKey(\"/nodes/{}/extensions/KHR_node_selectability/selectable\", {\n    get: (node: INode) => {\n        const tn = node._babylonTransformNode as any;\n        if (tn && tn.isPickable !== undefined) {\n            return tn.isPickable;\n        }\n        return true;\n    },\n    set: (value: boolean, node: INode) => {\n        node._primitiveBabylonMeshes?.forEach((mesh) => {\n            mesh.isPickable = value;\n        });\n    },\n    getTarget: (node: INode) => node._babylonTransformNode,\n    getPropertyName: [() => \"isPickable\"],\n    type: \"boolean\",\n});\n\n/**\n * Loader extension for KHR_selectability\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport class KHR_node_selectability implements IGLTFLoaderExtension {\n    /**\n     * The name of this extension.\n     */\n    public readonly name = NAME;\n    /**\n     * Defines whether this extension is enabled.\n     */\n    public enabled: boolean;\n\n    private _loader: GLTFLoader;\n\n    /**\n     * @internal\n     */\n    constructor(loader: GLTFLoader) {\n        this._loader = loader;\n        this.enabled = loader.isExtensionUsed(NAME);\n    }\n\n    // eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-misused-promises\n    public async onReady(): Promise<void> {\n        this._loader.gltf.nodes?.forEach((node) => {\n            if (node.extensions?.KHR_node_selectability && node.extensions?.KHR_node_selectability.selectable === false) {\n                node._babylonTransformNode?.getChildMeshes().forEach((mesh) => {\n                    mesh.isPickable = false;\n                });\n            }\n        });\n    }\n\n    public dispose() {\n        (this._loader as any) = null;\n    }\n}\n\nunregisterGLTFExtension(NAME);\nregisterGLTFExtension(NAME, true, (loader) => new KHR_node_selectability(loader));\n","import { FlowGraphBlockNames } from \"core/FlowGraph/Blocks/flowGraphBlockNames\";\nimport type { GLTFLoader } from \"../glTFLoader\";\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\nimport { addNewInteractivityFlowGraphMapping } from \"./KHR_interactivity/declarationMapper\";\nimport type { INode } from \"../glTFLoaderInterfaces\";\nimport { AddObjectAccessorToKey } from \"./objectModelMapping\";\n\nconst NAME = \"KHR_node_hoverability\";\n\ndeclare module \"../../glTFFileLoader\" {\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\n    export interface GLTFLoaderExtensionOptions {\n        /**\n         * Defines options for the KHR_node_hoverability extension.\n         */\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\n        [\"KHR_node_hoverability\"]: {};\n    }\n}\n\n// interactivity\nconst MeshPointerOverPrefix = \"targetMeshPointerOver_\";\naddNewInteractivityFlowGraphMapping(\"event/onHoverIn\", NAME, {\n    // using GetVariable as the nodeIndex is a configuration and not a value (i.e. it's not mutable)\n    blocks: [FlowGraphBlockNames.PointerOverEvent, FlowGraphBlockNames.GetVariable, FlowGraphBlockNames.IndexOf, \"KHR_interactivity/FlowGraphGLTFDataProvider\"],\n    configuration: {\n        stopPropagation: { name: \"stopPropagation\" },\n        nodeIndex: {\n            name: \"variable\",\n            toBlock: FlowGraphBlockNames.GetVariable,\n            dataTransformer(data) {\n                return [MeshPointerOverPrefix + data[0]];\n            },\n        },\n    },\n    outputs: {\n        values: {\n            hoverNodeIndex: { name: \"index\", toBlock: FlowGraphBlockNames.IndexOf },\n            controllerIndex: { name: \"pointerId\" },\n        },\n        flows: {\n            out: { name: \"done\" },\n        },\n    },\n    interBlockConnectors: [\n        {\n            input: \"targetMesh\",\n            output: \"value\",\n            inputBlockIndex: 0,\n            outputBlockIndex: 1,\n            isVariable: true,\n        },\n        {\n            input: \"array\",\n            output: \"nodes\",\n            inputBlockIndex: 2,\n            outputBlockIndex: 3,\n            isVariable: true,\n        },\n        {\n            input: \"object\",\n            output: \"meshUnderPointer\",\n            inputBlockIndex: 2,\n            outputBlockIndex: 0,\n            isVariable: true,\n        },\n    ],\n    extraProcessor(gltfBlock, _declaration, _mapping, _arrays, serializedObjects, context, globalGLTF) {\n        // add the glTF to the configuration of the last serialized object\n        const serializedObject = serializedObjects[serializedObjects.length - 1];\n        serializedObject.config = serializedObject.config || {};\n        serializedObject.config.glTF = globalGLTF;\n        // find the listener nodeIndex value\n        const nodeIndex = gltfBlock.configuration?.[\"nodeIndex\"]?.value[0];\n        if (nodeIndex === undefined || typeof nodeIndex !== \"number\") {\n            throw new Error(\"nodeIndex not found in configuration\");\n        }\n        const variableName = MeshPointerOverPrefix + nodeIndex;\n        // find the nodeIndex value\n        serializedObjects[1].config.variable = variableName;\n        context._userVariables[variableName] = {\n            className: \"Mesh\",\n            id: globalGLTF?.nodes?.[nodeIndex]._babylonTransformNode?.id,\n            uniqueId: globalGLTF?.nodes?.[nodeIndex]._babylonTransformNode?.uniqueId,\n        };\n        return serializedObjects;\n    },\n});\n\nconst MeshPointerOutPrefix = \"targetMeshPointerOut_\";\naddNewInteractivityFlowGraphMapping(\"event/onHoverOut\", NAME, {\n    // using GetVariable as the nodeIndex is a configuration and not a value (i.e. it's not mutable)\n    blocks: [FlowGraphBlockNames.PointerOutEvent, FlowGraphBlockNames.GetVariable, FlowGraphBlockNames.IndexOf, \"KHR_interactivity/FlowGraphGLTFDataProvider\"],\n    configuration: {\n        stopPropagation: { name: \"stopPropagation\" },\n        nodeIndex: {\n            name: \"variable\",\n            toBlock: FlowGraphBlockNames.GetVariable,\n            dataTransformer(data) {\n                return [MeshPointerOutPrefix + data[0]];\n            },\n        },\n    },\n    outputs: {\n        values: {\n            hoverNodeIndex: { name: \"index\", toBlock: FlowGraphBlockNames.IndexOf },\n            controllerIndex: { name: \"pointerId\" },\n        },\n        flows: {\n            out: { name: \"done\" },\n        },\n    },\n    interBlockConnectors: [\n        {\n            input: \"targetMesh\",\n            output: \"value\",\n            inputBlockIndex: 0,\n            outputBlockIndex: 1,\n            isVariable: true,\n        },\n        {\n            input: \"array\",\n            output: \"nodes\",\n            inputBlockIndex: 2,\n            outputBlockIndex: 3,\n            isVariable: true,\n        },\n        {\n            input: \"object\",\n            output: \"meshOutOfPointer\",\n            inputBlockIndex: 2,\n            outputBlockIndex: 0,\n            isVariable: true,\n        },\n    ],\n    extraProcessor(gltfBlock, _declaration, _mapping, _arrays, serializedObjects, context, globalGLTF) {\n        // add the glTF to the configuration of the last serialized object\n        const serializedObject = serializedObjects[serializedObjects.length - 1];\n        serializedObject.config = serializedObject.config || {};\n        serializedObject.config.glTF = globalGLTF;\n\n        const nodeIndex = gltfBlock.configuration?.[\"nodeIndex\"]?.value[0];\n        if (nodeIndex === undefined || typeof nodeIndex !== \"number\") {\n            throw new Error(\"nodeIndex not found in configuration\");\n        }\n        const variableName = MeshPointerOutPrefix + nodeIndex;\n        // find the nodeIndex value\n        serializedObjects[1].config.variable = variableName;\n        context._userVariables[variableName] = {\n            className: \"Mesh\",\n            id: globalGLTF?.nodes?.[nodeIndex]._babylonTransformNode?.id,\n            uniqueId: globalGLTF?.nodes?.[nodeIndex]._babylonTransformNode?.uniqueId,\n        };\n        return serializedObjects;\n    },\n});\n\nAddObjectAccessorToKey(\"/nodes/{}/extensions/KHR_node_hoverability/hoverable\", {\n    get: (node: INode) => {\n        const tn = node._babylonTransformNode as any;\n        if (tn && tn.pointerOverDisableMeshTesting !== undefined) {\n            return tn.pointerOverDisableMeshTesting;\n        }\n        return true;\n    },\n    set: (value: boolean, node: INode) => {\n        node._primitiveBabylonMeshes?.forEach((mesh) => {\n            mesh.pointerOverDisableMeshTesting = !value;\n        });\n    },\n    getTarget: (node: INode) => node._babylonTransformNode,\n    getPropertyName: [() => \"pointerOverDisableMeshTesting\"],\n    type: \"boolean\",\n});\n\n/**\n * Loader extension for KHR_node_hoverability\n * @see https://github.com/KhronosGroup/glTF/pull/2426\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport class KHR_node_hoverability implements IGLTFLoaderExtension {\n    /**\n     * The name of this extension.\n     */\n    public readonly name = NAME;\n    /**\n     * Defines whether this extension is enabled.\n     */\n    public enabled: boolean;\n\n    private _loader: GLTFLoader;\n\n    /**\n     * @internal\n     */\n    constructor(loader: GLTFLoader) {\n        this._loader = loader;\n        this.enabled = loader.isExtensionUsed(NAME);\n    }\n\n    // eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-misused-promises\n    public async onReady(): Promise<void> {\n        this._loader.gltf.nodes?.forEach((node) => {\n            // default is true, so only apply if false\n            if (node.extensions?.KHR_node_hoverability && node.extensions?.KHR_node_hoverability.hoverable === false) {\n                node._babylonTransformNode?.getChildMeshes().forEach((mesh) => {\n                    mesh.pointerOverDisableMeshTesting = true;\n                });\n            }\n        });\n    }\n\n    public dispose() {\n        (this._loader as any) = null;\n    }\n}\n\nunregisterGLTFExtension(NAME);\nregisterGLTFExtension(NAME, true, (loader) => new KHR_node_hoverability(loader));\n","import type { Nullable } from \"core/types\";\r\nimport type { TransformNode } from \"core/Meshes/transformNode\";\r\nimport type { Camera } from \"core/Cameras/camera\";\r\n\r\nimport type { IProperty } from \"babylonjs-gltf2interface\";\r\nimport type { INode, ICamera, IMaterial } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport type { GLTFLoader } from \"../glTFLoader\";\r\nimport type { Material } from \"core/Materials/material\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"ExtrasAsMetadata\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the ExtrasAsMetadata extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"ExtrasAsMetadata\"]: {};\r\n    }\r\n}\r\n\r\ninterface IObjectWithMetadata {\r\n    metadata: any;\r\n}\r\n\r\n/**\r\n * Store glTF extras (if present) in BJS objects' metadata\r\n */\r\nexport class ExtrasAsMetadata implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled = true;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    private _assignExtras(babylonObject: IObjectWithMetadata, gltfProp: IProperty): void {\r\n        if (gltfProp.extras && Object.keys(gltfProp.extras).length > 0) {\r\n            const metadata = (babylonObject.metadata = babylonObject.metadata || {});\r\n            const gltf = (metadata.gltf = metadata.gltf || {});\r\n            gltf.extras = gltfProp.extras;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose(): void {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadNodeAsync(context: string, node: INode, assign: (babylonTransformNode: TransformNode) => void): Nullable<Promise<TransformNode>> {\r\n        return this._loader.loadNodeAsync(context, node, (babylonTransformNode): void => {\r\n            this._assignExtras(babylonTransformNode, node);\r\n            assign(babylonTransformNode);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadCameraAsync(context: string, camera: ICamera, assign: (babylonCamera: Camera) => void): Nullable<Promise<Camera>> {\r\n        return this._loader.loadCameraAsync(context, camera, (babylonCamera): void => {\r\n            this._assignExtras(babylonCamera, camera);\r\n            assign(babylonCamera);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public createMaterial(context: string, material: IMaterial, babylonDrawMode: number): Nullable<Material> {\r\n        const babylonMaterial = this._loader.createMaterial(context, material, babylonDrawMode);\r\n        this._assignExtras(babylonMaterial, material);\r\n        return babylonMaterial;\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, false, (loader) => new ExtrasAsMetadata(loader));\r\n","/* eslint-disable @typescript-eslint/no-restricted-imports */\r\nimport * as Extensions from \"loaders/glTF/2.0/Extensions/index\";\r\nimport * as Interfaces from \"loaders/glTF/2.0/glTFLoaderInterfaces\";\r\nimport * as GLTF2 from \"loaders/glTF/2.0/index\";\r\n\r\n/**\r\n * This is the entry point for the UMD module.\r\n * The entry point for a future ESM package should be index.ts\r\n */\r\nconst GlobalObject = typeof global !== \"undefined\" ? global : typeof window !== \"undefined\" ? window : undefined;\r\nif (typeof GlobalObject !== \"undefined\") {\r\n    (<any>GlobalObject).BABYLON = (<any>GlobalObject).BABYLON || {};\r\n    // eslint-disable-next-line @typescript-eslint/naming-convention\r\n    const BABYLON = (<any>GlobalObject).BABYLON;\r\n    BABYLON.GLTF2 = BABYLON.GLTF2 || {};\r\n    BABYLON.GLTF2.Loader = BABYLON.GLTF2.Loader || {};\r\n    BABYLON.GLTF2.Loader.Extensions = BABYLON.GLTF2.Loader.Extensions || {};\r\n\r\n    const keys = [];\r\n    for (const key in Extensions) {\r\n        BABYLON.GLTF2.Loader.Extensions[key] = (<any>Extensions)[key];\r\n        keys.push(key);\r\n    }\r\n    for (const key in Interfaces) {\r\n        BABYLON.GLTF2.Loader[key] = (<any>Interfaces)[key];\r\n        keys.push(key);\r\n    }\r\n\r\n    for (const key in GLTF2) {\r\n        // Prevent Reassignment.\r\n        if (keys.indexOf(key) > -1) {\r\n            continue;\r\n        }\r\n\r\n        BABYLON.GLTF2[key] = (<any>GLTF2)[key];\r\n    }\r\n}\r\n\r\nexport { GLTF2 };\r\n","import * as loaders from \"@lts/loaders/legacy/legacy-glTF2FileLoader\";\r\nexport { loaders };\r\nexport default loaders;\r\n"],"names":["root","factory","exports","module","require","define","amd","self","global","this","__WEBPACK_EXTERNAL_MODULE__597__","leafPrototypes","getProto","config","glTF","animationGroups","animations","map","a","_babylonAnimationGroup","registerDataOutput","RichTypeAny","nodes","n","_babylonTransformNode","getClassName","FlowGraphBlock","extendStatics","d","b","Object","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","call","__extends","TypeError","String","__","constructor","create","__assign","assign","t","s","i","arguments","length","apply","__awaiter","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","value","step","next","e","rejected","result","done","then","__generator","body","f","y","_","label","sent","trys","ops","g","Iterator","verb","Symbol","iterator","v","op","pop","push","SuppressedError","OptionalPathExceptionsList","regex","RegExp","_gltf","_infoTree","convert","path","objectTree","infoTree","target","undefined","startsWith","Error","parts","split","shift","includes","ignoreObjectTree","part","isLength","__array__","__ignoreObjectTree__","find","test","__target__","object","info","GetTexture","material","payload","textureType","textureInObject","babylonMaterial","GetMaterial","_index","_data","fillMode","Constants","MATERIAL_TriangleFillMode","GenerateTextureMap","offset","componentsCount","type","get","texture","Vector2","uOffset","vOffset","getTarget","set","x","getPropertyName","rotation","wAng","scale","uScale","vScale","index","objectModelMapping","cameras","orthographic","xmag","camera","_babylonCamera","orthoLeft","orthoRight","ymag","orthoBottom","orthoTop","zfar","maxZ","znear","minZ","perspective","aspectRatio","getEngine","getAspectRatio","isReadOnly","yfov","fov","node","translation","position","copyFrom","rotationQuaternion","scaling","weights","_numMorphTargets","_primitiveBabylonMeshes","morphTargetManager","influence","matrix","Matrix","Compose","globalMatrix","Identity","rootNode","parent","forceUpdate","_isDirty","rootMatrix","computeWorldMatrix","invert","multiplyToRef","extensions","EXT_lights_ies","multiplier","getChildren","child","SpotLight","intensity","light","color","diffuse","materials","emissiveFactor","emissiveColor","emissiveTexture","KHR_texture_transform","normalTexture","level","occlusionTexture","strength","ambientTextureStrength","mat","pbrMetallicRoughness","baseColorFactor","Color4","FromColor3","albedoColor","alpha","r","baseColorTexture","metallicFactor","metallic","roughnessFactor","roughness","metallicRoughnessTexture","KHR_materials_anisotropy","anisotropyStrength","anisotropy","anisotropyRotation","angle","anisotropyTexture","KHR_materials_clearcoat","clearcoatFactor","clearCoat","clearcoatRoughnessFactor","clearcoatTexture","clearcoatNormalTexture","bumpTexture","clearcoatRoughnessTexture","KHR_materials_dispersion","dispersion","subSurface","KHR_materials_emissive_strength","emissiveStrength","emissiveIntensity","KHR_materials_ior","ior","indexOfRefraction","KHR_materials_iridescence","iridescenceFactor","iridescence","iridescenceIor","iridescenceTexture","iridescenceThicknessMaximum","maximumThickness","iridescenceThicknessMinimum","minimumThickness","iridescenceThicknessTexture","KHR_materials_sheen","sheenColorFactor","sheen","sheenColorTexture","sheenRoughnessFactor","sheenRoughnessTexture","KHR_materials_specular","specularFactor","metallicF0Factor","specularColorFactor","metallicReflectanceColor","specularTexture","specularColorTexture","KHR_materials_transmission","transmissionFactor","refractionIntensity","transmissionTexture","KHR_materials_diffuse_transmission","diffuseTransmissionFactor","translucencyIntensity","diffuseTransmissionTexture","diffuseTransmissionColorFactor","translucencyColor","diffuseTransmissionColorTexture","KHR_materials_volume","attenuationColor","tintColor","attenuationDistance","tintColorAtDistance","thicknessFactor","thicknessTexture","KHR_lights_punctual","lights","_babylonLight","_lights","_light","range","spot","innerConeAngle","innerAngle","outerConeAngle","EXT_lights_image_based","_babylonTexture","Quaternion","FromRotationMatrix","getReflectionTextureMatrix","getScene","useRightHandedSystem","Inverse","FromQuaternionToRef","animation","meshes","mesh","primitives","_instanceData","babylonSourceMesh","GetPathToObjectConverter","gltf","GLTFPathToObjectConverter","GetMappingForKey","key","keyParts","replace","current","SetInterpolationForKey","interpolation","AddObjectAccessorToKey","accessor","getVector3","_target","source","Vector3","FromArray","scaleInPlace","getQuaternion","getWeights","name","getValue","getStride","_buildAnimation","fps","keys","babylonAnimation","Animation","setKeys","buildAnimations","babylonAnimations","babylonAnimatable","AnimationPropertyInfo","targetIndex","frame","inTangent","outTangent","babylonMesh","morphTarget","babylonAnimationClone","clone","TransformNodeAnimationPropertyInfo","ANIMATIONTYPE_VECTOR3","ANIMATIONTYPE_QUATERNION","WeightAnimationPropertyInfo","ANIMATIONTYPE_FLOAT","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","getter","__esModule","getPrototypeOf","obj","mode","ns","def","indexOf","getOwnPropertyNames","forEach","definition","o","defineProperty","enumerable","globalThis","Function","window","prop","toStringTag","ValidateAsync","data","rootUrl","fileName","getExternalResource","options","externalResourceFunction","uri","ArrayBuffer","isView","GLTFValidator","validateBytes","validateString","WorkerFunc","pendingExternalResources","onmessage","message","id","importScripts","url","postMessage","reason","GLTFLoaderCoordinateSystemMode","GLTFLoaderAnimationStartMode","GLTFLoaderState","Worker","workerContent","workerBlobUrl","URL","createObjectURL","Blob","worker","onError","error","removeEventListener","onMessage","buffer","terminate","addEventListener","Tools","GetBabylonScriptURL","Configuration","slicedData","slice","_LoadScriptPromise","LoadBabylonScriptAsync","_DefaultCdnUrl","GLTFMagicBase64Encoded","GLTFFileLoaderMetadata","isBinary","mimeType","readAsync","arrayBuffer","byteOffset","byteLength","Uint8Array","onParsedObservable","Observable","onMeshLoadedObservable","onSkinLoadedObservable","onTextureLoadedObservable","onMaterialLoadedObservable","onCameraLoadedObservable","onCompleteObservable","onErrorObservable","onDisposeObservable","onExtensionLoadedObservable","onValidatedObservable","_loader","_state","_requests","onLoaderStateChangedObservable","_logIndentLevel","_loggingEnabled","_log","_logDisabled","_capturePerformanceCounters","_startPerformanceCounter","_startPerformanceCounterDisabled","_endPerformanceCounter","_endPerformanceCounterDisabled","callback","_onParsedObserver","remove","add","_onMeshLoadedObserver","_onSkinLoadedObserver","skinnedNode","_onTextureLoadedObserver","_onMaterialLoadedObserver","_onCameraLoadedObserver","_onCompleteObserver","_onErrorObserver","_onDisposeObserver","_onExtensionLoadedObserver","_logEnabled","_startPerformanceCounterEnabled","_endPerformanceCounterEnabled","_onValidatedObserver","dispose","abort","_progressCallback","preprocessUrlAsync","clear","notifyObservers","loadFile","scene","fileOrUrl","onSuccess","onProgress","useArrayBuffer","_loadBinary","GetFilename","useRangeRequests","validate","Logger","Warn","dataBuffer","_loadFile","webRequest","setRequestHeader","_unpackBinaryAsync","DataReader","loaderData","_validate","json","_parseJson","arrayBufferView","RangeError","readViewAsync","importMeshAsync","meshesNames","_getLoader","loadAsync","loadAssetContainerAsync","container","AssetContainer","textures","morphTargetManagers","geometries","particleSystems","skeletons","transformNodes","canDirectLoad","directLoad","DecodeBase64UrlToBinary","createPlugin","GLTFFileLoader","whenCompleteAsync","addOnce","_setState","state","onOpened","request","event","_onProgress","_lengthComputable","_total","_loaded","lengthComputable","loaded","total","GLTFValidation","_loadFileAsync","asset","version","minVersion","_parseVersion","_compareVersion","major","minor","createLoader","_CreateGLTF1Loader","_CreateGLTF2Loader","parsed","JSON","parse","dataReader","magic","readUint32","RuntimeError","ErrorCodes","GLTFLoaderUnexpectedMagicError","loggingEnabled","unpacked","_unpackBinaryV1Async","_unpackBinaryV2Async","contentLength","contentFormat","bodyLength","readString","bin","ChunkFormat","chunkLength","skipBytes","match","parseInt","_logOpen","_logClose","spaces","_logSpaces","substring","Log","counterName","StartPerformanceCounter","EndPerformanceCounter","IncrementalLoading","HomogeneousCoordinates","alwaysComputeBoundingBox","alwaysComputeSkeletonRootNode","animationStartMode","FIRST","compileMaterials","compileShadowGenerators","coordinateSystemMode","AUTO","createInstances","extensionOptions","loadAllMaterials","loadMorphTargets","loadNodeAnimations","loadOnlyMaterials","loadSkins","skipMaterials","targetFps","transparencyAsCoverage","useClipPlane","useGltfTextureNames","useSRGBBuffers","capturePerformanceCounters","customRootNode","onCameraLoaded","onMaterialLoaded","onMeshLoaded","onParsed","onSkinLoaded","onTextureLoaded","onValidated","RegisterSceneLoaderPlugin","GlobalObject","BABYLON","RegisteredGLTFExtensions","Map","registeredGLTFExtensions","registerGLTFExtension","isGLTFExtension","unregisterGLTFExtension","delete","LazyAnimationGroupModulePromise","Lazy","LazyLoaderAnimationModulePromise","Get","context","array","TryGet","Assign","LoadBoundingInfoFromPositionAccessor","min","max","minArray","maxArray","minVector","TmpVectors","copyFromFloats","maxVector","normalized","componentType","divider","oneOverDivider","BoundingInfo","_completePromises","_assetContainer","_babylonLights","_disableInstancedMesh","_allMaterialsDirtyRequired","_skipStartAnimationStep","_extensions","_disposed","_rootUrl","_fileName","_uniqueRootUrl","_bin","_rootBabylonMesh","_defaultBabylonMaterialData","_postSceneLoadActions","_parent","RegisterExtension","UnregisterExtension","_babylonScene","extension","_loadData","_loadAsync","_getMeshes","_getSkeletons","_getAnimationGroups","_getTransformNodes","_getGeometries","spriteManagers","resultFunc","Date","now","_loadExtensionsAsync","loadingToReadyCounterName","LOADING","READY","loadingToCompleteCounterName","COMPLETE","_extensionsOnLoading","promises","oldBlockMaterialDirtyMechanism","blockMaterialDirtyMechanism","loadSceneAsync","scenes","ArrayItem","m","babylonDrawMode","Material","TriangleFillMode","_loadMaterialAsync","_forceBlockMaterialDirtyMechanism","_compileMaterialsAsync","_compileShadowGeneratorsAsync","resultPromise","all","setEnabled","maxSimultaneousLights","Math","_extensionsOnReady","_startAnimations","SetImmediate","catch","_setupData","buffers","binaryBuffer","accessors","bufferViews","images","samplers","skins","nodeParents","children","_createRootNode","parentIndex","extensionPromises","registeredExtension","enabled","isExtensionUsed","sort","order","Number","MAX_VALUE","extensionsRequired","some","_blockEntityCollection","rootMesh","Mesh","_parentContainer","GLTFLoader","_LoadTransform","FORCE_RIGHT_HANDED","extensionPromise","_extensionsLoadSceneAsync","logOpen","loadNodeAsync","action","_loadAnimationsAsync","logClose","_forEachPrimitive","geometry","AbstractMesh","_babylonTransformNodeForSkin","skin","babylonSkeleton","NONE","babylonAnimationGroups","start","ALL","_extensionsLoadNodeAsync","loadNode","babylonTransformNode","AddPointerMetadata","loadCameraAsync","babylonCamera","childNode","childBabylonMesh","hasMesh","hasSkin","nodeName","transformNode","TransformNode","_loadMeshAsync","babylonTransformNodeForSkin","metadata","deepMerge","_loadSkinAsync","skeleton","parentNode","asMesh","isAnInstance","useBoundingInfoFromGeometry","_updateBoundingInfo","refreshBoundingInfo","primitive","_loadMeshPrimitiveAsync","_extensionsLoadMeshPrimitiveAsync","babylonAbstractMesh","promise","shouldInstance","targets","createInstance","sideOrientation","CounterClockWiseSideOrientation","ClockWiseSideOrientation","_createMorphTargets","_loadVertexDataAsync","babylonGeometry","_loadMorphTargetsAsync","applyToMesh","_GetDrawMode","_createDefaultMaterial","_extensionsLoadVertexDataAsync","attributes","Geometry","indices","isUnIndexed","_loadIndicesAccessorAsync","setIndices","loadAttribute","kind","_delayInfo","_loadVertexAccessorAsync","babylonVertexBuffer","getKind","VertexBuffer","PositionKind","babylonBoundingInfo","_boundingInfo","setVerticesBuffer","count","MatricesIndicesExtraKind","numBoneInfluencers","NormalKind","TangentKind","UVKind","UV2Kind","UV3Kind","UV4Kind","UV5Kind","UV6Kind","MatricesIndicesKind","MatricesWeightsKind","MatricesWeightsExtraKind","ColorKind","hasVertexAlpha","targetNames","extras","MorphTargetManager","areUpdatesFrozen","weight","addTarget","MorphTarget","numTargets","babylonMorphTarget","_loadMorphTargetVertexDataAsync","attribute","setData","getVertexBuffer","_loadFloatAccessorAsync","positions","Float32Array","setPositions","normals","setNormals","tangents","dataIndex","setTangents","uvs","setUVs","setUV2s","colors","componentSize","getSize","pixid","floor","channel","setColors","babylonNode","Zero","One","decompose","_extensionsLoadSkinAsync","skeletonId","Skeleton","_loadBones","_loadSkinInverseBindMatricesDataAsync","inverseBindMatricesData","_updateBoneMatrices","_findSkeletonRootNode","joints","skeletonNode","isParent","babylonBones","_loadBone","paths","unshift","j","_isJoint","babylonBone","parentBabylonBone","boneIndex","Bone","_getNodeMatrix","linkTransformNode","inverseBindMatrices","bones","baseMatrix","FromArrayToRef","invertToRef","babylonParentBone","getParent","getAbsoluteInverseBindMatrix","updateMatrix","_updateAbsoluteBindMatrices","_extensionsLoadCameraAsync","FreeCamera","setTarget","Camera","ORTHOGRAPHIC_CAMERA","loadAnimationAsync","animationGroup","targetedAnimations","_extensionsLoadAnimationAsync","AnimationGroup","babylonAnimationGroup","channels","_loadAnimationChannelAsync","babylonTarget","addTargetedAnimation","normalize","animationContext","onLoad","_extensionsLoadAnimationChannelAsync","targetNode","channelTargetPath","pathIsWeights","properties","targetInfo","_loadAnimationChannelFromTargetInfoAsync","invfps","sampler","_loadAnimationSamplerAsync","numAnimations","propertyInfo","stride","input","output","outputOffset","inputAccessor","outputAccessor","inputData","outputData","loadBufferAsync","_extensionsLoadBufferAsync","loadUriAsync","loadBufferViewAsync","bufferView","_extensionsLoadBufferViewAsync","_loadAccessorAsync","numComponents","_GetNumComponents","byteStride","GetTypeByteLength","ForEach","_GetTypedArray","sparse","typedArray","indicesBufferView","valuesBufferView","values","indicesData","valuesData","sparseLength","sparseData","valuesIndex","indicesIndex","componentIndex","_GetTypedArrayConstructor","_loadVertexBufferViewAsync","_babylonBuffer","engine","Buffer","_babylonVertexBuffer","babylonBuffer","_loadMaterialMetallicRoughnessPropertiesAsync","PBRMaterial","Color3","White","loadTextureInfoAsync","albedoTexture","nonColorData","metallicTexture","useMetallnessFromMetallicTextureBlue","useRoughnessFromMetallicTextureGreen","useRoughnessFromMetallicTextureAlpha","_extensionsLoadMaterialAsync","babylonData","createMaterial","babylonMeshes","loadMaterialPropertiesAsync","splice","enableSpecularAntiAliasing","useRadianceOverAlpha","useSpecularOverAlpha","transparencyMode","PBRMATERIAL_OPAQUE","_extensionsCreateMaterial","_extensionsLoadMaterialPropertiesAsync","loadMaterialBasePropertiesAsync","loadMaterialAlphaProperties","doubleSided","backFaceCulling","twoSidedLighting","invertNormalMapX","invertNormalMapY","forceIrradianceInFragment","ambientTexture","useAmbientInGrayScale","alphaMode","PBRMATERIAL_ALPHATEST","alphaCutOff","alphaCutoff","hasAlpha","PBRMATERIAL_ALPHABLEND","useAlphaFromAlbedoTexture","textureInfo","_extensionsLoadTextureInfoAsync","texCoord","_textureInfo","_loadTextureAsync","babylonTexture","coordinatesIndex","_extensionsLoadTextureAsync","DefaultSampler","image","_createTextureAsync","textureLoaderOptions","useSRGBBuffer","samplerData","_loadSampler","deferred","Deferred","textureCreationOptions","noMipmap","noMipMaps","invertY","samplingMode","exception","GetMimeType","loaderOptions","Texture","loadImageAsync","dataUrl","updateURL","internalTexture","getInternalTexture","wrapU","wrapV","minFilter","_GetTextureSamplingMode","_GetTextureWrapMode","wrapS","wrapT","property","_extensionsLoadUriAsync","_ValidateUri","IsBase64DataUrl","log","LoadFileError","status","statusText","babylonObject","pointer","_internalMetadata","pointers","CLAMP_ADDRESSMODE","MIRROR_ADDRESSMODE","WRAP_ADDRESSMODE","magFilter","LINEAR_NEAREST","LINEAR_LINEAR","LINEAR_NEAREST_MIPNEAREST","LINEAR_LINEAR_MIPNEAREST","LINEAR_NEAREST_MIPLINEAR","LINEAR_LINEAR_MIPLINEAR","NEAREST_NEAREST","NEAREST_LINEAR","NEAREST_NEAREST_MIPNEAREST","NEAREST_LINEAR_MIPNEAREST","NEAREST_NEAREST_MIPLINEAR","NEAREST_LINEAR_MIPLINEAR","GetTypedArrayConstructor","componentTypeLength","IsBase64","PointListDrawMode","LineListDrawMode","LineLoopDrawMode","LineStripDrawMode","TriangleStripDrawMode","TriangleFanDrawMode","forceCompilationAsync","useInstances","clipPlane","getShadowGenerator","_forEachExtensions","_applyExtensions","functionName","actionAsync","loaderProperty","_activeLoaderExtensionFunctions","activeLoaderExtensionFunctions","onLoading","onReady","_loadUriAsync","LoadExtensionAsync","extensionName","LoadExtraAsync","extra","extensionsUsed","startPerformanceCounter","endPerformanceCounter","NAME","loader","extensionContext","_loadLightAsync","babylonScene","environmentTexture","specularImages","mipmap","faces","face","specularImageContext","RawCubeTexture","specularImageSize","irradianceCoefficients","sphericalHarmonics","SphericalHarmonics","convertIrradianceToLambertianRadiance","sphericalPolynomial","SphericalPolynomial","FromHarmonics","lodGenerationScale","log2","updateRGBDAsync","instanceCount","translationBuffer","rotationBuffer","scaleBuffer","matrices","ComposeToRef","copyToArray","thinInstanceSetBuffer","EXT_mesh_gpu_instancing","bufferViewMeshopt","_meshOptData","MeshoptCompression","Default","decodeGltfBufferAsync","filter","EXT_meshopt_compression","EXT_texture_webp","EXT_texture_avif","babylonSpotLight","Backward","PI","falloffType","Light","FALLOFF_GLTF","bufferData","iesProfileTexture","useNormalizedFlagFromAccessor","DracoDecoder","DefaultAvailable","dracoDecoder","uniqueId","_dracoBabylonGeometry","positionAccessor","_decodeMeshToGeometryForGltfAsync","KHR_draco_mesh_compression","babylonLight","babylonDirectionalLight","DirectionalLight","setAll","PointLight","KHR_lights","_loadSpecularGlossinessPropertiesAsync","diffuseFactor","reflectivityColor","microSurface","glossinessFactor","diffuseTexture","specularGlossinessTexture","reflectivityTexture","useMicroSurfaceFromReflectivityMapAlpha","KHR_materials_pbrSpecularGlossiness","_loadUnlitPropertiesAsync","unlit","KHR_materials_unlit","_loadClearCoatPropertiesAsync","isEnabled","useRoughnessFromMainTexture","remapF0OnInterfaceChange","textureRoughness","_loadIridescencePropertiesAsync","iridescenceIOR","_loadEmissiveProperties","_loadSheenPropertiesAsync","Black","albedoScaling","_loadSpecularPropertiesAsync","EXT_materials_specular_edge_color","specularEdgeColorEnabled","brdf","dielectricSpecularModel","MATERIAL_DIELECTRIC_SPECULAR_MODEL_OPENPBR","conductorSpecularModel","MATERIAL_CONDUCTOR_SPECULAR_MODEL_OPENPBR","metallicReflectanceTexture","useOnlyMetallicFromMetallicReflectanceTexture","reflectanceTexture","_loadIorPropertiesAsync","_DEFAULT_IOR","GetAvailableVariants","extensionMetadata","_GetExtensionMetadata","variants","getAvailableVariants","KHR_materials_variants","SelectVariant","variantName","select","entries","entry","lastSelected","selectVariant","Reset","original","reset","GetLastSelectedVariant","getLastSelectedVariant","_variants","rootBabylonMesh","defaultVariant","onLoaded","selectedVariant","lastSelectedVariant","isArray","mappingIndex","mapping","mappings","mappingVariantIndex","variantIndex","variant","onClonedObservable","newOne","newMesh","newRoot","variantEntry","_opaqueRenderTarget","_opaqueMeshesCache","_transparentMeshesCache","_materialObservers","_options","TransmissionHelper","_GetDefaultOptions","_scene","_transmissionHelper","_parseScene","_setupRenderTargets","renderSize","samples","lodGenerationOffset","renderTargetTextureType","TEXTURETYPE_HALF_FLOAT","generateMipmaps","updateOptions","newValues","newOptions","oldOptions","getOpaqueTarget","_shouldRenderAsTransmission","isRefractionEnabled","_addMesh","onMaterialChangedObservable","_onMeshMaterialChanged","bind","refractionTexture","_removeMesh","idx","onNewMeshAddedObservable","onMeshRemovedObservable","transparentIdx","opaqueIdx","_isRenderTargetValid","saveSceneEnvIntensity","RenderTargetTexture","ignoreCameraViewport","renderList","clearColor","gammaSpace","renderSprites","renderParticles","disableImageProcessing","onBeforeBindObservable","opaqueRenderTarget","environmentIntensity","toLinearSpaceToRef","useExactSrgbConversions","onAfterUnbindObservable","_loadTransparentPropertiesAsync","pbrMaterial","volumeIndexOfRefraction","useAlbedoToTintRefraction","refractionIntensityTexture","useGltfStyleTextures","_loadTranslucentPropertiesAsync","isTranslucencyEnabled","useAlbedoToTintTranslucency","translucencyIntensityTexture","translucencyColorTexture","_loadVolumePropertiesAsync","useThicknessAsDepth","_loadDispersionPropertiesAsync","isDispersionEnabled","_loadDiffuseRoughnessPropertiesAsync","baseDiffuseModel","MATERIAL_DIFFUSE_MODEL_E_OREN_NAYAR","diffuseRoughnessFactor","baseDiffuseRoughness","diffuseRoughnessTexture","baseDiffuseRoughnessTexture","EXT_materials_diffuse_roughness","KHR_mesh_quantization","useRGBAIfASTCBC7NotAvailableWhenUASTC","KHR_texture_basisu","uRotationCenter","vRotationCenter","xmpGltf","KHR_xmp_json_ld","xmpNode","packet","packets","xmp","getColor3","getFloat","getMinusFloat","getNextFloat","getFloatBy2","getTextureTransformTree","textureName","MaterialAnimationPropertyInfo","CameraAnimationPropertyInfo","ANIMATIONTYPE_COLOR3","baseColorTextureInterpolation","metallicRoughnessTextureInterpolation","normalTextureInterpolation","occlusionTextureInterpolation","emissiveTextureInterpolation","anisotropyTextureInterpolation","clearcoatTextureInterpolation","clearcoatNormalTextureInterpolation","clearcoatRoughnessTextureInterpolation","iridescenceTextureInterpolation","iridescenceThicknessTextureInterpolation","sheenTextureInterpolation","sheenRoughnessTextureInterpolation","specularTextureInterpolation","specularColorTextureInterpolation","transmissionTextureInterpolation","thicknessTextureInterpolation","diffuseTransmissionTextureInterpolation","diffuseTransmissionColorTextureInterpolation","LightAnimationPropertyInfo","_pathToObjectConverter","KHR_animation_pointer","_clips","_emitters","clips","emitters","emitterIndex","emitter","refDistance","maxDistance","rolloffFactor","distanceModel","outerAngle","_loadEmitterAsync","_babylonSounds","sound","attachToMesh","setLocalDirectionToMesh","Forward","setDirectionalCone","ToDegrees","events","_loadAnimationEventAsync","_loadClipAsync","clip","_objectURL","_babylonData","clipPromises","loop","autoplay","volume","clipContext","objectURL","Sound","weightedSound","WeightedSound","directionalConeInnerAngle","directionalConeOuterAngle","_getEventAction","time","startOffset","currentFrame","frameOffset","play","stop","pause","babylonAnimationEvent","AnimationEvent","addEvent","onAnimationGroupEndObservable","onAnimationGroupPauseObservable","MSFT_audio_emitter","maxLODsToLoad","onNodeLODsLoadedObservable","onMaterialLODsLoadedObservable","_bufferLODs","_nodeIndexLOD","_nodeSignalLODs","_nodePromiseLODs","_nodeBufferLODs","_materialIndexLOD","_materialSignalLODs","_materialPromiseLODs","_materialBufferLODs","indexLOD","_loadBufferLOD","nodeLODs","_getLODs","ids","nodeLOD","previousNodeLOD","_disposeTransformNode","firstPromise","materialLODs","materialLOD","previousDataLOD","_disposeMaterials","previousIndexLOD","bufferLODs","end","bufferLOD","babylonMaterials","getChildMeshes","babylonMaterialsToDispose","every","babylonTextures","getActiveTextures","hasTexture","MSFT_lod","extraContext","needAlphaBlending","forceDepthWrite","separateCullingPass","MSFT_minecraftMesh","getMappingForFullOperationName","fullOperationName","getMappingForDeclaration","declaration","returnNoOpIfNotAvailable","gltfExtensionsToFlowGraphMapping","gltfToFlowGraphMapping","inputs","flows","inputValueSockets","outputValueSockets","blocks","outputs","addNewInteractivityFlowGraphMapping","MSFT_sRGBFactors","out","timeSinceLastTick","gltfType","extraProcessor","gltfBlock","_mapping","parser","serializedObjects","configuration","eventId","arrays","serializedObject","eventData","validation","interactivityGraph","valid","eventConfiguration","getSimpleInputMapping","roundHalfAwayFromZero","_gltfBlock","_declaration","_parser","useMatrixPerComponent","preventIntegerFloatArithmetic","types","flowGraphType","ValidateTypes","condition","c","dataInputs","_connectionValues","axis","inputIsColumnMajor","h","k","l","socketIn","valueType","socketInA","socketInB","_arrays","outputSignalCount","signalOutputs","true","false","cases","inOptions","defaultValue","selection","default","caseValue","toString","uniqueCases","Set","from","loopBody","initialIndex","startIndex","endIndex","incrementIndexWhenLoopDone","currentCount","isRandom","isLoop","inputFlows","err","variable","isVariable","dataTransformer","getVariableName","variables","useSlerp","duration","p1","toBlock","p2","in","interBlockConnectors","inputBlockIndex","outputBlockIndex","serializedValueInterpolation","propertyIndex","staticVariables","animationType","getAnimationTypeByFlowGraphType","serializedGetVariable","className","outputValue","speed","startTime","_animationTargetFps","endTime","_context","globalGLTF","stopTime","treatCasesAsIntegers","inferType","reduce","acc","getAllSupportedNativeNodeTypes","gltfTypeToBabylonType","float","elementType","bool","float2","float3","float4","float4x4","float2x2","float3x3","int","_interactivityGraph","_types","_mappings","_staticVariables","_events","_internalEventsCounter","_nodes","_parseTypes","_parseDeclarations","_parseVariables","_parseEvents","_parseNodes","signature","declarations","flowGraphMapping","_parseVariable","dataTransform","NaN","fill","parseFloat","converted","eventValue","validationResult","blockType","block","_getEmptyBlock","_parseNodeConfiguration","RandomGUID","dataOutputs","signalInputs","nodeMapping","configMapping","configKey","_parseNodeConnections","gltfNode","flowGraphBlocks","outputMapper","flowsFromGLTF","flowsKeys","flowKey","flow","flowMapping","socketOutName","socketOut","_createNewSocketConnection","inputNodeId","nodeIn","inputMapper","flowInMapping","socket","arrayMapping","endsWith","nodeInSocketName","inputBlock","connectedPointIds","valuesFromGLTF","valuesKeys","valueKey","valueMapping","socketInName","convertedValue","nodeOutId","nodeOutSocketName","nodeOut","outBlock","connector","_connectFlowGraphNodes","isOutput","_connectionType","serializedInput","serializedOutput","inputArray","outputArray","inputConnection","outputConnection","serializeToFlowGraph","_userVariables","rightHanded","allBlocks","val","concat","executionContexts","_pathConverter","_AddInteractivityObjectModel","interactivityDefinition","KHR_interactivity","coordinator","FlowGraphCoordinator","dispatchEventsSynchronously","graphs","graph","InteractivityGraphToFlowGraphParser","ParseFlowGraphAsync","pathConverter","activeCamera","quat","getWorldMatrix","w","pos","getTranslation","isPlaying","to","getCurrentFrame","addToBlockFactory","FlowGraphGLTFDataProvider","tn","isVisible","inheritVisibility","KHR_node_visibility","visible","stopPropagation","nodeIndex","selectedNodeIndex","controllerIndex","selectionPoint","selectionRayOrigin","variableName","isPickable","KHR_node_selectability","selectable","MeshPointerOverPrefix","hoverNodeIndex","MeshPointerOutPrefix","pointerOverDisableMeshTesting","KHR_node_hoverability","hoverable","_assignExtras","gltfProp","ExtrasAsMetadata","GLTF2","Loader","Extensions"],"sourceRoot":""}
+{"version":3,"file":"babylon.glTF2FileLoader.min.js","mappings":"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","sources":["webpack://LOADERS/webpack/universalModuleDefinition","webpack://LOADERS/webpack/runtime/create fake namespace object","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_interactivity/flowGraphGLTFDataProvider.ts","webpack://LOADERS/../../../../node_modules/tslib/tslib.es6.mjs","webpack://LOADERS/external umd {\"root\":\"BABYLON\",\"commonjs\":\"babylonjs\",\"commonjs2\":\"babylonjs\",\"amd\":\"babylonjs\"}","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/gltfPathToObjectConverter.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/objectModelMapping.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/glTFLoaderAnimation.ts","webpack://LOADERS/webpack/bootstrap","webpack://LOADERS/webpack/runtime/compat get default export","webpack://LOADERS/webpack/runtime/define property getters","webpack://LOADERS/webpack/runtime/global","webpack://LOADERS/webpack/runtime/hasOwnProperty shorthand","webpack://LOADERS/webpack/runtime/make namespace object","webpack://LOADERS/../../../dev/loaders/src/glTF/glTFValidation.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/glTFFileLoader.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/glTFFileLoader.metadata.ts","webpack://LOADERS/../../../lts/loaders/src/legacy/legacy-glTF.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/glTFLoaderExtensionRegistry.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/glTFLoader.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/EXT_lights_image_based.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/EXT_mesh_gpu_instancing.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/EXT_meshopt_compression.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/EXT_texture_webp.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/EXT_texture_avif.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/EXT_lights_ies.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_draco_mesh_compression.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_lights_punctual.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_pbrSpecularGlossiness.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_unlit.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_clearcoat.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_iridescence.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_anisotropy.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_emissive_strength.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_sheen.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_specular.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_ior.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_variants.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_transmission.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_diffuse_transmission.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_volume.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_materials_dispersion.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/EXT_materials_diffuse_roughness.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_mesh_quantization.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_texture_basisu.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_texture_transform.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_xmp_json_ld.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_animation_pointer.data.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_animation_pointer.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/MSFT_audio_emitter.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/MSFT_lod.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/MSFT_minecraftMesh.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/MSFT_sRGBFactors.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_interactivity/declarationMapper.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_interactivity/interactivityGraphParser.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_interactivity.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_node_visibility.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_node_selectability.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/KHR_node_hoverability.ts","webpack://LOADERS/../../../dev/loaders/src/glTF/2.0/Extensions/ExtrasAsMetadata.ts","webpack://LOADERS/../../../lts/loaders/src/legacy/legacy-glTF2.ts","webpack://LOADERS/./src/glTF2FileLoader.ts"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"babylonjs\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"babylonjs-loaders\", [\"babylonjs\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"babylonjs-loaders\"] = factory(require(\"babylonjs\"));\n\telse\n\t\troot[\"LOADERS\"] = factory(root[\"BABYLON\"]);\n})((typeof self !== \"undefined\" ? self : typeof global !== \"undefined\" ? global : this), (__WEBPACK_EXTERNAL_MODULE__597__) => {\nreturn ","var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);\nvar leafPrototypes;\n// create a fake namespace object\n// mode & 1: value is a module id, require it\n// mode & 2: merge all properties of value into the ns\n// mode & 4: return value when already ns object\n// mode & 16: return value when it's Promise-like\n// mode & 8|1: behave like require\n__webpack_require__.t = function(value, mode) {\n\tif(mode & 1) value = this(value);\n\tif(mode & 8) return value;\n\tif(typeof value === 'object' && value) {\n\t\tif((mode & 4) && value.__esModule) return value;\n\t\tif((mode & 16) && typeof value.then === 'function') return value;\n\t}\n\tvar ns = Object.create(null);\n\t__webpack_require__.r(ns);\n\tvar def = {};\n\tleafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];\n\tfor(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {\n\t\tObject.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));\n\t}\n\tdef['default'] = () => (value);\n\t__webpack_require__.d(ns, def);\n\treturn ns;\n};","import type { IFlowGraphBlockConfiguration } from \"core/FlowGraph/flowGraphBlock\";\nimport { FlowGraphBlock } from \"core/FlowGraph/flowGraphBlock\";\nimport type { IGLTF } from \"../../glTFLoaderInterfaces\";\nimport type { FlowGraphDataConnection } from \"core/FlowGraph/flowGraphDataConnection\";\nimport type { AnimationGroup } from \"core/Animations/animationGroup\";\nimport type { TransformNode } from \"core/Meshes/transformNode\";\nimport { RichTypeAny } from \"core/FlowGraph/flowGraphRichTypes\";\n\n/**\n * a configuration interface for this block\n */\nexport interface IFlowGraphGLTFDataProviderBlockConfiguration extends IFlowGraphBlockConfiguration {\n    /**\n     * the glTF object to provide data from\n     */\n    glTF: IGLTF;\n}\n\n/**\n * a glTF-based FlowGraph block that provides arrays with babylon object, based on the glTF tree\n * Can be used, for example, to get animation index from a glTF animation\n */\nexport class FlowGraphGLTFDataProvider extends FlowGraphBlock {\n    /**\n     * Output: an array of animation groups\n     * Corresponds directly to the glTF animations array\n     */\n    public readonly animationGroups: FlowGraphDataConnection<AnimationGroup[]>;\n\n    /**\n     * Output an array of (Transform) nodes\n     * Corresponds directly to the glTF nodes array\n     */\n    public readonly nodes: FlowGraphDataConnection<TransformNode[]>;\n\n    constructor(config: IFlowGraphGLTFDataProviderBlockConfiguration) {\n        super();\n        const glTF = config.glTF;\n        const animationGroups = glTF.animations?.map((a) => a._babylonAnimationGroup) || [];\n        this.animationGroups = this.registerDataOutput(\"animationGroups\", RichTypeAny, animationGroups);\n        const nodes = glTF.nodes?.map((n) => n._babylonTransformNode) || [];\n        this.nodes = this.registerDataOutput(\"nodes\", RichTypeAny, nodes);\n    }\n\n    public override getClassName(): string {\n        return \"FlowGraphGLTFDataProvider\";\n    }\n}\n","/******************************************************************************\nCopyright (c) Microsoft Corporation.\n\nPermission to use, copy, modify, and/or distribute this software for any\npurpose with or without fee is hereby granted.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\nPERFORMANCE OF THIS SOFTWARE.\n***************************************************************************** */\n/* global Reflect, Promise, SuppressedError, Symbol, Iterator */\n\nvar extendStatics = function(d, b) {\n  extendStatics = Object.setPrototypeOf ||\n      ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n      function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n  return extendStatics(d, b);\n};\n\nexport function __extends(d, b) {\n  if (typeof b !== \"function\" && b !== null)\n      throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n  extendStatics(d, b);\n  function __() { this.constructor = d; }\n  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n}\n\nexport var __assign = function() {\n  __assign = Object.assign || function __assign(t) {\n      for (var s, i = 1, n = arguments.length; i < n; i++) {\n          s = arguments[i];\n          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n      }\n      return t;\n  }\n  return __assign.apply(this, arguments);\n}\n\nexport function __rest(s, e) {\n  var t = {};\n  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n      t[p] = s[p];\n  if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n      for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n          if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n              t[p[i]] = s[p[i]];\n      }\n  return t;\n}\n\nexport function __decorate(decorators, target, key, desc) {\n  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n  if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n  return c > 3 && r && Object.defineProperty(target, key, r), r;\n}\n\nexport function __param(paramIndex, decorator) {\n  return function (target, key) { decorator(target, key, paramIndex); }\n}\n\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\n  function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\n  var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\n  var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\n  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\n  var _, done = false;\n  for (var i = decorators.length - 1; i >= 0; i--) {\n      var context = {};\n      for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\n      for (var p in contextIn.access) context.access[p] = contextIn.access[p];\n      context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\n      var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\n      if (kind === \"accessor\") {\n          if (result === void 0) continue;\n          if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\n          if (_ = accept(result.get)) descriptor.get = _;\n          if (_ = accept(result.set)) descriptor.set = _;\n          if (_ = accept(result.init)) initializers.unshift(_);\n      }\n      else if (_ = accept(result)) {\n          if (kind === \"field\") initializers.unshift(_);\n          else descriptor[key] = _;\n      }\n  }\n  if (target) Object.defineProperty(target, contextIn.name, descriptor);\n  done = true;\n};\n\nexport function __runInitializers(thisArg, initializers, value) {\n  var useValue = arguments.length > 2;\n  for (var i = 0; i < initializers.length; i++) {\n      value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\n  }\n  return useValue ? value : void 0;\n};\n\nexport function __propKey(x) {\n  return typeof x === \"symbol\" ? x : \"\".concat(x);\n};\n\nexport function __setFunctionName(f, name, prefix) {\n  if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\n  return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\n};\n\nexport function __metadata(metadataKey, metadataValue) {\n  if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\n}\n\nexport function __awaiter(thisArg, _arguments, P, generator) {\n  function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n  return new (P || (P = Promise))(function (resolve, reject) {\n      function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n      function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n      function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n      step((generator = generator.apply(thisArg, _arguments || [])).next());\n  });\n}\n\nexport function __generator(thisArg, body) {\n  var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === \"function\" ? Iterator : Object).prototype);\n  return g.next = verb(0), g[\"throw\"] = verb(1), g[\"return\"] = verb(2), typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n  function verb(n) { return function (v) { return step([n, v]); }; }\n  function step(op) {\n      if (f) throw new TypeError(\"Generator is already executing.\");\n      while (g && (g = 0, op[0] && (_ = 0)), _) try {\n          if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n          if (y = 0, t) op = [op[0] & 2, t.value];\n          switch (op[0]) {\n              case 0: case 1: t = op; break;\n              case 4: _.label++; return { value: op[1], done: false };\n              case 5: _.label++; y = op[1]; op = [0]; continue;\n              case 7: op = _.ops.pop(); _.trys.pop(); continue;\n              default:\n                  if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                  if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                  if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                  if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                  if (t[2]) _.ops.pop();\n                  _.trys.pop(); continue;\n          }\n          op = body.call(thisArg, _);\n      } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n      if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n  }\n}\n\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  var desc = Object.getOwnPropertyDescriptor(m, k);\n  if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n  }\n  Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  o[k2] = m[k];\n});\n\nexport function __exportStar(m, o) {\n  for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\n}\n\nexport function __values(o) {\n  var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n  if (m) return m.call(o);\n  if (o && typeof o.length === \"number\") return {\n      next: function () {\n          if (o && i >= o.length) o = void 0;\n          return { value: o && o[i++], done: !o };\n      }\n  };\n  throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n}\n\nexport function __read(o, n) {\n  var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n  if (!m) return o;\n  var i = m.call(o), r, ar = [], e;\n  try {\n      while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n  }\n  catch (error) { e = { error: error }; }\n  finally {\n      try {\n          if (r && !r.done && (m = i[\"return\"])) m.call(i);\n      }\n      finally { if (e) throw e.error; }\n  }\n  return ar;\n}\n\n/** @deprecated */\nexport function __spread() {\n  for (var ar = [], i = 0; i < arguments.length; i++)\n      ar = ar.concat(__read(arguments[i]));\n  return ar;\n}\n\n/** @deprecated */\nexport function __spreadArrays() {\n  for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\n  for (var r = Array(s), k = 0, i = 0; i < il; i++)\n      for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\n          r[k] = a[j];\n  return r;\n}\n\nexport function __spreadArray(to, from, pack) {\n  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n      if (ar || !(i in from)) {\n          if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n          ar[i] = from[i];\n      }\n  }\n  return to.concat(ar || Array.prototype.slice.call(from));\n}\n\nexport function __await(v) {\n  return this instanceof __await ? (this.v = v, this) : new __await(v);\n}\n\nexport function __asyncGenerator(thisArg, _arguments, generator) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var g = generator.apply(thisArg, _arguments || []), i, q = [];\n  return i = Object.create((typeof AsyncIterator === \"function\" ? AsyncIterator : Object).prototype), verb(\"next\"), verb(\"throw\"), verb(\"return\", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;\n  function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }\n  function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }\n  function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\n  function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\n  function fulfill(value) { resume(\"next\", value); }\n  function reject(value) { resume(\"throw\", value); }\n  function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\n}\n\nexport function __asyncDelegator(o) {\n  var i, p;\n  return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\n  function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\n}\n\nexport function __asyncValues(o) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var m = o[Symbol.asyncIterator], i;\n  return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\n  function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\n  function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\n}\n\nexport function __makeTemplateObject(cooked, raw) {\n  if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\n  return cooked;\n};\n\nvar __setModuleDefault = Object.create ? (function(o, v) {\n  Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n  o[\"default\"] = v;\n};\n\nvar ownKeys = function(o) {\n  ownKeys = Object.getOwnPropertyNames || function (o) {\n    var ar = [];\n    for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;\n    return ar;\n  };\n  return ownKeys(o);\n};\n\nexport function __importStar(mod) {\n  if (mod && mod.__esModule) return mod;\n  var result = {};\n  if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== \"default\") __createBinding(result, mod, k[i]);\n  __setModuleDefault(result, mod);\n  return result;\n}\n\nexport function __importDefault(mod) {\n  return (mod && mod.__esModule) ? mod : { default: mod };\n}\n\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n  return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n}\n\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\n  if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n  if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n  if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n  return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n}\n\nexport function __classPrivateFieldIn(state, receiver) {\n  if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\n  return typeof state === \"function\" ? receiver === state : state.has(receiver);\n}\n\nexport function __addDisposableResource(env, value, async) {\n  if (value !== null && value !== void 0) {\n    if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\n    var dispose, inner;\n    if (async) {\n      if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\n      dispose = value[Symbol.asyncDispose];\n    }\n    if (dispose === void 0) {\n      if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\n      dispose = value[Symbol.dispose];\n      if (async) inner = dispose;\n    }\n    if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\n    if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };\n    env.stack.push({ value: value, dispose: dispose, async: async });\n  }\n  else if (async) {\n    env.stack.push({ async: true });\n  }\n  return value;\n}\n\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\n  var e = new Error(message);\n  return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\n};\n\nexport function __disposeResources(env) {\n  function fail(e) {\n    env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\n    env.hasError = true;\n  }\n  var r, s = 0;\n  function next() {\n    while (r = env.stack.pop()) {\n      try {\n        if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);\n        if (r.dispose) {\n          var result = r.dispose.call(r.value);\n          if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\n        }\n        else s |= 1;\n      }\n      catch (e) {\n        fail(e);\n      }\n    }\n    if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();\n    if (env.hasError) throw env.error;\n  }\n  return next();\n}\n\nexport function __rewriteRelativeImportExtension(path, preserveJsx) {\n  if (typeof path === \"string\" && /^\\.\\.?\\//.test(path)) {\n      return path.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+?)?)\\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {\n          return tsx ? preserveJsx ? \".jsx\" : \".js\" : d && (!ext || !cm) ? m : (d + ext + \".\" + cm.toLowerCase() + \"js\");\n      });\n  }\n  return path;\n}\n\nexport default {\n  __extends,\n  __assign,\n  __rest,\n  __decorate,\n  __param,\n  __esDecorate,\n  __runInitializers,\n  __propKey,\n  __setFunctionName,\n  __metadata,\n  __awaiter,\n  __generator,\n  __createBinding,\n  __exportStar,\n  __values,\n  __read,\n  __spread,\n  __spreadArrays,\n  __spreadArray,\n  __await,\n  __asyncGenerator,\n  __asyncDelegator,\n  __asyncValues,\n  __makeTemplateObject,\n  __importStar,\n  __importDefault,\n  __classPrivateFieldGet,\n  __classPrivateFieldSet,\n  __classPrivateFieldIn,\n  __addDisposableResource,\n  __disposeResources,\n  __rewriteRelativeImportExtension,\n};\n","module.exports = __WEBPACK_EXTERNAL_MODULE__597__;","import type { IObjectInfo, IPathToObjectConverter } from \"core/ObjectModel/objectModelInterfaces\";\r\nimport type { IGLTF } from \"../glTFLoaderInterfaces\";\r\nimport type { IObjectAccessor } from \"core/FlowGraph/typeDefinitions\";\r\n\r\n/**\r\n * Adding an exception here will break traversing through the glTF object tree.\r\n * This is used for properties that might not be in the glTF object model, but are optional and have a default value.\r\n * For example, the path /nodes/\\{\\}/extensions/KHR_node_visibility/visible is optional - the object can be deferred without the object fully existing.\r\n */\r\nexport const OptionalPathExceptionsList: {\r\n    regex: RegExp;\r\n}[] = [\r\n    {\r\n        // get the node as object when reading an extension\r\n        regex: new RegExp(`^/nodes/\\\\d+/extensions/`),\r\n    },\r\n];\r\n\r\n/**\r\n * A converter that takes a glTF Object Model JSON Pointer\r\n * and transforms it into an ObjectAccessorContainer, allowing\r\n * objects referenced in the glTF to be associated with their\r\n * respective Babylon.js objects.\r\n */\r\nexport class GLTFPathToObjectConverter<T, BabylonType, BabylonValue> implements IPathToObjectConverter<IObjectAccessor<T, BabylonType, BabylonValue>> {\r\n    public constructor(\r\n        private _gltf: IGLTF,\r\n        private _infoTree: any\r\n    ) {}\r\n\r\n    /**\r\n     * The pointer string is represented by a [JSON pointer](https://datatracker.ietf.org/doc/html/rfc6901).\r\n     * See also https://github.com/KhronosGroup/glTF/blob/main/specification/2.0/ObjectModel.adoc#core-pointers\r\n     * <animationPointer> := /<rootNode>/<assetIndex>/<propertyPath>\r\n     * <rootNode> := \"nodes\" | \"materials\" | \"meshes\" | \"cameras\" | \"extensions\"\r\n     * <assetIndex> := <digit> | <name>\r\n     * <propertyPath> := <extensionPath> | <standardPath>\r\n     * <extensionPath> := \"extensions\"/<name>/<standardPath>\r\n     * <standardPath> := <name> | <name>/<standardPath>\r\n     * <name> := W+\r\n     * <digit> := D+\r\n     *\r\n     * Examples:\r\n     *  - \"/nodes/0/rotation\"\r\n     * - \"/nodes.length\"\r\n     *  - \"/materials/2/emissiveFactor\"\r\n     *  - \"/materials/2/pbrMetallicRoughness/baseColorFactor\"\r\n     *  - \"/materials/2/extensions/KHR_materials_emissive_strength/emissiveStrength\"\r\n     *\r\n     * @param path The path to convert\r\n     * @returns The object and info associated with the path\r\n     */\r\n    public convert(path: string): IObjectInfo<IObjectAccessor<T, BabylonType, BabylonValue>> {\r\n        let objectTree: any = this._gltf;\r\n        let infoTree: any = this._infoTree;\r\n        let target: any = undefined;\r\n\r\n        if (!path.startsWith(\"/\")) {\r\n            throw new Error(\"Path must start with a /\");\r\n        }\r\n        const parts = path.split(\"/\");\r\n        parts.shift();\r\n\r\n        //if the last part has \".length\" in it, separate that as an extra part\r\n        if (parts[parts.length - 1].includes(\".length\")) {\r\n            const lastPart = parts[parts.length - 1];\r\n            const split = lastPart.split(\".\");\r\n            parts.pop();\r\n            parts.push(...split);\r\n        }\r\n\r\n        let ignoreObjectTree = false;\r\n\r\n        for (const part of parts) {\r\n            const isLength = part === \"length\";\r\n            if (isLength && !infoTree.__array__) {\r\n                throw new Error(`Path ${path} is invalid`);\r\n            }\r\n            if (infoTree.__ignoreObjectTree__) {\r\n                ignoreObjectTree = true;\r\n            }\r\n            if (infoTree.__array__ && !isLength) {\r\n                infoTree = infoTree.__array__;\r\n            } else {\r\n                infoTree = infoTree[part];\r\n                if (!infoTree) {\r\n                    throw new Error(`Path ${path} is invalid`);\r\n                }\r\n            }\r\n            if (!ignoreObjectTree) {\r\n                if (objectTree === undefined) {\r\n                    // check if the path is in the exception list. If it is, break and return the last object that was found\r\n                    const exception = OptionalPathExceptionsList.find((e) => e.regex.test(path));\r\n                    if (!exception) {\r\n                        throw new Error(`Path ${path} is invalid`);\r\n                    }\r\n                } else if (!isLength) {\r\n                    objectTree = objectTree?.[part];\r\n                }\r\n            }\r\n\r\n            if (infoTree.__target__ || isLength) {\r\n                target = objectTree;\r\n            }\r\n        }\r\n\r\n        return {\r\n            object: target,\r\n            info: infoTree,\r\n        };\r\n    }\r\n}\r\n","/* eslint-disable @typescript-eslint/naming-convention */\n\nimport type { TransformNode } from \"core/Meshes/transformNode\";\nimport type { IAnimation, ICamera, IGLTF, IKHRLightsPunctual_Light, IMaterial, IMesh, INode } from \"../glTFLoaderInterfaces\";\nimport type { Vector3 } from \"core/Maths/math.vector\";\nimport { Matrix, Quaternion, Vector2 } from \"core/Maths/math.vector\";\nimport { Constants } from \"core/Engines/constants\";\nimport type { Color3 } from \"core/Maths/math.color\";\nimport { Color4 } from \"core/Maths/math.color\";\nimport type { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\nimport type { Light } from \"core/Lights/light\";\nimport type { Nullable } from \"core/types\";\nimport { SpotLight } from \"core/Lights/spotLight\";\nimport type { IEXTLightsImageBased_LightImageBased } from \"babylonjs-gltf2interface\";\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\nimport type { IInterpolationPropertyInfo, IObjectAccessor } from \"core/FlowGraph/typeDefinitions\";\nimport { GLTFPathToObjectConverter } from \"./gltfPathToObjectConverter\";\nimport type { AnimationGroup } from \"core/Animations/animationGroup\";\nimport type { Mesh } from \"core/Meshes/mesh\";\n\nexport interface IGLTFObjectModelTree {\n    cameras: IGLTFObjectModelTreeCamerasObject;\n    nodes: IGLTFObjectModelTreeNodesObject;\n    materials: IGLTFObjectModelTreeMaterialsObject;\n    extensions: IGLTFObjectModelTreeExtensionsObject;\n    animations: {\n        length: IObjectAccessor<IAnimation[], AnimationGroup[], number>;\n        __array__: {};\n    };\n    meshes: {\n        length: IObjectAccessor<IMesh[], (Mesh | undefined)[], number>;\n        __array__: {};\n    };\n}\n\nexport interface IGLTFObjectModelTreeNodesObject<GLTFTargetType = INode, BabylonTargetType = TransformNode> {\n    length: IObjectAccessor<GLTFTargetType[], BabylonTargetType[], number>;\n    __array__: {\n        __target__: boolean;\n        translation: IObjectAccessor<GLTFTargetType, BabylonTargetType, Vector3>;\n        rotation: IObjectAccessor<GLTFTargetType, BabylonTargetType, Quaternion>;\n        scale: IObjectAccessor<GLTFTargetType, BabylonTargetType, Vector3>;\n        matrix: IObjectAccessor<GLTFTargetType, BabylonTargetType, Matrix>;\n        globalMatrix: IObjectAccessor<GLTFTargetType, BabylonTargetType, Matrix>;\n        weights: {\n            length: IObjectAccessor<GLTFTargetType, BabylonTargetType, number>;\n            __array__: { __target__: boolean } & IObjectAccessor<GLTFTargetType, BabylonTargetType, number>;\n        } & IObjectAccessor<GLTFTargetType, BabylonTargetType, number[]>;\n        extensions: {\n            EXT_lights_ies?: {\n                multiplier: IObjectAccessor<INode, Light, number>;\n                color: IObjectAccessor<INode, Light, Color3>;\n            };\n        };\n    };\n}\n\nexport interface IGLTFObjectModelTreeCamerasObject {\n    __array__: {\n        __target__: boolean;\n        orthographic: {\n            xmag: IObjectAccessor<ICamera, ICamera, Vector2>;\n            ymag: IObjectAccessor<ICamera, ICamera, Vector2>;\n            zfar: IObjectAccessor<ICamera, ICamera, number>;\n            znear: IObjectAccessor<ICamera, ICamera, number>;\n        };\n        perspective: {\n            yfov: IObjectAccessor<ICamera, ICamera, number>;\n            zfar: IObjectAccessor<ICamera, ICamera, number>;\n            znear: IObjectAccessor<ICamera, ICamera, number>;\n            aspectRatio: IObjectAccessor<ICamera, ICamera, Nullable<number>>;\n        };\n    };\n}\n\nexport interface IGLTFObjectModelTreeMaterialsObject {\n    __array__: {\n        __target__: boolean;\n        pbrMetallicRoughness: {\n            baseColorFactor: IObjectAccessor<IMaterial, PBRMaterial, Color4>;\n            metallicFactor: IObjectAccessor<IMaterial, PBRMaterial, Nullable<number>>;\n            roughnessFactor: IObjectAccessor<IMaterial, PBRMaterial, Nullable<number>>;\n            baseColorTexture: {\n                extensions: {\n                    KHR_texture_transform: ITextureDefinition;\n                };\n            };\n            metallicRoughnessTexture: {\n                extensions: {\n                    KHR_texture_transform: ITextureDefinition;\n                };\n            };\n        };\n        emissiveFactor: IObjectAccessor<IMaterial, PBRMaterial, Color3>;\n        normalTexture: {\n            scale: IObjectAccessor<IMaterial, PBRMaterial, number>;\n            extensions: {\n                KHR_texture_transform: ITextureDefinition;\n            };\n        };\n        occlusionTexture: {\n            strength: IObjectAccessor<IMaterial, PBRMaterial, number>;\n            extensions: {\n                KHR_texture_transform: ITextureDefinition;\n            };\n        };\n        emissiveTexture: {\n            extensions: {\n                KHR_texture_transform: ITextureDefinition;\n            };\n        };\n        extensions: {\n            KHR_materials_anisotropy: {\n                anisotropyStrength: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                anisotropyRotation: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                anisotropyTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n            };\n            KHR_materials_clearcoat: {\n                clearcoatFactor: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                clearcoatRoughnessFactor: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                clearcoatTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n                clearcoatNormalTexture: {\n                    scale: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n                clearcoatRoughnessTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n            };\n            KHR_materials_dispersion: {\n                dispersion: IObjectAccessor<IMaterial, PBRMaterial, number>;\n            };\n            KHR_materials_emissive_strength: {\n                emissiveStrength: IObjectAccessor<IMaterial, PBRMaterial, number>;\n            };\n            KHR_materials_ior: {\n                ior: IObjectAccessor<IMaterial, PBRMaterial, number>;\n            };\n            KHR_materials_iridescence: {\n                iridescenceFactor: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                iridescenceIor: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                iridescenceThicknessMinimum: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                iridescenceThicknessMaximum: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                iridescenceTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n                iridescenceThicknessTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n            };\n            KHR_materials_sheen: {\n                sheenColorFactor: IObjectAccessor<IMaterial, PBRMaterial, Color3>;\n                sheenRoughnessFactor: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                sheenColorTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n                sheenRoughnessTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n            };\n            KHR_materials_specular: {\n                specularFactor: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                specularColorFactor: IObjectAccessor<IMaterial, PBRMaterial, Color3>;\n                specularTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n                specularColorTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n            };\n            KHR_materials_transmission: {\n                transmissionFactor: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                transmissionTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n            };\n            KHR_materials_diffuse_transmission: {\n                diffuseTransmissionFactor: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                diffuseTransmissionTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n                diffuseTransmissionColorFactor: IObjectAccessor<IMaterial, PBRMaterial, Nullable<Color3>>;\n                diffuseTransmissionColorTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n            };\n            KHR_materials_volume: {\n                thicknessFactor: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                attenuationColor: IObjectAccessor<IMaterial, PBRMaterial, Color3>;\n                attenuationDistance: IObjectAccessor<IMaterial, PBRMaterial, number>;\n                thicknessTexture: {\n                    extensions: {\n                        KHR_texture_transform: ITextureDefinition;\n                    };\n                };\n            };\n        };\n    };\n}\n\ninterface ITextureDefinition {\n    offset: IObjectAccessor<IMaterial, PBRMaterial, Vector2>;\n    rotation: IObjectAccessor<IMaterial, PBRMaterial, number>;\n    scale: IObjectAccessor<IMaterial, PBRMaterial, Vector2>;\n}\n\nexport interface IGLTFObjectModelTreeMeshesObject {}\n\nexport interface IGLTFObjectModelTreeExtensionsObject {\n    KHR_lights_punctual: {\n        lights: {\n            length: IObjectAccessor<IKHRLightsPunctual_Light[], Light[], number>;\n            __array__: {\n                __target__: boolean;\n                color: IObjectAccessor<IKHRLightsPunctual_Light, Light, Color3>;\n                intensity: IObjectAccessor<IKHRLightsPunctual_Light, Light, number>;\n                range: IObjectAccessor<IKHRLightsPunctual_Light, Light, number>;\n                spot: {\n                    innerConeAngle: IObjectAccessor<IKHRLightsPunctual_Light, Light, number>;\n                    outerConeAngle: IObjectAccessor<IKHRLightsPunctual_Light, Light, number>;\n                };\n            };\n        };\n    };\n    EXT_lights_ies: {\n        lights: {\n            length: IObjectAccessor<IKHRLightsPunctual_Light[], Light[], number>;\n        };\n    };\n    EXT_lights_image_based: {\n        lights: {\n            __array__: {\n                __target__: boolean;\n                intensity: IObjectAccessor<IEXTLightsImageBased_LightImageBased, BaseTexture, number>;\n                rotation: IObjectAccessor<IEXTLightsImageBased_LightImageBased, BaseTexture, Quaternion>;\n            };\n            length: IObjectAccessor<IEXTLightsImageBased_LightImageBased[], BaseTexture[], number>;\n        };\n    };\n}\n\nconst nodesTree: IGLTFObjectModelTreeNodesObject = {\n    length: {\n        type: \"number\",\n        get: (nodes: INode[]) => nodes.length,\n        getTarget: (nodes: INode[]) => nodes.map((node) => node._babylonTransformNode!),\n        getPropertyName: [() => \"length\"],\n    },\n    __array__: {\n        __target__: true,\n        translation: {\n            type: \"Vector3\",\n            get: (node: INode) => node._babylonTransformNode?.position,\n            set: (value: Vector3, node: INode) => node._babylonTransformNode?.position.copyFrom(value),\n            getTarget: (node: INode) => node._babylonTransformNode,\n            getPropertyName: [() => \"position\"],\n        },\n        rotation: {\n            type: \"Quaternion\",\n            get: (node: INode) => node._babylonTransformNode?.rotationQuaternion!,\n            set: (value: Quaternion, node: INode) => node._babylonTransformNode?.rotationQuaternion?.copyFrom(value),\n            getTarget: (node: INode) => node._babylonTransformNode,\n            getPropertyName: [() => \"rotationQuaternion\"],\n        },\n        scale: {\n            type: \"Vector3\",\n            get: (node: INode) => node._babylonTransformNode?.scaling,\n            set: (value: Vector3, node: INode) => node._babylonTransformNode?.scaling.copyFrom(value),\n            getTarget: (node: INode) => node._babylonTransformNode,\n            getPropertyName: [() => \"scaling\"],\n        },\n        weights: {\n            length: {\n                type: \"number\",\n                get: (node: INode) => node._numMorphTargets,\n                getTarget: (node: INode) => node._babylonTransformNode,\n                getPropertyName: [() => \"influence\"],\n            },\n            __array__: {\n                __target__: true,\n                type: \"number\",\n                get: (node: INode, index?: number) => (index !== undefined ? node._primitiveBabylonMeshes?.[0].morphTargetManager?.getTarget(index).influence : undefined),\n                // set: (value: number, node: INode, index?: number) => node._babylonTransformNode?.getMorphTargetManager()?.getTarget(index)?.setInfluence(value),\n                getTarget: (node: INode) => node._babylonTransformNode,\n                getPropertyName: [() => \"influence\"],\n            },\n            type: \"number[]\",\n            get: (node: INode, index?: number) => [0], // TODO: get the weights correctly\n            // set: (value: number, node: INode, index?: number) => node._babylonTransformNode?.getMorphTargetManager()?.getTarget(index)?.setInfluence(value),\n            getTarget: (node: INode) => node._babylonTransformNode,\n            getPropertyName: [() => \"influence\"],\n        },\n        // readonly!\n        matrix: {\n            type: \"Matrix\",\n            get: (node: INode) => Matrix.Compose(node._babylonTransformNode?.scaling!, node._babylonTransformNode?.rotationQuaternion!, node._babylonTransformNode?.position!),\n            getTarget: (node: INode) => node._babylonTransformNode,\n            isReadOnly: true,\n        },\n        globalMatrix: {\n            type: \"Matrix\",\n            get: (node: INode) => {\n                const matrix = Matrix.Identity();\n                // RHS/LHS support\n                let rootNode = node.parent;\n                while (rootNode && rootNode.parent) {\n                    rootNode = rootNode.parent;\n                }\n                const forceUpdate =\n                    node._babylonTransformNode?.position._isDirty || node._babylonTransformNode?.rotationQuaternion?._isDirty || node._babylonTransformNode?.scaling._isDirty;\n                if (rootNode) {\n                    // take the parent root node's world matrix, invert it, and multiply it with the current node's world matrix\n                    // This will provide the global matrix, ignoring the RHS->LHS conversion\n                    const rootMatrix = rootNode._babylonTransformNode?.computeWorldMatrix(true).invert();\n                    if (rootMatrix) {\n                        node._babylonTransformNode?.computeWorldMatrix(forceUpdate)?.multiplyToRef(rootMatrix, matrix);\n                    }\n                } else if (node._babylonTransformNode) {\n                    matrix.copyFrom(node._babylonTransformNode.computeWorldMatrix(forceUpdate));\n                }\n                return matrix;\n            },\n            getTarget: (node: INode) => node._babylonTransformNode,\n            isReadOnly: true,\n        },\n        extensions: {\n            EXT_lights_ies: {\n                multiplier: {\n                    type: \"number\",\n                    get: (node: INode) => {\n                        return node._babylonTransformNode?.getChildren((child) => child instanceof SpotLight, true)[0]?.intensity;\n                    },\n                    getTarget: (node: INode) => node._babylonTransformNode?.getChildren((child) => child instanceof SpotLight, true)[0],\n                    set: (value, node) => {\n                        if (node._babylonTransformNode) {\n                            const light = node._babylonTransformNode.getChildren((child) => child instanceof SpotLight, true)[0];\n                            if (light) {\n                                light.intensity = value;\n                            }\n                        }\n                    },\n                },\n                color: {\n                    type: \"Color3\",\n                    get: (node: INode) => {\n                        return node._babylonTransformNode?.getChildren((child) => child instanceof SpotLight, true)[0]?.diffuse;\n                    },\n                    getTarget: (node: INode) => node._babylonTransformNode?.getChildren((child) => child instanceof SpotLight, true)[0],\n                    set: (value, node: INode) => {\n                        if (node._babylonTransformNode) {\n                            const light = node._babylonTransformNode.getChildren((child) => child instanceof SpotLight, true)[0];\n                            if (light) {\n                                light.diffuse = value;\n                            }\n                        }\n                    },\n                },\n            },\n        },\n    },\n};\n\nconst animationsTree = {\n    length: {\n        type: \"number\",\n        get: (animations: IAnimation[]) => animations.length,\n        getTarget: (animations: IAnimation[]) => animations.map((animation) => animation._babylonAnimationGroup!),\n        getPropertyName: [() => \"length\"],\n    },\n    __array__: {},\n};\n\nconst meshesTree = {\n    length: {\n        type: \"number\",\n        get: (meshes: IMesh[]) => meshes.length,\n        getTarget: (meshes: IMesh[]) => meshes.map((mesh) => mesh.primitives[0]._instanceData?.babylonSourceMesh),\n        getPropertyName: [() => \"length\"],\n    },\n    __array__: {},\n};\n\nconst camerasTree: IGLTFObjectModelTreeCamerasObject = {\n    __array__: {\n        __target__: true,\n        orthographic: {\n            xmag: {\n                componentsCount: 2,\n                type: \"Vector2\",\n                get: (camera) => new Vector2(camera._babylonCamera?.orthoLeft ?? 0, camera._babylonCamera?.orthoRight ?? 0),\n                set: (value, camera) => {\n                    if (camera._babylonCamera) {\n                        camera._babylonCamera.orthoLeft = value.x;\n                        camera._babylonCamera.orthoRight = value.y;\n                    }\n                },\n                getTarget: (camera) => camera,\n                getPropertyName: [() => \"orthoLeft\", () => \"orthoRight\"],\n            },\n            ymag: {\n                componentsCount: 2,\n                type: \"Vector2\",\n                get: (camera: ICamera) => new Vector2(camera._babylonCamera?.orthoBottom ?? 0, camera._babylonCamera?.orthoTop ?? 0),\n                set: (value: Vector2, camera: ICamera) => {\n                    if (camera._babylonCamera) {\n                        camera._babylonCamera.orthoBottom = value.x;\n                        camera._babylonCamera.orthoTop = value.y;\n                    }\n                },\n                getTarget: (camera) => camera,\n                getPropertyName: [() => \"orthoBottom\", () => \"orthoTop\"],\n            },\n            zfar: {\n                type: \"number\",\n                get: (camera: ICamera) => camera._babylonCamera?.maxZ,\n                set: (value: number, camera: ICamera) => {\n                    if (camera._babylonCamera) {\n                        camera._babylonCamera.maxZ = value;\n                    }\n                },\n                getTarget: (camera: ICamera) => camera,\n                getPropertyName: [() => \"maxZ\"],\n            },\n            znear: {\n                type: \"number\",\n                get: (camera: ICamera) => camera._babylonCamera?.minZ,\n                set: (value: number, camera: ICamera) => {\n                    if (camera._babylonCamera) {\n                        camera._babylonCamera.minZ = value;\n                    }\n                },\n                getTarget: (camera: ICamera) => camera,\n                getPropertyName: [() => \"minZ\"],\n            },\n        },\n        perspective: {\n            aspectRatio: {\n                type: \"number\",\n                get: (camera: ICamera) => camera._babylonCamera?.getEngine().getAspectRatio(camera._babylonCamera),\n                getTarget: (camera: ICamera) => camera,\n                getPropertyName: [() => \"aspectRatio\"],\n                isReadOnly: true, // might not be the case for glTF?\n            },\n            yfov: {\n                type: \"number\",\n                get: (camera: ICamera) => camera._babylonCamera?.fov,\n                set: (value: number, camera: ICamera) => {\n                    if (camera._babylonCamera) {\n                        camera._babylonCamera.fov = value;\n                    }\n                },\n                getTarget: (camera: ICamera) => camera,\n                getPropertyName: [() => \"fov\"],\n            },\n            zfar: {\n                type: \"number\",\n                get: (camera: ICamera) => camera._babylonCamera?.maxZ,\n                set: (value: number, camera: ICamera) => {\n                    if (camera._babylonCamera) {\n                        camera._babylonCamera.maxZ = value;\n                    }\n                },\n                getTarget: (camera: ICamera) => camera,\n                getPropertyName: [() => \"maxZ\"],\n            },\n            znear: {\n                type: \"number\",\n                get: (camera: ICamera) => camera._babylonCamera?.minZ,\n                set: (value: number, camera: ICamera) => {\n                    if (camera._babylonCamera) {\n                        camera._babylonCamera.minZ = value;\n                    }\n                },\n                getTarget: (camera: ICamera) => camera,\n                getPropertyName: [() => \"minZ\"],\n            },\n        },\n    },\n};\n\nconst materialsTree: IGLTFObjectModelTreeMaterialsObject = {\n    __array__: {\n        __target__: true,\n        emissiveFactor: {\n            type: \"Color3\",\n            get: (material, index?, payload?) => GetMaterial(material, index, payload).emissiveColor,\n            set: (value: Color3, material, index?, payload?) => GetMaterial(material, index, payload).emissiveColor.copyFrom(value),\n            getTarget: (material, index?, payload?) => GetMaterial(material, index, payload),\n            getPropertyName: [() => \"emissiveColor\"],\n        },\n        emissiveTexture: {\n            extensions: {\n                KHR_texture_transform: GenerateTextureMap(\"emissiveTexture\"),\n            },\n        },\n        normalTexture: {\n            scale: {\n                type: \"number\",\n                get: (material, index?, payload?) => GetTexture(material, payload, \"bumpTexture\")?.level,\n                set: (value: number, material, index?, payload?) => {\n                    const texture = GetTexture(material, payload, \"bumpTexture\");\n                    if (texture) {\n                        texture.level = value;\n                    }\n                },\n                getTarget: (material, index?, payload?) => GetMaterial(material, index, payload),\n                getPropertyName: [() => \"level\"],\n            },\n            extensions: {\n                KHR_texture_transform: GenerateTextureMap(\"bumpTexture\"),\n            },\n        },\n        occlusionTexture: {\n            strength: {\n                type: \"number\",\n                get: (material, index?, payload?) => GetMaterial(material, index, payload).ambientTextureStrength,\n                set: (value: number, material, index?, payload?) => {\n                    const mat = GetMaterial(material, index, payload);\n                    if (mat) {\n                        mat.ambientTextureStrength = value;\n                    }\n                },\n                getTarget: (material, index?, payload?) => GetMaterial(material, index, payload),\n                getPropertyName: [() => \"ambientTextureStrength\"],\n            },\n            extensions: {\n                KHR_texture_transform: GenerateTextureMap(\"ambientTexture\"),\n            },\n        },\n        pbrMetallicRoughness: {\n            baseColorFactor: {\n                type: \"Color4\",\n                get: (material, index?, payload?) => {\n                    const mat = GetMaterial(material, index, payload);\n                    return Color4.FromColor3(mat.albedoColor, mat.alpha);\n                },\n                set: (value: Color4, material, index?, payload?) => {\n                    const mat = GetMaterial(material, index, payload);\n                    mat.albedoColor.set(value.r, value.g, value.b);\n                    mat.alpha = value.a;\n                },\n                getTarget: (material, index?, payload?) => GetMaterial(material, index, payload),\n                // This is correct on the animation level, but incorrect as a single property of a type Color4\n                getPropertyName: [() => \"albedoColor\", () => \"alpha\"],\n            },\n            baseColorTexture: {\n                extensions: {\n                    KHR_texture_transform: GenerateTextureMap(\"albedoTexture\"),\n                },\n            },\n            metallicFactor: {\n                type: \"number\",\n                get: (material, index?, payload?) => GetMaterial(material, index, payload).metallic,\n                set: (value, material, index?, payload?) => {\n                    const mat = GetMaterial(material, index, payload);\n                    if (mat) {\n                        mat.metallic = value;\n                    }\n                },\n                getTarget: (material, index?, payload?) => GetMaterial(material, index, payload),\n                getPropertyName: [() => \"metallic\"],\n            },\n            roughnessFactor: {\n                type: \"number\",\n                get: (material, index?, payload?) => GetMaterial(material, index, payload).roughness,\n                set: (value, material, index?, payload?) => {\n                    const mat = GetMaterial(material, index, payload);\n                    if (mat) {\n                        mat.roughness = value;\n                    }\n                },\n                getTarget: (material, index?, payload?) => GetMaterial(material, index, payload),\n                getPropertyName: [() => \"roughness\"],\n            },\n            metallicRoughnessTexture: {\n                extensions: {\n                    KHR_texture_transform: GenerateTextureMap(\"metallicTexture\"),\n                },\n            },\n        },\n        extensions: {\n            KHR_materials_anisotropy: {\n                anisotropyStrength: {\n                    type: \"number\",\n                    get: (material, index?, payload?) => GetMaterial(material, index, payload).anisotropy.intensity,\n                    set: (value: number, material, index?, payload?) => {\n                        GetMaterial(material, index, payload).anisotropy.intensity = value;\n                    },\n                    getTarget: (material, index?, payload?) => GetMaterial(material, index, payload),\n                    getPropertyName: [() => \"anisotropy.intensity\"],\n                },\n                anisotropyRotation: {\n                    type: \"number\",\n                    get: (material, index?, payload?) => GetMaterial(material, index, payload).anisotropy.angle,\n                    set: (value: number, material, index?, payload?) => {\n                        GetMaterial(material, index, payload).anisotropy.angle = value;\n                    },\n                    getTarget: (material, index?, payload?) => GetMaterial(material, index, payload),\n                    getPropertyName: [() => \"anisotropy.angle\"],\n                },\n                anisotropyTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"anisotropy\", \"texture\"),\n                    },\n                },\n            },\n            KHR_materials_clearcoat: {\n                clearcoatFactor: {\n                    type: \"number\",\n                    get: (material, index?, payload?) => GetMaterial(material, index, payload).clearCoat.intensity,\n                    set: (value, material, index?, payload?) => {\n                        GetMaterial(material, index, payload).clearCoat.intensity = value;\n                    },\n                    getTarget: (material, index?, payload?) => GetMaterial(material, index, payload),\n                    getPropertyName: [() => \"clearCoat.intensity\"],\n                },\n                clearcoatRoughnessFactor: {\n                    type: \"number\",\n                    get: (material, index?, payload?) => GetMaterial(material, index, payload).clearCoat.roughness,\n                    set: (value, material, index?, payload?) => {\n                        GetMaterial(material, index, payload).clearCoat.roughness = value;\n                    },\n                    getTarget: (material, index?, payload?) => GetMaterial(material, index, payload),\n                    getPropertyName: [() => \"clearCoat.roughness\"],\n                },\n                clearcoatTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"clearCoat\", \"texture\"),\n                    },\n                },\n                clearcoatNormalTexture: {\n                    scale: {\n                        type: \"number\",\n                        get: (material, index, payload) => GetMaterial(material, index, payload).clearCoat.bumpTexture?.level,\n                        getTarget: GetMaterial,\n                        set: (value, material, index, payload) => (GetMaterial(material, index, payload).clearCoat.bumpTexture!.level = value),\n                    },\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"clearCoat\", \"bumpTexture\"),\n                    },\n                },\n                clearcoatRoughnessTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"clearCoat\", \"textureRoughness\"),\n                    },\n                },\n            },\n            KHR_materials_dispersion: {\n                dispersion: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).subSurface.dispersion,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).subSurface.dispersion = value),\n                },\n            },\n            KHR_materials_emissive_strength: {\n                emissiveStrength: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).emissiveIntensity,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).emissiveIntensity = value),\n                },\n            },\n            KHR_materials_ior: {\n                ior: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).indexOfRefraction,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).indexOfRefraction = value),\n                },\n            },\n            KHR_materials_iridescence: {\n                iridescenceFactor: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).iridescence.intensity,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).iridescence.intensity = value),\n                },\n                iridescenceIor: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).iridescence.indexOfRefraction,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).iridescence.indexOfRefraction = value),\n                },\n                iridescenceTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"iridescence\", \"texture\"),\n                    },\n                },\n                iridescenceThicknessMaximum: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).iridescence.maximumThickness,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).iridescence.maximumThickness = value),\n                },\n                iridescenceThicknessMinimum: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).iridescence.minimumThickness,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).iridescence.minimumThickness = value),\n                },\n                iridescenceThicknessTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"iridescence\", \"thicknessTexture\"),\n                    },\n                },\n            },\n            KHR_materials_sheen: {\n                sheenColorFactor: {\n                    type: \"Color3\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).sheen.color,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => GetMaterial(material, index, payload).sheen.color.copyFrom(value),\n                },\n                sheenColorTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"sheen\", \"texture\"),\n                    },\n                },\n                sheenRoughnessFactor: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).sheen.intensity,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).sheen.intensity = value),\n                },\n                sheenRoughnessTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"sheen\", \"thicknessTexture\"),\n                    },\n                },\n            },\n            KHR_materials_specular: {\n                specularFactor: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).metallicF0Factor,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).metallicF0Factor = value),\n                    getPropertyName: [() => \"metallicF0Factor\"],\n                },\n                specularColorFactor: {\n                    type: \"Color3\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).metallicReflectanceColor,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => GetMaterial(material, index, payload).metallicReflectanceColor.copyFrom(value),\n                    getPropertyName: [() => \"metallicReflectanceColor\"],\n                },\n                specularTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"metallicReflectanceTexture\"),\n                    },\n                },\n                specularColorTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"reflectanceTexture\"),\n                    },\n                },\n            },\n            KHR_materials_transmission: {\n                transmissionFactor: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).subSurface.refractionIntensity,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).subSurface.refractionIntensity = value),\n                    getPropertyName: [() => \"subSurface.refractionIntensity\"],\n                },\n                transmissionTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"subSurface\", \"refractionIntensityTexture\"),\n                    },\n                },\n            },\n            KHR_materials_diffuse_transmission: {\n                diffuseTransmissionFactor: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).subSurface.translucencyIntensity,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).subSurface.translucencyIntensity = value),\n                },\n                diffuseTransmissionTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"subSurface\", \"translucencyIntensityTexture\"),\n                    },\n                },\n                diffuseTransmissionColorFactor: {\n                    type: \"Color3\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).subSurface.translucencyColor,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => value && GetMaterial(material, index, payload).subSurface.translucencyColor?.copyFrom(value),\n                },\n                diffuseTransmissionColorTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"subSurface\", \"translucencyColorTexture\"),\n                    },\n                },\n            },\n            KHR_materials_volume: {\n                attenuationColor: {\n                    type: \"Color3\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).subSurface.tintColor,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => GetMaterial(material, index, payload).subSurface.tintColor.copyFrom(value),\n                },\n                attenuationDistance: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).subSurface.tintColorAtDistance,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).subSurface.tintColorAtDistance = value),\n                },\n                thicknessFactor: {\n                    type: \"number\",\n                    get: (material, index, payload) => GetMaterial(material, index, payload).subSurface.maximumThickness,\n                    getTarget: GetMaterial,\n                    set: (value, material, index, payload) => (GetMaterial(material, index, payload).subSurface.maximumThickness = value),\n                },\n                thicknessTexture: {\n                    extensions: {\n                        KHR_texture_transform: GenerateTextureMap(\"subSurface\", \"thicknessTexture\"),\n                    },\n                },\n            },\n        },\n    },\n};\n\nconst extensionsTree: IGLTFObjectModelTreeExtensionsObject = {\n    KHR_lights_punctual: {\n        lights: {\n            length: {\n                type: \"number\",\n                get: (lights: IKHRLightsPunctual_Light[]) => lights.length,\n                getTarget: (lights: IKHRLightsPunctual_Light[]) => lights.map((light) => light._babylonLight!),\n                getPropertyName: [(_lights: IKHRLightsPunctual_Light[]) => \"length\"],\n            },\n            __array__: {\n                __target__: true,\n                color: {\n                    type: \"Color3\",\n                    get: (light: IKHRLightsPunctual_Light) => light._babylonLight?.diffuse,\n                    set: (value: Color3, light: IKHRLightsPunctual_Light) => light._babylonLight?.diffuse.copyFrom(value),\n                    getTarget: (light: IKHRLightsPunctual_Light) => light._babylonLight,\n                    getPropertyName: [(_light: IKHRLightsPunctual_Light) => \"diffuse\"],\n                },\n                intensity: {\n                    type: \"number\",\n                    get: (light: IKHRLightsPunctual_Light) => light._babylonLight?.intensity,\n                    set: (value: number, light: IKHRLightsPunctual_Light) => (light._babylonLight ? (light._babylonLight.intensity = value) : undefined),\n                    getTarget: (light: IKHRLightsPunctual_Light) => light._babylonLight,\n                    getPropertyName: [(_light: IKHRLightsPunctual_Light) => \"intensity\"],\n                },\n                range: {\n                    type: \"number\",\n                    get: (light: IKHRLightsPunctual_Light) => light._babylonLight?.range,\n                    set: (value: number, light: IKHRLightsPunctual_Light) => (light._babylonLight ? (light._babylonLight.range = value) : undefined),\n                    getTarget: (light: IKHRLightsPunctual_Light) => light._babylonLight,\n                    getPropertyName: [(_light: IKHRLightsPunctual_Light) => \"range\"],\n                },\n                spot: {\n                    innerConeAngle: {\n                        type: \"number\",\n                        get: (light: IKHRLightsPunctual_Light) => (light._babylonLight as SpotLight)?.innerAngle,\n                        set: (value: number, light: IKHRLightsPunctual_Light) => (light._babylonLight ? ((light._babylonLight as SpotLight).innerAngle = value) : undefined),\n                        getTarget: (light: IKHRLightsPunctual_Light) => light._babylonLight,\n                        getPropertyName: [(_light: IKHRLightsPunctual_Light) => \"innerConeAngle\"],\n                    },\n                    outerConeAngle: {\n                        type: \"number\",\n                        get: (light: IKHRLightsPunctual_Light) => (light._babylonLight as SpotLight)?.angle,\n                        set: (value: number, light: IKHRLightsPunctual_Light) => (light._babylonLight ? ((light._babylonLight as SpotLight).angle = value) : undefined),\n                        getTarget: (light: IKHRLightsPunctual_Light) => light._babylonLight,\n                        getPropertyName: [(_light: IKHRLightsPunctual_Light) => \"outerConeAngle\"],\n                    },\n                },\n            },\n        },\n    },\n    EXT_lights_ies: {\n        lights: {\n            length: {\n                type: \"number\",\n                get: (lights: IKHRLightsPunctual_Light[]) => lights.length,\n                getTarget: (lights: IKHRLightsPunctual_Light[]) => lights.map((light) => light._babylonLight!),\n                getPropertyName: [(_lights: IKHRLightsPunctual_Light[]) => \"length\"],\n            },\n        },\n    },\n    EXT_lights_image_based: {\n        lights: {\n            length: {\n                type: \"number\",\n                get: (lights) => lights.length,\n                getTarget: (lights) => lights.map((light) => light._babylonTexture!),\n                getPropertyName: [(_lights) => \"length\"],\n            },\n            __array__: {\n                __target__: true,\n                intensity: {\n                    type: \"number\",\n                    get: (light) => light._babylonTexture?.level,\n                    set: (value, light) => {\n                        if (light._babylonTexture) {\n                            light._babylonTexture.level = value;\n                        }\n                    },\n\n                    getTarget: (light) => light._babylonTexture,\n                },\n                rotation: {\n                    type: \"Quaternion\",\n                    get: (light) => light._babylonTexture && Quaternion.FromRotationMatrix(light._babylonTexture?.getReflectionTextureMatrix()),\n                    set: (value, light) => {\n                        if (!light._babylonTexture) {\n                            return;\n                        }\n                        // Invert the rotation so that positive rotation is counter-clockwise.\n                        if (!light._babylonTexture.getScene()?.useRightHandedSystem) {\n                            value = Quaternion.Inverse(value);\n                        }\n\n                        Matrix.FromQuaternionToRef(value, light._babylonTexture.getReflectionTextureMatrix());\n                    },\n                    getTarget: (light) => light._babylonTexture,\n                },\n            },\n        },\n    },\n};\n\nfunction GetTexture(material: IMaterial, payload: any, textureType: keyof PBRMaterial, textureInObject?: string) {\n    const babylonMaterial = GetMaterial(material, payload);\n    return textureInObject ? babylonMaterial[textureType][textureInObject] : babylonMaterial[textureType];\n}\nfunction GetMaterial(material: IMaterial, _index?: number, payload?: any) {\n    return material._data?.[payload?.fillMode ?? Constants.MATERIAL_TriangleFillMode]?.babylonMaterial as PBRMaterial;\n}\nfunction GenerateTextureMap(textureType: keyof PBRMaterial, textureInObject?: string): ITextureDefinition {\n    return {\n        offset: {\n            componentsCount: 2,\n            // assuming two independent values for u and v, and NOT a Vector2\n            type: \"Vector2\",\n            get: (material, _index?, payload?) => {\n                const texture = GetTexture(material, payload, textureType, textureInObject);\n                return new Vector2(texture?.uOffset, texture?.vOffset);\n            },\n            getTarget: GetMaterial,\n            set: (value, material, _index?, payload?) => {\n                const texture = GetTexture(material, payload, textureType, textureInObject);\n                (texture.uOffset = value.x), (texture.vOffset = value.y);\n            },\n            getPropertyName: [\n                () => `${textureType}${textureInObject ? \".\" + textureInObject : \"\"}.uOffset`,\n                () => `${textureType}${textureInObject ? \".\" + textureInObject : \"\"}.vOffset`,\n            ],\n        },\n        rotation: {\n            type: \"number\",\n            get: (material, _index?, payload?) => GetTexture(material, payload, textureType, textureInObject)?.wAng,\n            getTarget: GetMaterial,\n            set: (value, material, _index?, payload?) => (GetTexture(material, payload, textureType, textureInObject).wAng = value),\n            getPropertyName: [() => `${textureType}${textureInObject ? \".\" + textureInObject : \"\"}.wAng`],\n        },\n        scale: {\n            componentsCount: 2,\n            type: \"Vector2\",\n            get: (material, _index?, payload?) => {\n                const texture = GetTexture(material, payload, textureType, textureInObject);\n                return new Vector2(texture?.uScale, texture?.vScale);\n            },\n            getTarget: GetMaterial,\n            set: (value, material, index?, payload?) => {\n                const texture = GetTexture(material, payload, textureType, textureInObject);\n                (texture.uScale = value.x), (texture.vScale = value.y);\n            },\n            getPropertyName: [\n                () => `${textureType}${textureInObject ? \".\" + textureInObject : \"\"}.uScale`,\n                () => `${textureType}${textureInObject ? \".\" + textureInObject : \"\"}.vScale`,\n            ],\n        },\n    };\n}\n\nconst objectModelMapping: IGLTFObjectModelTree = {\n    cameras: camerasTree,\n    nodes: nodesTree,\n    materials: materialsTree,\n    extensions: extensionsTree,\n    animations: animationsTree,\n    meshes: meshesTree,\n};\n\n/**\n * get a path-to-object converter for the given glTF tree\n * @param gltf the glTF tree to use\n * @returns a path-to-object converter for the given glTF tree\n */\nexport function GetPathToObjectConverter(gltf: IGLTF) {\n    return new GLTFPathToObjectConverter(gltf, objectModelMapping);\n}\n\n/**\n * This function will return the object accessor for the given key in the object model\n * If the key is not found, it will return undefined\n * @param key the key to get the mapping for, for example /materials/\\{\\}/emissiveFactor\n * @returns an object accessor for the given key, or undefined if the key is not found\n */\nexport function GetMappingForKey(key: string): IObjectAccessor | undefined {\n    // replace every `{}` in key with __array__ to match the object model\n    const keyParts = key.split(\"/\").map((part) => part.replace(/{}/g, \"__array__\"));\n    let current = objectModelMapping as any;\n    for (const part of keyParts) {\n        // make sure part is not empty\n        if (!part) {\n            continue;\n        }\n        current = current[part];\n    }\n    // validate that current is an object accessor\n    if (current && current.type && current.get) {\n        return current;\n    }\n    return undefined;\n}\n\n/**\n * Set interpolation for a specific key in the object model\n * @param key the key to set, for example /materials/\\{\\}/emissiveFactor\n * @param interpolation the interpolation elements array\n */\nexport function SetInterpolationForKey(key: string, interpolation?: IInterpolationPropertyInfo[]): void {\n    // replace every `{}` in key with __array__ to match the object model\n    const keyParts = key.split(\"/\").map((part) => part.replace(/{}/g, \"__array__\"));\n    let current = objectModelMapping as any;\n    for (const part of keyParts) {\n        // make sure part is not empty\n        if (!part) {\n            continue;\n        }\n        current = current[part];\n    }\n    // validate that the current object is an object accessor\n    if (current && current.type && current.get) {\n        (current as IObjectAccessor).interpolation = interpolation;\n    }\n}\n\n/**\n * This will ad a new object accessor in the object model at the given key.\n * Note that this will NOT change the typescript types. To do that you will need to change the interface itself (extending it in the module that uses it)\n * @param key the key to add the object accessor at. For example /cameras/\\{\\}/perspective/aspectRatio\n * @param accessor the object accessor to add\n */\nexport function AddObjectAccessorToKey<GLTFTargetType = any, BabylonTargetType = any, BabylonValueType = any>(\n    key: string,\n    accessor: IObjectAccessor<GLTFTargetType, BabylonTargetType, BabylonValueType>\n): void {\n    // replace every `{}` in key with __array__ to match the object model\n    const keyParts = key.split(\"/\").map((part) => part.replace(/{}/g, \"__array__\"));\n    let current = objectModelMapping as any;\n    for (const part of keyParts) {\n        // make sure part is not empty\n        if (!part) {\n            continue;\n        }\n        if (!current[part]) {\n            if (part === \"?\") {\n                current.__ignoreObjectTree__ = true;\n                continue;\n            }\n            current[part] = {};\n            // if the part is __array__ then add the __target__ property\n            if (part === \"__array__\") {\n                current[part].__target__ = true;\n            }\n        }\n        current = current[part];\n    }\n    Object.assign(current, accessor);\n}\n","import { Animation } from \"core/Animations/animation\";\r\nimport { Quaternion, Vector3 } from \"core/Maths/math.vector\";\r\nimport type { INode } from \"./glTFLoaderInterfaces\";\r\nimport type { IAnimatable } from \"core/Animations/animatable.interface\";\r\nimport { SetInterpolationForKey } from \"./Extensions/objectModelMapping\";\r\n\r\n/** @internal */\r\nexport type GetValueFn = (target: any, source: Float32Array, offset: number, scale: number) => any;\r\n\r\n/** @internal */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport function getVector3(_target: any, source: Float32Array, offset: number, scale: number): Vector3 {\r\n    return Vector3.FromArray(source, offset).scaleInPlace(scale);\r\n}\r\n\r\n/** @internal */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport function getQuaternion(_target: any, source: Float32Array, offset: number, scale: number): Quaternion {\r\n    return Quaternion.FromArray(source, offset).scaleInPlace(scale);\r\n}\r\n\r\n/** @internal */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport function getWeights(target: INode, source: Float32Array, offset: number, scale: number): Array<number> {\r\n    const value = new Array<number>(target._numMorphTargets!);\r\n    for (let i = 0; i < value.length; i++) {\r\n        value[i] = source[offset++] * scale;\r\n    }\r\n\r\n    return value;\r\n}\r\n\r\n/** @internal */\r\nexport abstract class AnimationPropertyInfo {\r\n    /** @internal */\r\n    public constructor(\r\n        public readonly type: number,\r\n        public readonly name: string,\r\n        public readonly getValue: GetValueFn,\r\n        public readonly getStride: (target: any) => number\r\n    ) {}\r\n\r\n    protected _buildAnimation(name: string, fps: number, keys: any[]): Animation {\r\n        const babylonAnimation = new Animation(name, this.name, fps, this.type);\r\n        babylonAnimation.setKeys(keys);\r\n        return babylonAnimation;\r\n    }\r\n\r\n    /** @internal */\r\n    public abstract buildAnimations(target: any, name: string, fps: number, keys: any[]): { babylonAnimatable: IAnimatable; babylonAnimation: Animation }[];\r\n}\r\n\r\n/** @internal */\r\nexport class TransformNodeAnimationPropertyInfo extends AnimationPropertyInfo {\r\n    /** @internal */\r\n    public buildAnimations(target: INode, name: string, fps: number, keys: any[]) {\r\n        const babylonAnimations: { babylonAnimatable: IAnimatable; babylonAnimation: Animation }[] = [];\r\n        babylonAnimations.push({ babylonAnimatable: target._babylonTransformNode!, babylonAnimation: this._buildAnimation(name, fps, keys) });\r\n        return babylonAnimations;\r\n    }\r\n}\r\n\r\n/** @internal */\r\nexport class WeightAnimationPropertyInfo extends AnimationPropertyInfo {\r\n    public buildAnimations(target: INode, name: string, fps: number, keys: any[]) {\r\n        const babylonAnimations: { babylonAnimatable: IAnimatable; babylonAnimation: Animation }[] = [];\r\n        if (target._numMorphTargets) {\r\n            for (let targetIndex = 0; targetIndex < target._numMorphTargets; targetIndex++) {\r\n                const babylonAnimation = new Animation(`${name}_${targetIndex}`, this.name, fps, this.type);\r\n                babylonAnimation.setKeys(\r\n                    keys.map((key) => ({\r\n                        frame: key.frame,\r\n                        inTangent: key.inTangent ? key.inTangent[targetIndex] : undefined,\r\n                        value: key.value[targetIndex],\r\n                        outTangent: key.outTangent ? key.outTangent[targetIndex] : undefined,\r\n                        interpolation: key.interpolation,\r\n                    }))\r\n                );\r\n\r\n                if (target._primitiveBabylonMeshes) {\r\n                    for (const babylonMesh of target._primitiveBabylonMeshes) {\r\n                        if (babylonMesh.morphTargetManager) {\r\n                            const morphTarget = babylonMesh.morphTargetManager.getTarget(targetIndex);\r\n                            const babylonAnimationClone = babylonAnimation.clone();\r\n                            morphTarget.animations.push(babylonAnimationClone);\r\n                            babylonAnimations.push({ babylonAnimatable: morphTarget, babylonAnimation: babylonAnimationClone });\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        return babylonAnimations;\r\n    }\r\n}\r\n\r\nSetInterpolationForKey(\"/nodes/{}/translation\", [new TransformNodeAnimationPropertyInfo(Animation.ANIMATIONTYPE_VECTOR3, \"position\", getVector3, () => 3)]);\r\nSetInterpolationForKey(\"/nodes/{}/rotation\", [new TransformNodeAnimationPropertyInfo(Animation.ANIMATIONTYPE_QUATERNION, \"rotationQuaternion\", getQuaternion, () => 4)]);\r\nSetInterpolationForKey(\"/nodes/{}/scale\", [new TransformNodeAnimationPropertyInfo(Animation.ANIMATIONTYPE_VECTOR3, \"scaling\", getVector3, () => 3)]);\r\nSetInterpolationForKey(\"/nodes/{}/weights\", [new WeightAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"influence\", getWeights, (target) => target._numMorphTargets!)]);\r\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","/* eslint-disable github/no-then */\r\n/* eslint-disable no-restricted-syntax */\r\n/* eslint-disable @typescript-eslint/promise-function-async */\r\nimport type * as GLTF2 from \"babylonjs-gltf2interface\";\r\nimport { Tools } from \"core/Misc/tools\";\r\n\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\ndeclare let GLTFValidator: GLTF2.IGLTFValidator;\r\n\r\n// WorkerGlobalScope\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\ndeclare function importScripts(...urls: string[]): void;\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\ndeclare function postMessage(message: any, transfer?: any[]): void;\r\n\r\nfunction ValidateAsync(\r\n    data: string | Uint8Array,\r\n    rootUrl: string,\r\n    fileName: string,\r\n    getExternalResource: (uri: string) => Promise<Uint8Array>\r\n): Promise<GLTF2.IGLTFValidationResults> {\r\n    const options: GLTF2.IGLTFValidationOptions = {\r\n        externalResourceFunction: getExternalResource,\r\n    };\r\n\r\n    if (fileName) {\r\n        options.uri = rootUrl === \"file:\" ? fileName : rootUrl + fileName;\r\n    }\r\n\r\n    return ArrayBuffer.isView(data) ? GLTFValidator.validateBytes(data, options) : GLTFValidator.validateString(data, options);\r\n}\r\n\r\n/**\r\n * The worker function that gets converted to a blob url to pass into a worker.\r\n */\r\nfunction WorkerFunc(): void {\r\n    const pendingExternalResources: Array<{ resolve: (data: any) => void; reject: (reason: any) => void }> = [];\r\n\r\n    onmessage = (message) => {\r\n        const data = message.data;\r\n        switch (data.id) {\r\n            case \"init\": {\r\n                importScripts(data.url);\r\n                break;\r\n            }\r\n            case \"validate\": {\r\n                ValidateAsync(\r\n                    data.data,\r\n                    data.rootUrl,\r\n                    data.fileName,\r\n                    (uri) =>\r\n                        new Promise((resolve, reject) => {\r\n                            const index = pendingExternalResources.length;\r\n                            pendingExternalResources.push({ resolve, reject });\r\n                            postMessage({ id: \"getExternalResource\", index: index, uri: uri });\r\n                        })\r\n                ).then(\r\n                    (value) => {\r\n                        postMessage({ id: \"validate.resolve\", value: value });\r\n                    },\r\n                    (reason) => {\r\n                        postMessage({ id: \"validate.reject\", reason: reason });\r\n                    }\r\n                );\r\n                break;\r\n            }\r\n            case \"getExternalResource.resolve\": {\r\n                pendingExternalResources[data.index].resolve(data.value);\r\n                break;\r\n            }\r\n            case \"getExternalResource.reject\": {\r\n                pendingExternalResources[data.index].reject(data.reason);\r\n                break;\r\n            }\r\n        }\r\n    };\r\n}\r\n\r\n/**\r\n * Configuration for glTF validation\r\n */\r\nexport interface IGLTFValidationConfiguration {\r\n    /**\r\n     * The url of the glTF validator.\r\n     */\r\n    url: string;\r\n}\r\n\r\n/**\r\n * glTF validation\r\n */\r\nexport class GLTFValidation {\r\n    /**\r\n     * The configuration. Defaults to `{ url: \"https://cdn.babylonjs.com/gltf_validator.js\" }`.\r\n     */\r\n    public static Configuration: IGLTFValidationConfiguration = {\r\n        url: `${Tools._DefaultCdnUrl}/gltf_validator.js`,\r\n    };\r\n\r\n    private static _LoadScriptPromise: Promise<void>;\r\n\r\n    /**\r\n     * Validate a glTF asset using the glTF-Validator.\r\n     * @param data The JSON of a glTF or the array buffer of a binary glTF\r\n     * @param rootUrl The root url for the glTF\r\n     * @param fileName The file name for the glTF\r\n     * @param getExternalResource The callback to get external resources for the glTF validator\r\n     * @returns A promise that resolves with the glTF validation results once complete\r\n     */\r\n    public static ValidateAsync(\r\n        data: string | Uint8Array,\r\n        rootUrl: string,\r\n        fileName: string,\r\n        getExternalResource: (uri: string) => Promise<Uint8Array>\r\n    ): Promise<GLTF2.IGLTFValidationResults> {\r\n        if (typeof Worker === \"function\") {\r\n            return new Promise((resolve, reject) => {\r\n                const workerContent = `${ValidateAsync}(${WorkerFunc})()`;\r\n                const workerBlobUrl = URL.createObjectURL(new Blob([workerContent], { type: \"application/javascript\" }));\r\n                const worker = new Worker(workerBlobUrl);\r\n\r\n                const onError = (error: ErrorEvent) => {\r\n                    worker.removeEventListener(\"error\", onError);\r\n                    worker.removeEventListener(\"message\", onMessage);\r\n                    // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors\r\n                    reject(error);\r\n                };\r\n\r\n                const onMessage = (message: MessageEvent) => {\r\n                    const data = message.data;\r\n                    switch (data.id) {\r\n                        case \"getExternalResource\": {\r\n                            getExternalResource(data.uri).then(\r\n                                (value) => {\r\n                                    worker.postMessage({ id: \"getExternalResource.resolve\", index: data.index, value: value }, [value.buffer]);\r\n                                },\r\n                                (reason) => {\r\n                                    worker.postMessage({ id: \"getExternalResource.reject\", index: data.index, reason: reason });\r\n                                }\r\n                            );\r\n                            break;\r\n                        }\r\n                        case \"validate.resolve\": {\r\n                            worker.removeEventListener(\"error\", onError);\r\n                            worker.removeEventListener(\"message\", onMessage);\r\n                            resolve(data.value);\r\n                            worker.terminate();\r\n                            break;\r\n                        }\r\n                        case \"validate.reject\": {\r\n                            worker.removeEventListener(\"error\", onError);\r\n                            worker.removeEventListener(\"message\", onMessage);\r\n                            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors\r\n                            reject(data.reason);\r\n                            worker.terminate();\r\n                        }\r\n                    }\r\n                };\r\n\r\n                worker.addEventListener(\"error\", onError);\r\n                worker.addEventListener(\"message\", onMessage);\r\n\r\n                worker.postMessage({ id: \"init\", url: Tools.GetBabylonScriptURL(this.Configuration.url) });\r\n\r\n                if (ArrayBuffer.isView(data)) {\r\n                    // Slice the data to avoid copying the whole array buffer.\r\n                    const slicedData = data.slice();\r\n                    worker.postMessage({ id: \"validate\", data: slicedData, rootUrl: rootUrl, fileName: fileName }, [slicedData.buffer]);\r\n                } else {\r\n                    worker.postMessage({ id: \"validate\", data: data, rootUrl: rootUrl, fileName: fileName });\r\n                }\r\n            });\r\n        } else {\r\n            if (!this._LoadScriptPromise) {\r\n                this._LoadScriptPromise = Tools.LoadBabylonScriptAsync(this.Configuration.url);\r\n            }\r\n\r\n            return this._LoadScriptPromise.then(() => {\r\n                return ValidateAsync(data, rootUrl, fileName, getExternalResource);\r\n            });\r\n        }\r\n    }\r\n}\r\n","/* eslint-disable github/no-then */\r\n/* eslint-disable @typescript-eslint/no-floating-promises */\r\n/* eslint-disable @typescript-eslint/prefer-promise-reject-errors */\r\n/* eslint-disable no-restricted-syntax */\r\n/* eslint-disable @typescript-eslint/promise-function-async */\r\n/* eslint-disable @typescript-eslint/no-unused-vars */\r\n/* eslint-disable @typescript-eslint/naming-convention */\r\nimport type * as GLTF2 from \"babylonjs-gltf2interface\";\r\nimport type { Nullable } from \"core/types\";\r\nimport type { Observer } from \"core/Misc/observable\";\r\nimport { Observable } from \"core/Misc/observable\";\r\nimport { Tools } from \"core/Misc/tools\";\r\nimport type { Camera } from \"core/Cameras/camera\";\r\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\r\nimport type { Material } from \"core/Materials/material\";\r\nimport type { AbstractMesh } from \"core/Meshes/abstractMesh\";\r\nimport type { ISceneLoaderPluginFactory, ISceneLoaderPluginAsync, ISceneLoaderProgressEvent, ISceneLoaderAsyncResult, SceneLoaderPluginOptions } from \"core/Loading/sceneLoader\";\r\nimport { RegisterSceneLoaderPlugin } from \"core/Loading/sceneLoader\";\r\nimport { AssetContainer } from \"core/assetContainer\";\r\nimport type { Scene, IDisposable } from \"core/scene\";\r\nimport type { WebRequest } from \"core/Misc/webRequest\";\r\nimport type { IFileRequest } from \"core/Misc/fileRequest\";\r\nimport { Logger } from \"core/Misc/logger\";\r\nimport type { IDataBuffer } from \"core/Misc/dataReader\";\r\nimport { DataReader } from \"core/Misc/dataReader\";\r\nimport { GLTFValidation } from \"./glTFValidation\";\r\nimport { GLTFFileLoaderMetadata, GLTFMagicBase64Encoded } from \"./glTFFileLoader.metadata\";\r\nimport type { LoadFileError } from \"core/Misc/fileTools\";\r\nimport { DecodeBase64UrlToBinary } from \"core/Misc/fileTools\";\r\nimport { RuntimeError, ErrorCodes } from \"core/Misc/error\";\r\nimport type { TransformNode } from \"core/Meshes/transformNode\";\r\nimport type { MorphTargetManager } from \"core/Morph/morphTargetManager\";\r\n\r\n/**\r\n * Defines options for glTF loader extensions. This interface is extended by specific extensions.\r\n */\r\nexport interface GLTFLoaderExtensionOptions extends Record<string, Record<string, unknown> | undefined> {}\r\n\r\ndeclare module \"core/Loading/sceneLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc\r\n    export interface SceneLoaderPluginOptions {\r\n        /**\r\n         * Defines options for the glTF loader.\r\n         */\r\n        [GLTFFileLoaderMetadata.name]: Partial<GLTFLoaderOptions>;\r\n    }\r\n}\r\n\r\ninterface IFileRequestInfo extends IFileRequest {\r\n    _lengthComputable?: boolean;\r\n    _loaded?: number;\r\n    _total?: number;\r\n}\r\n\r\nfunction readAsync(arrayBuffer: ArrayBuffer, byteOffset: number, byteLength: number): Promise<Uint8Array> {\r\n    try {\r\n        return Promise.resolve(new Uint8Array(arrayBuffer, byteOffset, byteLength));\r\n    } catch (e) {\r\n        return Promise.reject(e);\r\n    }\r\n}\r\n\r\nfunction readViewAsync(arrayBufferView: ArrayBufferView, byteOffset: number, byteLength: number): Promise<Uint8Array> {\r\n    try {\r\n        if (byteOffset < 0 || byteOffset >= arrayBufferView.byteLength) {\r\n            throw new RangeError(\"Offset is out of range.\");\r\n        }\r\n\r\n        if (byteOffset + byteLength > arrayBufferView.byteLength) {\r\n            throw new RangeError(\"Length is out of range.\");\r\n        }\r\n\r\n        return Promise.resolve(new Uint8Array(arrayBufferView.buffer, arrayBufferView.byteOffset + byteOffset, byteLength));\r\n    } catch (e) {\r\n        return Promise.reject(e);\r\n    }\r\n}\r\n\r\n/**\r\n * Mode that determines the coordinate system to use.\r\n */\r\nexport enum GLTFLoaderCoordinateSystemMode {\r\n    /**\r\n     * Automatically convert the glTF right-handed data to the appropriate system based on the current coordinate system mode of the scene.\r\n     */\r\n    AUTO,\r\n\r\n    /**\r\n     * Sets the useRightHandedSystem flag on the scene.\r\n     */\r\n    FORCE_RIGHT_HANDED,\r\n}\r\n\r\n/**\r\n * Mode that determines what animations will start.\r\n */\r\nexport enum GLTFLoaderAnimationStartMode {\r\n    /**\r\n     * No animation will start.\r\n     */\r\n    NONE,\r\n\r\n    /**\r\n     * The first animation will start.\r\n     */\r\n    FIRST,\r\n\r\n    /**\r\n     * All animations will start.\r\n     */\r\n    ALL,\r\n}\r\n\r\n/**\r\n * Interface that contains the data for the glTF asset.\r\n */\r\nexport interface IGLTFLoaderData {\r\n    /**\r\n     * The object that represents the glTF JSON.\r\n     */\r\n    json: object;\r\n\r\n    /**\r\n     * The BIN chunk of a binary glTF.\r\n     */\r\n    bin: Nullable<IDataBuffer>;\r\n}\r\n\r\n/**\r\n * Interface for extending the loader.\r\n */\r\nexport interface IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    readonly name: string;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    enabled: boolean;\r\n\r\n    /**\r\n     * Defines the order of this extension.\r\n     * The loader sorts the extensions using these values when loading.\r\n     */\r\n    order?: number;\r\n}\r\n\r\n/**\r\n * Loader state.\r\n */\r\nexport enum GLTFLoaderState {\r\n    /**\r\n     * The asset is loading.\r\n     */\r\n    LOADING,\r\n\r\n    /**\r\n     * The asset is ready for rendering.\r\n     */\r\n    READY,\r\n\r\n    /**\r\n     * The asset is completely loaded.\r\n     */\r\n    COMPLETE,\r\n}\r\n\r\n/** @internal */\r\nexport interface IGLTFLoader extends IDisposable {\r\n    importMeshAsync: (\r\n        meshesNames: string | readonly string[] | null | undefined,\r\n        scene: Scene,\r\n        container: Nullable<AssetContainer>,\r\n        data: IGLTFLoaderData,\r\n        rootUrl: string,\r\n        onProgress?: (event: ISceneLoaderProgressEvent) => void,\r\n        fileName?: string\r\n    ) => Promise<ISceneLoaderAsyncResult>;\r\n    loadAsync: (scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string) => Promise<void>;\r\n}\r\n\r\n/**\r\n * Adds default/implicit options to extension specific options.\r\n */\r\ntype DefaultExtensionOptions<BaseExtensionOptions> = {\r\n    /**\r\n     * Defines if the extension is enabled\r\n     */\r\n    enabled?: boolean;\r\n} & BaseExtensionOptions;\r\n\r\n/**\r\n * This class contains all the concrete (not abstract) glTF options, excluding callbacks.\r\n * The purpose of this class is to make it easy to provide a way to mutate the default\r\n * loader options (see the GLTFLoaderDefaultOptions instance below) without duplicating\r\n * all the options in yet another object. Since this class is instantiated for the default\r\n * options object, abstract properties and callbacks are not included, it's more just\r\n * flag-type options.\r\n */\r\nclass GLTFLoaderBaseOptions {\r\n    /**\r\n     * Defines if the loader should always compute the bounding boxes of meshes and not use the min/max values from the position accessor. Defaults to false.\r\n     */\r\n    public alwaysComputeBoundingBox = false;\r\n\r\n    /**\r\n     * Defines if the loader should always compute the nearest common ancestor of the skeleton joints instead of using `skin.skeleton`. Defaults to false.\r\n     * Set this to true if loading assets with invalid `skin.skeleton` values.\r\n     */\r\n    public alwaysComputeSkeletonRootNode = false;\r\n\r\n    /**\r\n     * The animation start mode. Defaults to FIRST.\r\n     */\r\n    public animationStartMode = GLTFLoaderAnimationStartMode.FIRST;\r\n\r\n    /**\r\n     * Defines if the loader should compile materials before raising the success callback. Defaults to false.\r\n     */\r\n    public compileMaterials = false;\r\n\r\n    /**\r\n     * Defines if the loader should compile shadow generators before raising the success callback. Defaults to false.\r\n     */\r\n    public compileShadowGenerators = false;\r\n\r\n    /**\r\n     * The coordinate system mode. Defaults to AUTO.\r\n     */\r\n    public coordinateSystemMode = GLTFLoaderCoordinateSystemMode.AUTO;\r\n\r\n    /**\r\n     * Defines if the loader should create instances when multiple glTF nodes point to the same glTF mesh. Defaults to true.\r\n     */\r\n    public createInstances = true;\r\n\r\n    /**\r\n     * If true, load all materials defined in the file, even if not used by any mesh. Defaults to false.\r\n     */\r\n    public loadAllMaterials = false;\r\n\r\n    /**\r\n     * Defines if the loader should load morph targets. Defaults to true.\r\n     */\r\n    public loadMorphTargets = true;\r\n\r\n    /**\r\n     * Defines if the loader should load node animations. Defaults to true.\r\n     * NOTE: The animation of this node will still load if the node is also a joint of a skin and `loadSkins` is true.\r\n     */\r\n    public loadNodeAnimations = true;\r\n\r\n    /**\r\n     * If true, load only the materials defined in the file. Defaults to false.\r\n     */\r\n    public loadOnlyMaterials = false;\r\n\r\n    /**\r\n     * Defines if the loader should load skins. Defaults to true.\r\n     */\r\n    public loadSkins = true;\r\n\r\n    /**\r\n     * If true, do not load any materials defined in the file. Defaults to false.\r\n     */\r\n    public skipMaterials = false;\r\n\r\n    /**\r\n     * When loading glTF animations, which are defined in seconds, target them to this FPS. Defaults to 60.\r\n     */\r\n    public targetFps = 60;\r\n\r\n    /**\r\n     * Defines if the Alpha blended materials are only applied as coverage.\r\n     * If false, (default) The luminance of each pixel will reduce its opacity to simulate the behaviour of most physical materials.\r\n     * If true, no extra effects are applied to transparent pixels.\r\n     */\r\n    public transparencyAsCoverage = false;\r\n\r\n    /**\r\n     * Defines if the loader should also compile materials with clip planes. Defaults to false.\r\n     */\r\n    public useClipPlane = false;\r\n\r\n    /**\r\n     * If true, the loader will derive the name for Babylon textures from the glTF texture name, image name, or image url. Defaults to false.\r\n     * Note that it is possible for multiple Babylon textures to share the same name when the Babylon textures load from the same glTF texture or image.\r\n     */\r\n    public useGltfTextureNames = false;\r\n\r\n    /**\r\n     * Defines if the loader should use range requests when load binary glTF files from HTTP.\r\n     * Enabling will disable offline support and glTF validator.\r\n     * Defaults to false.\r\n     */\r\n    public useRangeRequests = false;\r\n\r\n    /**\r\n     * If true, load the color (gamma encoded) textures into sRGB buffers (if supported by the GPU), which will yield more accurate results when sampling the texture. Defaults to true.\r\n     */\r\n    public useSRGBBuffers = true;\r\n\r\n    /**\r\n     * Defines if the loader should validate the asset.\r\n     */\r\n    public validate = false;\r\n}\r\n\r\n/**\r\n * The default GLTF loader options.\r\n * Override the properties of this object to globally change the default loader options.\r\n * To specify options for a specific load call, pass those options into the associated load function.\r\n */\r\nexport const GLTFLoaderDefaultOptions = new GLTFLoaderBaseOptions();\r\n\r\nabstract class GLTFLoaderOptions extends GLTFLoaderBaseOptions {\r\n    // eslint-disable-next-line babylonjs/available\r\n    protected copyFrom(options?: Partial<Readonly<GLTFLoaderOptions>>) {\r\n        if (options) {\r\n            this.alwaysComputeBoundingBox = options.alwaysComputeBoundingBox ?? this.alwaysComputeBoundingBox;\r\n            this.alwaysComputeSkeletonRootNode = options.alwaysComputeSkeletonRootNode ?? this.alwaysComputeSkeletonRootNode;\r\n            this.animationStartMode = options.animationStartMode ?? this.animationStartMode;\r\n            this.capturePerformanceCounters = options.capturePerformanceCounters ?? this.capturePerformanceCounters;\r\n            this.compileMaterials = options.compileMaterials ?? this.compileMaterials;\r\n            this.compileShadowGenerators = options.compileShadowGenerators ?? this.compileShadowGenerators;\r\n            this.coordinateSystemMode = options.coordinateSystemMode ?? this.coordinateSystemMode;\r\n            this.createInstances = options.createInstances ?? this.createInstances;\r\n            this.customRootNode = options.customRootNode;\r\n            this.extensionOptions = options.extensionOptions ?? this.extensionOptions;\r\n            this.loadAllMaterials = options.loadAllMaterials ?? this.loadAllMaterials;\r\n            this.loadMorphTargets = options.loadMorphTargets ?? this.loadMorphTargets;\r\n            this.loadNodeAnimations = options.loadNodeAnimations ?? this.loadNodeAnimations;\r\n            this.loadOnlyMaterials = options.loadOnlyMaterials ?? this.loadOnlyMaterials;\r\n            this.loadSkins = options.loadSkins ?? this.loadSkins;\r\n            this.loggingEnabled = options.loggingEnabled ?? this.loggingEnabled;\r\n            this.onCameraLoaded = options.onCameraLoaded;\r\n            this.onMaterialLoaded = options.onMaterialLoaded;\r\n            this.onMeshLoaded = options.onMeshLoaded;\r\n            this.onParsed = options.onParsed;\r\n            this.onSkinLoaded = options.onSkinLoaded;\r\n            this.onTextureLoaded = options.onTextureLoaded;\r\n            this.onValidated = options.onValidated;\r\n            this.preprocessUrlAsync = options.preprocessUrlAsync ?? this.preprocessUrlAsync;\r\n            this.skipMaterials = options.skipMaterials ?? this.skipMaterials;\r\n            this.targetFps = options.targetFps ?? this.targetFps;\r\n            this.transparencyAsCoverage = options.transparencyAsCoverage ?? this.transparencyAsCoverage;\r\n            this.useClipPlane = options.useClipPlane ?? this.useClipPlane;\r\n            this.useGltfTextureNames = options.useGltfTextureNames ?? this.useGltfTextureNames;\r\n            this.useRangeRequests = options.useRangeRequests ?? this.useRangeRequests;\r\n            this.useSRGBBuffers = options.useSRGBBuffers ?? this.useSRGBBuffers;\r\n            this.validate = options.validate ?? this.validate;\r\n        }\r\n    }\r\n\r\n    // --------------\r\n    // Common options\r\n    // --------------\r\n\r\n    /**\r\n     * Raised when the asset has been parsed\r\n     */\r\n    public abstract onParsed?: ((loaderData: IGLTFLoaderData) => void) | undefined;\r\n\r\n    // ----------\r\n    // V2 options\r\n    // ----------\r\n\r\n    /**\r\n     * Defines if the loader should capture performance counters.\r\n     */\r\n    public abstract capturePerformanceCounters: boolean;\r\n\r\n    /**\r\n     * Defines the node to use as the root of the hierarchy when loading the scene (default: undefined). If not defined, a root node will be automatically created.\r\n     * You can also pass null if you don't want a root node to be created.\r\n     */\r\n    public customRootNode?: Nullable<TransformNode>;\r\n\r\n    /**\r\n     * Defines options for glTF extensions.\r\n     */\r\n    public extensionOptions: {\r\n        // NOTE: This type is doing two things:\r\n        // 1. Adding an implicit 'enabled' property to the options for each extension.\r\n        // 2. Creating a mapped type of all the options of all the extensions to make it just look like a consolidated plain object in intellisense for the user.\r\n        [Extension in keyof GLTFLoaderExtensionOptions]?: {\r\n            [Option in keyof DefaultExtensionOptions<GLTFLoaderExtensionOptions[Extension]>]: DefaultExtensionOptions<GLTFLoaderExtensionOptions[Extension]>[Option];\r\n        };\r\n    } = {};\r\n\r\n    /**\r\n     * If true, enable logging for the loader. Defaults to false.\r\n     */\r\n    public abstract loggingEnabled: boolean;\r\n\r\n    /**\r\n     * Callback raised when the loader creates a camera after parsing the glTF properties of the camera.\r\n     */\r\n    public abstract onCameraLoaded?: (camera: Camera) => void;\r\n\r\n    /**\r\n     * Callback raised when the loader creates a material after parsing the glTF properties of the material.\r\n     */\r\n    public abstract onMaterialLoaded?: (material: Material) => void;\r\n\r\n    /**\r\n     * Callback raised when the loader creates a mesh after parsing the glTF properties of the mesh.\r\n     * Note that the callback is called as soon as the mesh object is created, meaning some data may not have been setup yet for this mesh (vertex data, morph targets, material, ...)\r\n     */\r\n    public abstract onMeshLoaded?: (mesh: AbstractMesh) => void;\r\n\r\n    /**\r\n     * Callback raised when the loader creates a skin after parsing the glTF properties of the skin node.\r\n     * @see https://doc.babylonjs.com/features/featuresDeepDive/importers/glTF/glTFSkinning#ignoring-the-transform-of-the-skinned-mesh\r\n     */\r\n    public abstract onSkinLoaded?: (node: TransformNode, skinnedNode: TransformNode) => void;\r\n\r\n    /**\r\n     * Callback raised when the loader creates a texture after parsing the glTF properties of the texture.\r\n     */\r\n    public abstract onTextureLoaded?: (texture: BaseTexture) => void;\r\n\r\n    /**\r\n     * Callback raised after the asset is validated.\r\n     */\r\n    public abstract onValidated?: (results: GLTF2.IGLTFValidationResults) => void;\r\n\r\n    /**\r\n     * Function called before loading a url referenced by the asset.\r\n     * @param url url referenced by the asset\r\n     * @returns Async url to load\r\n     */\r\n    public preprocessUrlAsync = (url: string) => Promise.resolve(url);\r\n}\r\n\r\n/**\r\n * File loader for loading glTF files into a scene.\r\n */\r\nexport class GLTFFileLoader extends GLTFLoaderOptions implements IDisposable, ISceneLoaderPluginAsync, ISceneLoaderPluginFactory {\r\n    /** @internal */\r\n    public static _CreateGLTF1Loader: (parent: GLTFFileLoader) => IGLTFLoader;\r\n\r\n    /** @internal */\r\n    public static _CreateGLTF2Loader: (parent: GLTFFileLoader) => IGLTFLoader;\r\n\r\n    /**\r\n     * Creates a new glTF file loader.\r\n     * @param options The options for the loader\r\n     */\r\n    public constructor(options?: Partial<Readonly<GLTFLoaderOptions>>) {\r\n        super();\r\n        this.copyFrom(Object.assign({ ...GLTFLoaderDefaultOptions }, options));\r\n    }\r\n\r\n    // --------------------\r\n    // Begin Common options\r\n    // --------------------\r\n\r\n    /**\r\n     * Raised when the asset has been parsed\r\n     */\r\n    public onParsedObservable = new Observable<IGLTFLoaderData>();\r\n\r\n    private _onParsedObserver: Nullable<Observer<IGLTFLoaderData>>;\r\n\r\n    /**\r\n     * Raised when the asset has been parsed\r\n     */\r\n    public set onParsed(callback: ((loaderData: IGLTFLoaderData) => void) | undefined) {\r\n        if (this._onParsedObserver) {\r\n            this.onParsedObservable.remove(this._onParsedObserver);\r\n        }\r\n        if (callback) {\r\n            this._onParsedObserver = this.onParsedObservable.add(callback);\r\n        }\r\n    }\r\n\r\n    // ------------------\r\n    // End Common options\r\n    // ------------------\r\n\r\n    // ----------------\r\n    // Begin V1 options\r\n    // ----------------\r\n\r\n    /**\r\n     * Set this property to false to disable incremental loading which delays the loader from calling the success callback until after loading the meshes and shaders.\r\n     * Textures always loads asynchronously. For example, the success callback can compute the bounding information of the loaded meshes when incremental loading is disabled.\r\n     * Defaults to true.\r\n     * @internal\r\n     */\r\n    public static IncrementalLoading = true;\r\n\r\n    /**\r\n     * Set this property to true in order to work with homogeneous coordinates, available with some converters and exporters.\r\n     * Defaults to false. See https://en.wikipedia.org/wiki/Homogeneous_coordinates.\r\n     * @internal\r\n     */\r\n    public static HomogeneousCoordinates = false;\r\n\r\n    // --------------\r\n    // End V1 options\r\n    // --------------\r\n\r\n    /**\r\n     * Observable raised when the loader creates a mesh after parsing the glTF properties of the mesh.\r\n     * Note that the observable is raised as soon as the mesh object is created, meaning some data may not have been setup yet for this mesh (vertex data, morph targets, material, ...)\r\n     */\r\n    public readonly onMeshLoadedObservable = new Observable<AbstractMesh>();\r\n\r\n    private _onMeshLoadedObserver: Nullable<Observer<AbstractMesh>>;\r\n\r\n    /**\r\n     * Callback raised when the loader creates a mesh after parsing the glTF properties of the mesh.\r\n     * Note that the callback is called as soon as the mesh object is created, meaning some data may not have been setup yet for this mesh (vertex data, morph targets, material, ...)\r\n     */\r\n    public set onMeshLoaded(callback: ((mesh: AbstractMesh) => void) | undefined) {\r\n        if (this._onMeshLoadedObserver) {\r\n            this.onMeshLoadedObservable.remove(this._onMeshLoadedObserver);\r\n        }\r\n        if (callback) {\r\n            this._onMeshLoadedObserver = this.onMeshLoadedObservable.add(callback);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Observable raised when the loader creates a skin after parsing the glTF properties of the skin node.\r\n     * @see https://doc.babylonjs.com/features/featuresDeepDive/importers/glTF/glTFSkinning#ignoring-the-transform-of-the-skinned-mesh\r\n     * @param node - the transform node that corresponds to the original glTF skin node used for animations\r\n     * @param skinnedNode - the transform node that is the skinned mesh itself or the parent of the skinned meshes\r\n     */\r\n    public readonly onSkinLoadedObservable = new Observable<{ node: TransformNode; skinnedNode: TransformNode }>();\r\n\r\n    private _onSkinLoadedObserver: Nullable<Observer<{ node: TransformNode; skinnedNode: TransformNode }>>;\r\n\r\n    /**\r\n     * Callback raised when the loader creates a skin after parsing the glTF properties of the skin node.\r\n     * @see https://doc.babylonjs.com/features/featuresDeepDive/importers/glTF/glTFSkinning#ignoring-the-transform-of-the-skinned-mesh\r\n     */\r\n    public set onSkinLoaded(callback: ((node: TransformNode, skinnedNode: TransformNode) => void) | undefined) {\r\n        if (this._onSkinLoadedObserver) {\r\n            this.onSkinLoadedObservable.remove(this._onSkinLoadedObserver);\r\n        }\r\n        if (callback) {\r\n            this._onSkinLoadedObserver = this.onSkinLoadedObservable.add((data) => callback(data.node, data.skinnedNode));\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Observable raised when the loader creates a texture after parsing the glTF properties of the texture.\r\n     */\r\n    public readonly onTextureLoadedObservable = new Observable<BaseTexture>();\r\n\r\n    private _onTextureLoadedObserver: Nullable<Observer<BaseTexture>>;\r\n\r\n    /**\r\n     * Callback raised when the loader creates a texture after parsing the glTF properties of the texture.\r\n     */\r\n    public set onTextureLoaded(callback: ((texture: BaseTexture) => void) | undefined) {\r\n        if (this._onTextureLoadedObserver) {\r\n            this.onTextureLoadedObservable.remove(this._onTextureLoadedObserver);\r\n        }\r\n        if (callback) {\r\n            this._onTextureLoadedObserver = this.onTextureLoadedObservable.add(callback);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Observable raised when the loader creates a material after parsing the glTF properties of the material.\r\n     */\r\n    public readonly onMaterialLoadedObservable = new Observable<Material>();\r\n\r\n    private _onMaterialLoadedObserver: Nullable<Observer<Material>>;\r\n\r\n    /**\r\n     * Callback raised when the loader creates a material after parsing the glTF properties of the material.\r\n     */\r\n    public set onMaterialLoaded(callback: ((material: Material) => void) | undefined) {\r\n        if (this._onMaterialLoadedObserver) {\r\n            this.onMaterialLoadedObservable.remove(this._onMaterialLoadedObserver);\r\n        }\r\n        if (callback) {\r\n            this._onMaterialLoadedObserver = this.onMaterialLoadedObservable.add(callback);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Observable raised when the loader creates a camera after parsing the glTF properties of the camera.\r\n     */\r\n    public readonly onCameraLoadedObservable = new Observable<Camera>();\r\n\r\n    private _onCameraLoadedObserver: Nullable<Observer<Camera>>;\r\n\r\n    /**\r\n     * Callback raised when the loader creates a camera after parsing the glTF properties of the camera.\r\n     */\r\n    public set onCameraLoaded(callback: ((camera: Camera) => void) | undefined) {\r\n        if (this._onCameraLoadedObserver) {\r\n            this.onCameraLoadedObservable.remove(this._onCameraLoadedObserver);\r\n        }\r\n        if (callback) {\r\n            this._onCameraLoadedObserver = this.onCameraLoadedObservable.add(callback);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Observable raised when the asset is completely loaded, immediately before the loader is disposed.\r\n     * For assets with LODs, raised when all of the LODs are complete.\r\n     * For assets without LODs, raised when the model is complete, immediately after the loader resolves the returned promise.\r\n     */\r\n    public readonly onCompleteObservable = new Observable<void>();\r\n\r\n    private _onCompleteObserver: Nullable<Observer<void>>;\r\n\r\n    /**\r\n     * Callback raised when the asset is completely loaded, immediately before the loader is disposed.\r\n     * For assets with LODs, raised when all of the LODs are complete.\r\n     * For assets without LODs, raised when the model is complete, immediately after the loader resolves the returned promise.\r\n     */\r\n    public set onComplete(callback: () => void) {\r\n        if (this._onCompleteObserver) {\r\n            this.onCompleteObservable.remove(this._onCompleteObserver);\r\n        }\r\n        this._onCompleteObserver = this.onCompleteObservable.add(callback);\r\n    }\r\n\r\n    /**\r\n     * Observable raised when an error occurs.\r\n     */\r\n    public readonly onErrorObservable = new Observable<any>();\r\n\r\n    private _onErrorObserver: Nullable<Observer<any>>;\r\n\r\n    /**\r\n     * Callback raised when an error occurs.\r\n     */\r\n    public set onError(callback: (reason: any) => void) {\r\n        if (this._onErrorObserver) {\r\n            this.onErrorObservable.remove(this._onErrorObserver);\r\n        }\r\n        this._onErrorObserver = this.onErrorObservable.add(callback);\r\n    }\r\n\r\n    /**\r\n     * Observable raised after the loader is disposed.\r\n     */\r\n    public readonly onDisposeObservable = new Observable<void>();\r\n\r\n    private _onDisposeObserver: Nullable<Observer<void>>;\r\n\r\n    /**\r\n     * Callback raised after the loader is disposed.\r\n     */\r\n    public set onDispose(callback: () => void) {\r\n        if (this._onDisposeObserver) {\r\n            this.onDisposeObservable.remove(this._onDisposeObserver);\r\n        }\r\n        this._onDisposeObserver = this.onDisposeObservable.add(callback);\r\n    }\r\n\r\n    /**\r\n     * Observable raised after a loader extension is created.\r\n     * Set additional options for a loader extension in this event.\r\n     */\r\n    public readonly onExtensionLoadedObservable = new Observable<IGLTFLoaderExtension>();\r\n\r\n    private _onExtensionLoadedObserver: Nullable<Observer<IGLTFLoaderExtension>>;\r\n\r\n    /**\r\n     * Callback raised after a loader extension is created.\r\n     */\r\n    public set onExtensionLoaded(callback: (extension: IGLTFLoaderExtension) => void) {\r\n        if (this._onExtensionLoadedObserver) {\r\n            this.onExtensionLoadedObservable.remove(this._onExtensionLoadedObserver);\r\n        }\r\n        this._onExtensionLoadedObserver = this.onExtensionLoadedObservable.add(callback);\r\n    }\r\n\r\n    /**\r\n     * Defines if the loader logging is enabled.\r\n     */\r\n    public get loggingEnabled(): boolean {\r\n        return this._loggingEnabled;\r\n    }\r\n\r\n    public set loggingEnabled(value: boolean) {\r\n        if (this._loggingEnabled === value) {\r\n            return;\r\n        }\r\n\r\n        this._loggingEnabled = value;\r\n\r\n        if (this._loggingEnabled) {\r\n            this._log = this._logEnabled;\r\n        } else {\r\n            this._log = this._logDisabled;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Defines if the loader should capture performance counters.\r\n     */\r\n    public get capturePerformanceCounters(): boolean {\r\n        return this._capturePerformanceCounters;\r\n    }\r\n\r\n    public set capturePerformanceCounters(value: boolean) {\r\n        if (this._capturePerformanceCounters === value) {\r\n            return;\r\n        }\r\n\r\n        this._capturePerformanceCounters = value;\r\n\r\n        if (this._capturePerformanceCounters) {\r\n            this._startPerformanceCounter = this._startPerformanceCounterEnabled;\r\n            this._endPerformanceCounter = this._endPerformanceCounterEnabled;\r\n        } else {\r\n            this._startPerformanceCounter = this._startPerformanceCounterDisabled;\r\n            this._endPerformanceCounter = this._endPerformanceCounterDisabled;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Observable raised after validation when validate is set to true. The event data is the result of the validation.\r\n     */\r\n    public readonly onValidatedObservable = new Observable<GLTF2.IGLTFValidationResults>();\r\n\r\n    private _onValidatedObserver: Nullable<Observer<GLTF2.IGLTFValidationResults>>;\r\n\r\n    /**\r\n     * Callback raised after the asset is validated.\r\n     */\r\n    public set onValidated(callback: (results: GLTF2.IGLTFValidationResults) => void) {\r\n        if (this._onValidatedObserver) {\r\n            this.onValidatedObservable.remove(this._onValidatedObserver);\r\n        }\r\n        this._onValidatedObserver = this.onValidatedObservable.add(callback);\r\n    }\r\n\r\n    private _loader: Nullable<IGLTFLoader> = null;\r\n    private _state: Nullable<GLTFLoaderState> = null;\r\n    private _progressCallback?: (event: ISceneLoaderProgressEvent) => void;\r\n    private _requests = new Array<IFileRequestInfo>();\r\n\r\n    /**\r\n     * Name of the loader (\"gltf\")\r\n     */\r\n    public readonly name = GLTFFileLoaderMetadata.name;\r\n\r\n    /** @internal */\r\n    public readonly extensions = GLTFFileLoaderMetadata.extensions;\r\n\r\n    /**\r\n     * Disposes the loader, releases resources during load, and cancels any outstanding requests.\r\n     */\r\n    public dispose(): void {\r\n        if (this._loader) {\r\n            this._loader.dispose();\r\n            this._loader = null;\r\n        }\r\n\r\n        for (const request of this._requests) {\r\n            request.abort();\r\n        }\r\n\r\n        this._requests.length = 0;\r\n\r\n        delete this._progressCallback;\r\n\r\n        this.preprocessUrlAsync = (url) => Promise.resolve(url);\r\n\r\n        this.onMeshLoadedObservable.clear();\r\n        this.onSkinLoadedObservable.clear();\r\n        this.onTextureLoadedObservable.clear();\r\n        this.onMaterialLoadedObservable.clear();\r\n        this.onCameraLoadedObservable.clear();\r\n        this.onCompleteObservable.clear();\r\n        this.onExtensionLoadedObservable.clear();\r\n\r\n        this.onDisposeObservable.notifyObservers(undefined);\r\n        this.onDisposeObservable.clear();\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public loadFile(\r\n        scene: Scene,\r\n        fileOrUrl: File | string | ArrayBufferView,\r\n        rootUrl: string,\r\n        onSuccess: (data: unknown, responseURL?: string) => void,\r\n        onProgress?: (ev: ISceneLoaderProgressEvent) => void,\r\n        useArrayBuffer?: boolean,\r\n        onError?: (request?: WebRequest, exception?: LoadFileError) => void,\r\n        name?: string\r\n    ): Nullable<IFileRequest> {\r\n        if (ArrayBuffer.isView(fileOrUrl)) {\r\n            this._loadBinary(scene, fileOrUrl, rootUrl, onSuccess, onError, name);\r\n            return null;\r\n        }\r\n\r\n        this._progressCallback = onProgress;\r\n\r\n        const fileName = (fileOrUrl as File).name || Tools.GetFilename(fileOrUrl as string);\r\n\r\n        if (useArrayBuffer) {\r\n            if (this.useRangeRequests) {\r\n                if (this.validate) {\r\n                    Logger.Warn(\"glTF validation is not supported when range requests are enabled\");\r\n                }\r\n\r\n                const fileRequest: IFileRequest = {\r\n                    abort: () => {},\r\n                    onCompleteObservable: new Observable<IFileRequest>(),\r\n                };\r\n\r\n                const dataBuffer = {\r\n                    readAsync: (byteOffset: number, byteLength: number) => {\r\n                        return new Promise<ArrayBufferView>((resolve, reject) => {\r\n                            this._loadFile(\r\n                                scene,\r\n                                fileOrUrl,\r\n                                (data) => {\r\n                                    resolve(new Uint8Array(data as ArrayBuffer));\r\n                                },\r\n                                true,\r\n                                (error) => {\r\n                                    reject(error);\r\n                                },\r\n                                (webRequest) => {\r\n                                    webRequest.setRequestHeader(\"Range\", `bytes=${byteOffset}-${byteOffset + byteLength - 1}`);\r\n                                }\r\n                            );\r\n                        });\r\n                    },\r\n                    byteLength: 0,\r\n                };\r\n\r\n                this._unpackBinaryAsync(new DataReader(dataBuffer)).then(\r\n                    (loaderData) => {\r\n                        fileRequest.onCompleteObservable.notifyObservers(fileRequest);\r\n                        onSuccess(loaderData);\r\n                    },\r\n                    onError ? (error) => onError(undefined, error) : undefined\r\n                );\r\n\r\n                return fileRequest;\r\n            }\r\n\r\n            return this._loadFile(\r\n                scene,\r\n                fileOrUrl,\r\n                (data) => {\r\n                    this._validate(scene, new Uint8Array(data as ArrayBuffer, 0, (data as ArrayBuffer).byteLength), rootUrl, fileName);\r\n                    this._unpackBinaryAsync(\r\n                        new DataReader({\r\n                            readAsync: (byteOffset, byteLength) => readAsync(data as ArrayBuffer, byteOffset, byteLength),\r\n                            byteLength: (data as ArrayBuffer).byteLength,\r\n                        })\r\n                    ).then(\r\n                        (loaderData) => {\r\n                            onSuccess(loaderData);\r\n                        },\r\n                        onError ? (error) => onError(undefined, error) : undefined\r\n                    );\r\n                },\r\n                true,\r\n                onError\r\n            );\r\n        } else {\r\n            return this._loadFile(\r\n                scene,\r\n                fileOrUrl,\r\n                (data) => {\r\n                    try {\r\n                        this._validate(scene, data as string, rootUrl, fileName);\r\n                        onSuccess({ json: this._parseJson(data as string) });\r\n                    } catch {\r\n                        if (onError) {\r\n                            onError();\r\n                        }\r\n                    }\r\n                },\r\n                false,\r\n                onError\r\n            );\r\n        }\r\n    }\r\n\r\n    private _loadBinary(\r\n        scene: Scene,\r\n        data: ArrayBufferView,\r\n        rootUrl: string,\r\n        onSuccess: (data: unknown, responseURL?: string) => void,\r\n        onError?: (request?: WebRequest, exception?: LoadFileError) => void,\r\n        fileName?: string\r\n    ): void {\r\n        this._validate(scene, new Uint8Array(data.buffer, data.byteOffset, data.byteLength), rootUrl, fileName);\r\n        this._unpackBinaryAsync(\r\n            new DataReader({\r\n                readAsync: (byteOffset, byteLength) => readViewAsync(data, byteOffset, byteLength),\r\n                byteLength: data.byteLength,\r\n            })\r\n        ).then(\r\n            (loaderData) => {\r\n                onSuccess(loaderData);\r\n            },\r\n            onError ? (error) => onError(undefined, error) : undefined\r\n        );\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public importMeshAsync(\r\n        meshesNames: string | readonly string[] | null | undefined,\r\n        scene: Scene,\r\n        data: IGLTFLoaderData,\r\n        rootUrl: string,\r\n        onProgress?: (event: ISceneLoaderProgressEvent) => void,\r\n        fileName?: string\r\n    ): Promise<ISceneLoaderAsyncResult> {\r\n        return Promise.resolve().then(() => {\r\n            this.onParsedObservable.notifyObservers(data);\r\n            this.onParsedObservable.clear();\r\n\r\n            this._log(`Loading ${fileName || \"\"}`);\r\n            this._loader = this._getLoader(data);\r\n            return this._loader.importMeshAsync(meshesNames, scene, null, data, rootUrl, onProgress, fileName);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public loadAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName?: string): Promise<void> {\r\n        return Promise.resolve().then(() => {\r\n            this.onParsedObservable.notifyObservers(data);\r\n            this.onParsedObservable.clear();\r\n\r\n            this._log(`Loading ${fileName || \"\"}`);\r\n            this._loader = this._getLoader(data);\r\n            return this._loader.loadAsync(scene, data, rootUrl, onProgress, fileName);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public loadAssetContainerAsync(\r\n        scene: Scene,\r\n        data: IGLTFLoaderData,\r\n        rootUrl: string,\r\n        onProgress?: (event: ISceneLoaderProgressEvent) => void,\r\n        fileName?: string\r\n    ): Promise<AssetContainer> {\r\n        return Promise.resolve().then(() => {\r\n            this.onParsedObservable.notifyObservers(data);\r\n            this.onParsedObservable.clear();\r\n\r\n            this._log(`Loading ${fileName || \"\"}`);\r\n            this._loader = this._getLoader(data);\r\n\r\n            // Prepare the asset container.\r\n            const container = new AssetContainer(scene);\r\n\r\n            // Get materials/textures when loading to add to container\r\n            const materials: Array<Material> = [];\r\n            this.onMaterialLoadedObservable.add((material) => {\r\n                materials.push(material);\r\n            });\r\n            const textures: Array<BaseTexture> = [];\r\n            this.onTextureLoadedObservable.add((texture) => {\r\n                textures.push(texture);\r\n            });\r\n            const cameras: Array<Camera> = [];\r\n            this.onCameraLoadedObservable.add((camera) => {\r\n                cameras.push(camera);\r\n            });\r\n\r\n            const morphTargetManagers: Array<MorphTargetManager> = [];\r\n            this.onMeshLoadedObservable.add((mesh) => {\r\n                if (mesh.morphTargetManager) {\r\n                    morphTargetManagers.push(mesh.morphTargetManager);\r\n                }\r\n            });\r\n\r\n            return this._loader.importMeshAsync(null, scene, container, data, rootUrl, onProgress, fileName).then((result) => {\r\n                Array.prototype.push.apply(container.geometries, result.geometries);\r\n                Array.prototype.push.apply(container.meshes, result.meshes);\r\n                Array.prototype.push.apply(container.particleSystems, result.particleSystems);\r\n                Array.prototype.push.apply(container.skeletons, result.skeletons);\r\n                Array.prototype.push.apply(container.animationGroups, result.animationGroups);\r\n                Array.prototype.push.apply(container.materials, materials);\r\n                Array.prototype.push.apply(container.textures, textures);\r\n                Array.prototype.push.apply(container.lights, result.lights);\r\n                Array.prototype.push.apply(container.transformNodes, result.transformNodes);\r\n                Array.prototype.push.apply(container.cameras, cameras);\r\n                Array.prototype.push.apply(container.morphTargetManagers, morphTargetManagers);\r\n                return container;\r\n            });\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public canDirectLoad(data: string): boolean {\r\n        return GLTFFileLoaderMetadata.canDirectLoad(data);\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public directLoad(scene: Scene, data: string): Promise<object> {\r\n        if (\r\n            data.startsWith(\"base64,\" + GLTFMagicBase64Encoded) || // this is technically incorrect, but will continue to support for backcompat.\r\n            data.startsWith(\";base64,\" + GLTFMagicBase64Encoded) ||\r\n            data.startsWith(\"application/octet-stream;base64,\" + GLTFMagicBase64Encoded) ||\r\n            data.startsWith(\"model/gltf-binary;base64,\" + GLTFMagicBase64Encoded)\r\n        ) {\r\n            const arrayBuffer = DecodeBase64UrlToBinary(data);\r\n\r\n            this._validate(scene, new Uint8Array(arrayBuffer, 0, arrayBuffer.byteLength));\r\n            return this._unpackBinaryAsync(\r\n                new DataReader({\r\n                    readAsync: (byteOffset, byteLength) => readAsync(arrayBuffer, byteOffset, byteLength),\r\n                    byteLength: arrayBuffer.byteLength,\r\n                })\r\n            );\r\n        }\r\n\r\n        this._validate(scene, data);\r\n        return Promise.resolve({ json: this._parseJson(data) });\r\n    }\r\n\r\n    /**\r\n     * The callback that allows custom handling of the root url based on the response url.\r\n     * @param rootUrl the original root url\r\n     * @param responseURL the response url if available\r\n     * @returns the new root url\r\n     */\r\n    public rewriteRootURL?(rootUrl: string, responseURL?: string): string;\r\n\r\n    /** @internal */\r\n    public createPlugin(options: SceneLoaderPluginOptions): ISceneLoaderPluginAsync {\r\n        return new GLTFFileLoader(options[GLTFFileLoaderMetadata.name]);\r\n    }\r\n\r\n    /**\r\n     * The loader state or null if the loader is not active.\r\n     */\r\n    public get loaderState(): Nullable<GLTFLoaderState> {\r\n        return this._state;\r\n    }\r\n\r\n    /**\r\n     * Observable raised when the loader state changes.\r\n     */\r\n    public onLoaderStateChangedObservable = new Observable<Nullable<GLTFLoaderState>>();\r\n\r\n    /**\r\n     * Returns a promise that resolves when the asset is completely loaded.\r\n     * @returns a promise that resolves when the asset is completely loaded.\r\n     */\r\n    public whenCompleteAsync(): Promise<void> {\r\n        return new Promise((resolve, reject) => {\r\n            this.onCompleteObservable.addOnce(() => {\r\n                resolve();\r\n            });\r\n            this.onErrorObservable.addOnce((reason) => {\r\n                reject(reason);\r\n            });\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public _setState(state: GLTFLoaderState): void {\r\n        if (this._state === state) {\r\n            return;\r\n        }\r\n\r\n        this._state = state;\r\n        this.onLoaderStateChangedObservable.notifyObservers(this._state);\r\n        this._log(GLTFLoaderState[this._state]);\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public _loadFile(\r\n        scene: Scene,\r\n        fileOrUrl: File | string,\r\n        onSuccess: (data: string | ArrayBuffer) => void,\r\n        useArrayBuffer?: boolean,\r\n        onError?: (request?: WebRequest) => void,\r\n        onOpened?: (request: WebRequest) => void\r\n    ): IFileRequest {\r\n        const request = scene._loadFile(\r\n            fileOrUrl,\r\n            onSuccess,\r\n            (event) => {\r\n                this._onProgress(event, request);\r\n            },\r\n            true,\r\n            useArrayBuffer,\r\n            onError,\r\n            onOpened\r\n        ) as IFileRequestInfo;\r\n        request.onCompleteObservable.add(() => {\r\n            // Force the length computable to be true since we can guarantee the data is loaded.\r\n            request._lengthComputable = true;\r\n            request._total = request._loaded;\r\n        });\r\n        this._requests.push(request);\r\n        return request;\r\n    }\r\n\r\n    private _onProgress(event: ProgressEvent, request: IFileRequestInfo): void {\r\n        if (!this._progressCallback) {\r\n            return;\r\n        }\r\n\r\n        request._lengthComputable = event.lengthComputable;\r\n        request._loaded = event.loaded;\r\n        request._total = event.total;\r\n\r\n        let lengthComputable = true;\r\n        let loaded = 0;\r\n        let total = 0;\r\n        for (const request of this._requests) {\r\n            if (request._lengthComputable === undefined || request._loaded === undefined || request._total === undefined) {\r\n                return;\r\n            }\r\n\r\n            lengthComputable = lengthComputable && request._lengthComputable;\r\n            loaded += request._loaded;\r\n            total += request._total;\r\n        }\r\n\r\n        this._progressCallback({\r\n            lengthComputable: lengthComputable,\r\n            loaded: loaded,\r\n            total: lengthComputable ? total : 0,\r\n        });\r\n    }\r\n\r\n    private _validate(scene: Scene, data: string | Uint8Array, rootUrl = \"\", fileName = \"\"): void {\r\n        if (!this.validate) {\r\n            return;\r\n        }\r\n\r\n        this._startPerformanceCounter(\"Validate JSON\");\r\n        GLTFValidation.ValidateAsync(data, rootUrl, fileName, (uri) => {\r\n            return this.preprocessUrlAsync(rootUrl + uri).then((url) => {\r\n                return scene._loadFileAsync(url, undefined, true, true).then((data) => {\r\n                    return new Uint8Array(data, 0, data.byteLength);\r\n                });\r\n            });\r\n        }).then(\r\n            (result) => {\r\n                this._endPerformanceCounter(\"Validate JSON\");\r\n                this.onValidatedObservable.notifyObservers(result);\r\n                this.onValidatedObservable.clear();\r\n            },\r\n            (reason) => {\r\n                this._endPerformanceCounter(\"Validate JSON\");\r\n                Tools.Warn(`Failed to validate: ${reason.message}`);\r\n                this.onValidatedObservable.clear();\r\n            }\r\n        );\r\n    }\r\n\r\n    private _getLoader(loaderData: IGLTFLoaderData): IGLTFLoader {\r\n        const asset = (<any>loaderData.json).asset || {};\r\n\r\n        this._log(`Asset version: ${asset.version}`);\r\n        asset.minVersion && this._log(`Asset minimum version: ${asset.minVersion}`);\r\n        asset.generator && this._log(`Asset generator: ${asset.generator}`);\r\n\r\n        const version = GLTFFileLoader._parseVersion(asset.version);\r\n        if (!version) {\r\n            throw new Error(\"Invalid version: \" + asset.version);\r\n        }\r\n\r\n        if (asset.minVersion !== undefined) {\r\n            const minVersion = GLTFFileLoader._parseVersion(asset.minVersion);\r\n            if (!minVersion) {\r\n                throw new Error(\"Invalid minimum version: \" + asset.minVersion);\r\n            }\r\n\r\n            if (GLTFFileLoader._compareVersion(minVersion, { major: 2, minor: 0 }) > 0) {\r\n                throw new Error(\"Incompatible minimum version: \" + asset.minVersion);\r\n            }\r\n        }\r\n\r\n        const createLoaders: { [key: number]: (parent: GLTFFileLoader) => IGLTFLoader } = {\r\n            1: GLTFFileLoader._CreateGLTF1Loader,\r\n            2: GLTFFileLoader._CreateGLTF2Loader,\r\n        };\r\n\r\n        const createLoader = createLoaders[version.major];\r\n        if (!createLoader) {\r\n            throw new Error(\"Unsupported version: \" + asset.version);\r\n        }\r\n\r\n        return createLoader(this);\r\n    }\r\n\r\n    private _parseJson(json: string): object {\r\n        this._startPerformanceCounter(\"Parse JSON\");\r\n        this._log(`JSON length: ${json.length}`);\r\n        const parsed = JSON.parse(json);\r\n        this._endPerformanceCounter(\"Parse JSON\");\r\n        return parsed;\r\n    }\r\n\r\n    private _unpackBinaryAsync(dataReader: DataReader): Promise<IGLTFLoaderData> {\r\n        this._startPerformanceCounter(\"Unpack Binary\");\r\n\r\n        // Read magic + version + length + json length + json format\r\n        return dataReader.loadAsync(20).then(() => {\r\n            const Binary = {\r\n                Magic: 0x46546c67,\r\n            };\r\n\r\n            const magic = dataReader.readUint32();\r\n            if (magic !== Binary.Magic) {\r\n                throw new RuntimeError(\"Unexpected magic: \" + magic, ErrorCodes.GLTFLoaderUnexpectedMagicError);\r\n            }\r\n\r\n            const version = dataReader.readUint32();\r\n\r\n            if (this.loggingEnabled) {\r\n                this._log(`Binary version: ${version}`);\r\n            }\r\n\r\n            const length = dataReader.readUint32();\r\n            if (!this.useRangeRequests && length !== dataReader.buffer.byteLength) {\r\n                Logger.Warn(`Length in header does not match actual data length: ${length} != ${dataReader.buffer.byteLength}`);\r\n            }\r\n\r\n            let unpacked: Promise<IGLTFLoaderData>;\r\n            switch (version) {\r\n                case 1: {\r\n                    unpacked = this._unpackBinaryV1Async(dataReader, length);\r\n                    break;\r\n                }\r\n                case 2: {\r\n                    unpacked = this._unpackBinaryV2Async(dataReader, length);\r\n                    break;\r\n                }\r\n                default: {\r\n                    throw new Error(\"Unsupported version: \" + version);\r\n                }\r\n            }\r\n\r\n            this._endPerformanceCounter(\"Unpack Binary\");\r\n\r\n            return unpacked;\r\n        });\r\n    }\r\n\r\n    private _unpackBinaryV1Async(dataReader: DataReader, length: number): Promise<IGLTFLoaderData> {\r\n        const ContentFormat = {\r\n            JSON: 0,\r\n        };\r\n\r\n        const contentLength = dataReader.readUint32();\r\n        const contentFormat = dataReader.readUint32();\r\n\r\n        if (contentFormat !== ContentFormat.JSON) {\r\n            throw new Error(`Unexpected content format: ${contentFormat}`);\r\n        }\r\n\r\n        const bodyLength = length - dataReader.byteOffset;\r\n\r\n        const data: IGLTFLoaderData = { json: this._parseJson(dataReader.readString(contentLength)), bin: null };\r\n        if (bodyLength !== 0) {\r\n            const startByteOffset = dataReader.byteOffset;\r\n            data.bin = {\r\n                readAsync: (byteOffset, byteLength) => dataReader.buffer.readAsync(startByteOffset + byteOffset, byteLength),\r\n                byteLength: bodyLength,\r\n            };\r\n        }\r\n\r\n        return Promise.resolve(data);\r\n    }\r\n\r\n    private _unpackBinaryV2Async(dataReader: DataReader, length: number): Promise<IGLTFLoaderData> {\r\n        const ChunkFormat = {\r\n            JSON: 0x4e4f534a,\r\n            BIN: 0x004e4942,\r\n        };\r\n\r\n        // Read the JSON chunk header.\r\n        const chunkLength = dataReader.readUint32();\r\n        const chunkFormat = dataReader.readUint32();\r\n        if (chunkFormat !== ChunkFormat.JSON) {\r\n            throw new Error(\"First chunk format is not JSON\");\r\n        }\r\n\r\n        // Bail if there are no other chunks.\r\n        if (dataReader.byteOffset + chunkLength === length) {\r\n            return dataReader.loadAsync(chunkLength).then(() => {\r\n                return { json: this._parseJson(dataReader.readString(chunkLength)), bin: null };\r\n            });\r\n        }\r\n\r\n        // Read the JSON chunk and the length and type of the next chunk.\r\n        return dataReader.loadAsync(chunkLength + 8).then(() => {\r\n            const data: IGLTFLoaderData = { json: this._parseJson(dataReader.readString(chunkLength)), bin: null };\r\n\r\n            const readAsync = (): Promise<IGLTFLoaderData> => {\r\n                const chunkLength = dataReader.readUint32();\r\n                const chunkFormat = dataReader.readUint32();\r\n\r\n                switch (chunkFormat) {\r\n                    case ChunkFormat.JSON: {\r\n                        throw new Error(\"Unexpected JSON chunk\");\r\n                    }\r\n                    case ChunkFormat.BIN: {\r\n                        const startByteOffset = dataReader.byteOffset;\r\n                        data.bin = {\r\n                            readAsync: (byteOffset, byteLength) => dataReader.buffer.readAsync(startByteOffset + byteOffset, byteLength),\r\n                            byteLength: chunkLength,\r\n                        };\r\n                        dataReader.skipBytes(chunkLength);\r\n                        break;\r\n                    }\r\n                    default: {\r\n                        // ignore unrecognized chunkFormat\r\n                        dataReader.skipBytes(chunkLength);\r\n                        break;\r\n                    }\r\n                }\r\n\r\n                if (dataReader.byteOffset !== length) {\r\n                    return dataReader.loadAsync(8).then(readAsync);\r\n                }\r\n\r\n                return Promise.resolve(data);\r\n            };\r\n\r\n            return readAsync();\r\n        });\r\n    }\r\n\r\n    private static _parseVersion(version: string): Nullable<{ major: number; minor: number }> {\r\n        if (version === \"1.0\" || version === \"1.0.1\") {\r\n            return {\r\n                major: 1,\r\n                minor: 0,\r\n            };\r\n        }\r\n\r\n        const match = (version + \"\").match(/^(\\d+)\\.(\\d+)/);\r\n        if (!match) {\r\n            return null;\r\n        }\r\n\r\n        return {\r\n            major: parseInt(match[1]),\r\n            minor: parseInt(match[2]),\r\n        };\r\n    }\r\n\r\n    private static _compareVersion(a: { major: number; minor: number }, b: { major: number; minor: number }): number {\r\n        if (a.major > b.major) {\r\n            return 1;\r\n        }\r\n        if (a.major < b.major) {\r\n            return -1;\r\n        }\r\n        if (a.minor > b.minor) {\r\n            return 1;\r\n        }\r\n        if (a.minor < b.minor) {\r\n            return -1;\r\n        }\r\n        return 0;\r\n    }\r\n\r\n    private static readonly _logSpaces = \"                                \";\r\n    private _logIndentLevel = 0;\r\n    private _loggingEnabled = false;\r\n\r\n    /** @internal */\r\n    public _log = this._logDisabled;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public _logOpen(message: string): void {\r\n        this._log(message);\r\n        this._logIndentLevel++;\r\n    }\r\n\r\n    /** @internal */\r\n    public _logClose(): void {\r\n        --this._logIndentLevel;\r\n    }\r\n\r\n    private _logEnabled(message: string): void {\r\n        const spaces = GLTFFileLoader._logSpaces.substring(0, this._logIndentLevel * 2);\r\n        Logger.Log(`${spaces}${message}`);\r\n    }\r\n\r\n    private _logDisabled(message: string): void {}\r\n\r\n    private _capturePerformanceCounters = false;\r\n\r\n    /** @internal */\r\n    public _startPerformanceCounter = this._startPerformanceCounterDisabled;\r\n\r\n    /** @internal */\r\n    public _endPerformanceCounter = this._endPerformanceCounterDisabled;\r\n\r\n    private _startPerformanceCounterEnabled(counterName: string): void {\r\n        Tools.StartPerformanceCounter(counterName);\r\n    }\r\n\r\n    private _startPerformanceCounterDisabled(counterName: string): void {}\r\n\r\n    private _endPerformanceCounterEnabled(counterName: string): void {\r\n        Tools.EndPerformanceCounter(counterName);\r\n    }\r\n\r\n    private _endPerformanceCounterDisabled(counterName: string): void {}\r\n}\r\n\r\nRegisterSceneLoaderPlugin(new GLTFFileLoader());\r\n","import type { ISceneLoaderPluginExtensions, ISceneLoaderPluginMetadata } from \"core/index\";\r\n\r\nexport const GLTFMagicBase64Encoded = \"Z2xURg\"; // \"glTF\" base64 encoded (without the quotes!)\r\n\r\nexport const GLTFFileLoaderMetadata = {\r\n    name: \"gltf\",\r\n\r\n    extensions: {\r\n        // eslint-disable-next-line @typescript-eslint/naming-convention\r\n        \".gltf\": { isBinary: false, mimeType: \"model/gltf+json\" },\r\n        // eslint-disable-next-line @typescript-eslint/naming-convention\r\n        \".glb\": { isBinary: true, mimeType: \"model/gltf-binary\" },\r\n    } as const satisfies ISceneLoaderPluginExtensions,\r\n\r\n    canDirectLoad(data: string): boolean {\r\n        return (\r\n            (data.indexOf(\"asset\") !== -1 && data.indexOf(\"version\") !== -1) ||\r\n            data.startsWith(\"data:base64,\" + GLTFMagicBase64Encoded) || // this is technically incorrect, but will continue to support for backcompat.\r\n            data.startsWith(\"data:;base64,\" + GLTFMagicBase64Encoded) ||\r\n            data.startsWith(\"data:application/octet-stream;base64,\" + GLTFMagicBase64Encoded) ||\r\n            data.startsWith(\"data:model/gltf-binary;base64,\" + GLTFMagicBase64Encoded)\r\n        );\r\n    },\r\n} as const satisfies ISceneLoaderPluginMetadata;\r\n","import * as FileLoader from \"loaders/glTF/glTFFileLoader\";\r\nimport * as Validation from \"loaders/glTF/glTFValidation\";\r\n\r\n/**\r\n * This is the entry point for the UMD module.\r\n * The entry point for a future ESM package should be index.ts\r\n */\r\nconst GlobalObject = typeof global !== \"undefined\" ? global : typeof window !== \"undefined\" ? window : undefined;\r\nif (typeof GlobalObject !== \"undefined\") {\r\n    (<any>GlobalObject).BABYLON = (<any>GlobalObject).BABYLON || {};\r\n    for (const key in FileLoader) {\r\n        (<any>GlobalObject).BABYLON[key] = (<any>FileLoader)[key];\r\n    }\r\n    for (const key in Validation) {\r\n        (<any>GlobalObject).BABYLON[key] = (<any>Validation)[key];\r\n    }\r\n}\r\n\r\nexport * from \"loaders/glTF/glTFFileLoader\";\r\nexport * from \"loaders/glTF/glTFValidation\";\r\n","import type { GLTFLoader } from \"./glTFLoader\";\r\nimport type { IGLTFLoaderExtension } from \"./glTFLoaderExtension\";\r\n\r\nimport { Logger } from \"core/Misc/logger\";\r\n\r\ninterface IRegisteredGLTFExtension {\r\n    isGLTFExtension: boolean;\r\n    factory: GLTFExtensionFactory;\r\n}\r\n\r\nexport type GLTFExtensionFactory = (loader: GLTFLoader) => IGLTFLoaderExtension | Promise<IGLTFLoaderExtension>;\r\n\r\nconst RegisteredGLTFExtensions = new Map<string, IRegisteredGLTFExtension>();\r\n\r\n/**\r\n * All currently registered glTF 2.0 loader extensions.\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport const registeredGLTFExtensions: ReadonlyMap<string, Readonly<IRegisteredGLTFExtension>> = RegisteredGLTFExtensions;\r\n\r\n/**\r\n * Registers a loader extension.\r\n * @param name The name of the loader extension.\r\n * @param isGLTFExtension If the loader extension is a glTF extension, then it will only be used for glTF files that use the corresponding glTF extension. Otherwise, it will be used for all loaded glTF files.\r\n * @param factory The factory function that creates the loader extension.\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport function registerGLTFExtension(name: string, isGLTFExtension: boolean, factory: GLTFExtensionFactory): void {\r\n    if (unregisterGLTFExtension(name)) {\r\n        Logger.Warn(`Extension with the name '${name}' already exists`);\r\n    }\r\n\r\n    RegisteredGLTFExtensions.set(name, {\r\n        isGLTFExtension,\r\n        factory,\r\n    });\r\n}\r\n\r\n/**\r\n * Unregisters a loader extension.\r\n * @param name The name of the loader extension.\r\n * @returns A boolean indicating whether the extension has been unregistered\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport function unregisterGLTFExtension(name: string): boolean {\r\n    return RegisteredGLTFExtensions.delete(name);\r\n}\r\n","/* eslint-disable @typescript-eslint/promise-function-async */\r\n/* eslint-disable no-restricted-syntax */\r\n/* eslint-disable github/no-then */\r\nimport type { IndicesArray, Nullable, TypedArray, TypedArrayConstructor } from \"core/types\";\r\nimport { Deferred } from \"core/Misc/deferred\";\r\nimport { Quaternion, Vector3, Matrix, TmpVectors } from \"core/Maths/math.vector\";\r\nimport { Color3 } from \"core/Maths/math.color\";\r\nimport { Tools } from \"core/Misc/tools\";\r\nimport { Camera } from \"core/Cameras/camera\";\r\nimport { FreeCamera } from \"core/Cameras/freeCamera\";\r\nimport type { Animation } from \"core/Animations/animation\";\r\nimport type { IAnimatable } from \"core/Animations/animatable.interface\";\r\nimport type { IAnimationKey } from \"core/Animations/animationKey\";\r\nimport { AnimationKeyInterpolation } from \"core/Animations/animationKey\";\r\nimport type { AnimationGroup } from \"core/Animations/animationGroup\";\r\nimport { Bone } from \"core/Bones/bone\";\r\nimport { Skeleton } from \"core/Bones/skeleton\";\r\nimport { Material } from \"core/Materials/material\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\r\nimport type { ITextureCreationOptions } from \"core/Materials/Textures/texture\";\r\nimport { Texture } from \"core/Materials/Textures/texture\";\r\nimport { TransformNode } from \"core/Meshes/transformNode\";\r\nimport { Buffer, VertexBuffer } from \"core/Buffers/buffer\";\r\nimport { Geometry } from \"core/Meshes/geometry\";\r\nimport { AbstractMesh } from \"core/Meshes/abstractMesh\";\r\nimport { Mesh } from \"core/Meshes/mesh\";\r\nimport { MorphTarget } from \"core/Morph/morphTarget\";\r\nimport { MorphTargetManager } from \"core/Morph/morphTargetManager\";\r\nimport type { ISceneLoaderAsyncResult, ISceneLoaderProgressEvent } from \"core/Loading/sceneLoader\";\r\nimport type { Scene } from \"core/scene\";\r\nimport type { IProperty } from \"babylonjs-gltf2interface\";\r\nimport {\r\n    AnimationChannelTargetPath,\r\n    AnimationSamplerInterpolation,\r\n    AccessorType,\r\n    CameraType,\r\n    AccessorComponentType,\r\n    MaterialAlphaMode,\r\n    TextureMinFilter,\r\n    TextureWrapMode,\r\n    TextureMagFilter,\r\n    MeshPrimitiveMode,\r\n} from \"babylonjs-gltf2interface\";\r\nimport type {\r\n    IGLTF,\r\n    ISampler,\r\n    INode,\r\n    IScene,\r\n    IMesh,\r\n    IAccessor,\r\n    ISkin,\r\n    ICamera,\r\n    IAnimation,\r\n    IBuffer,\r\n    IBufferView,\r\n    IMaterialPbrMetallicRoughness,\r\n    IMaterial,\r\n    ITextureInfo,\r\n    ITexture,\r\n    IImage,\r\n    IMeshPrimitive,\r\n    IArrayItem,\r\n    _ISamplerData,\r\n    IAnimationChannel,\r\n    IAnimationSampler,\r\n    _IAnimationSamplerData,\r\n} from \"./glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"./glTFLoaderExtension\";\r\nimport type { IGLTFLoader, IGLTFLoaderData } from \"../glTFFileLoader\";\r\nimport { GLTFFileLoader, GLTFLoaderState, GLTFLoaderCoordinateSystemMode, GLTFLoaderAnimationStartMode } from \"../glTFFileLoader\";\r\nimport type { IDataBuffer } from \"core/Misc/dataReader\";\r\nimport { DecodeBase64UrlToBinary, GetMimeType, IsBase64DataUrl, LoadFileError } from \"core/Misc/fileTools\";\r\nimport { Logger } from \"core/Misc/logger\";\r\nimport type { Light } from \"core/Lights/light\";\r\nimport { BoundingInfo } from \"core/Culling/boundingInfo\";\r\nimport type { AssetContainer } from \"core/assetContainer\";\r\nimport type { AnimationPropertyInfo } from \"./glTFLoaderAnimation\";\r\nimport type { IObjectInfo } from \"core/ObjectModel/objectModelInterfaces\";\r\nimport { registeredGLTFExtensions, registerGLTFExtension, unregisterGLTFExtension } from \"./glTFLoaderExtensionRegistry\";\r\nimport type { GLTFExtensionFactory } from \"./glTFLoaderExtensionRegistry\";\r\nimport type { IInterpolationPropertyInfo } from \"core/FlowGraph/typeDefinitions\";\r\nimport { GetMappingForKey } from \"./Extensions/objectModelMapping\";\r\nimport { deepMerge } from \"core/Misc/deepMerger\";\r\nimport { GetTypedArrayConstructor } from \"core/Buffers/bufferUtils\";\r\nimport { Lazy } from \"core/Misc/lazy\";\r\n\r\n// Caching these dynamic imports gives a surprising perf boost (compared to importing them directly each time).\r\nconst LazyAnimationGroupModulePromise = new Lazy(() => import(\"core/Animations/animationGroup\"));\r\nconst LazyLoaderAnimationModulePromise = new Lazy(() => import(\"./glTFLoaderAnimation\"));\r\n\r\nexport { GLTFFileLoader };\r\n\r\ninterface ILoaderProperty extends IProperty {\r\n    _activeLoaderExtensionFunctions: {\r\n        [id: string]: boolean;\r\n    };\r\n}\r\n\r\ninterface IWithMetadata {\r\n    metadata: any;\r\n    _internalMetadata: any;\r\n}\r\n\r\n/**\r\n * Helper class for working with arrays when loading the glTF asset\r\n */\r\nexport class ArrayItem {\r\n    /**\r\n     * Gets an item from the given array.\r\n     * @param context The context when loading the asset\r\n     * @param array The array to get the item from\r\n     * @param index The index to the array\r\n     * @returns The array item\r\n     */\r\n    public static Get<T>(context: string, array: ArrayLike<T> | undefined, index: number | undefined): T {\r\n        if (!array || index == undefined || !array[index]) {\r\n            throw new Error(`${context}: Failed to find index (${index})`);\r\n        }\r\n\r\n        return array[index];\r\n    }\r\n\r\n    /**\r\n     * Gets an item from the given array or returns null if not available.\r\n     * @param array The array to get the item from\r\n     * @param index The index to the array\r\n     * @returns The array item or null\r\n     */\r\n    public static TryGet<T>(array: ArrayLike<T> | undefined, index: number | undefined): Nullable<T> {\r\n        if (!array || index == undefined || !array[index]) {\r\n            return null;\r\n        }\r\n\r\n        return array[index];\r\n    }\r\n\r\n    /**\r\n     * Assign an `index` field to each item of the given array.\r\n     * @param array The array of items\r\n     */\r\n    public static Assign(array?: IArrayItem[]): void {\r\n        if (array) {\r\n            for (let index = 0; index < array.length; index++) {\r\n                array[index].index = index;\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\n/** @internal */\r\nexport interface IAnimationTargetInfo {\r\n    /** @internal */\r\n    target: unknown;\r\n\r\n    /** @internal */\r\n    properties: Array<AnimationPropertyInfo>;\r\n}\r\n\r\n/** @internal */\r\nexport function LoadBoundingInfoFromPositionAccessor(accessor: IAccessor): Nullable<BoundingInfo> {\r\n    if (accessor.min && accessor.max) {\r\n        const minArray = accessor.min as [number, number, number];\r\n        const maxArray = accessor.max as [number, number, number];\r\n        const minVector = TmpVectors.Vector3[0].copyFromFloats(minArray[0], minArray[1], minArray[2]);\r\n        const maxVector = TmpVectors.Vector3[1].copyFromFloats(maxArray[0], maxArray[1], maxArray[2]);\r\n        if (accessor.normalized && accessor.componentType !== AccessorComponentType.FLOAT) {\r\n            let divider = 1;\r\n            switch (accessor.componentType) {\r\n                case AccessorComponentType.BYTE:\r\n                    divider = 127.0;\r\n                    break;\r\n                case AccessorComponentType.UNSIGNED_BYTE:\r\n                    divider = 255.0;\r\n                    break;\r\n                case AccessorComponentType.SHORT:\r\n                    divider = 32767.0;\r\n                    break;\r\n                case AccessorComponentType.UNSIGNED_SHORT:\r\n                    divider = 65535.0;\r\n                    break;\r\n            }\r\n            const oneOverDivider = 1 / divider;\r\n            minVector.scaleInPlace(oneOverDivider);\r\n            maxVector.scaleInPlace(oneOverDivider);\r\n        }\r\n        return new BoundingInfo(minVector, maxVector);\r\n    }\r\n    return null;\r\n}\r\n\r\n/**\r\n * The glTF 2.0 loader\r\n */\r\nexport class GLTFLoader implements IGLTFLoader {\r\n    /** @internal */\r\n    public readonly _completePromises = new Array<Promise<unknown>>();\r\n\r\n    /** @internal */\r\n    public _assetContainer: Nullable<AssetContainer> = null;\r\n\r\n    /** Storage */\r\n    public _babylonLights: Light[] = [];\r\n\r\n    /** @internal */\r\n    public _disableInstancedMesh = 0;\r\n\r\n    /** @internal */\r\n    public _allMaterialsDirtyRequired = false;\r\n\r\n    /** @internal */\r\n    public _skipStartAnimationStep = false;\r\n\r\n    private readonly _parent: GLTFFileLoader;\r\n    private readonly _extensions = new Array<IGLTFLoaderExtension>();\r\n    private _disposed = false;\r\n    private _rootUrl: Nullable<string> = null;\r\n    private _fileName: Nullable<string> = null;\r\n    private _uniqueRootUrl: Nullable<string> = null;\r\n    private _gltf: IGLTF;\r\n    private _bin: Nullable<IDataBuffer> = null;\r\n    private _babylonScene: Scene;\r\n    private _rootBabylonMesh: Nullable<TransformNode> = null;\r\n    private _defaultBabylonMaterialData: { [drawMode: number]: Material } = {};\r\n    private readonly _postSceneLoadActions = new Array<() => void>();\r\n\r\n    /**\r\n     * The default glTF sampler.\r\n     */\r\n    public static readonly DefaultSampler: ISampler = { index: -1 };\r\n\r\n    /**\r\n     * Registers a loader extension.\r\n     * @param name The name of the loader extension.\r\n     * @param factory The factory function that creates the loader extension.\r\n     * @deprecated Please use registerGLTFExtension instead.\r\n     */\r\n    public static RegisterExtension(name: string, factory: GLTFExtensionFactory): void {\r\n        registerGLTFExtension(name, false, factory);\r\n    }\r\n\r\n    /**\r\n     * Unregisters a loader extension.\r\n     * @param name The name of the loader extension.\r\n     * @returns A boolean indicating whether the extension has been unregistered\r\n     * @deprecated Please use unregisterGLTFExtension instead.\r\n     */\r\n    public static UnregisterExtension(name: string): boolean {\r\n        return unregisterGLTFExtension(name);\r\n    }\r\n\r\n    /**\r\n     * The object that represents the glTF JSON.\r\n     */\r\n    public get gltf(): IGLTF {\r\n        if (!this._gltf) {\r\n            throw new Error(\"glTF JSON is not available\");\r\n        }\r\n\r\n        return this._gltf;\r\n    }\r\n\r\n    /**\r\n     * The BIN chunk of a binary glTF.\r\n     */\r\n    public get bin(): Nullable<IDataBuffer> {\r\n        return this._bin;\r\n    }\r\n\r\n    /**\r\n     * The parent file loader.\r\n     */\r\n    public get parent(): GLTFFileLoader {\r\n        return this._parent;\r\n    }\r\n\r\n    /**\r\n     * The Babylon scene when loading the asset.\r\n     */\r\n    public get babylonScene(): Scene {\r\n        if (!this._babylonScene) {\r\n            throw new Error(\"Scene is not available\");\r\n        }\r\n\r\n        return this._babylonScene;\r\n    }\r\n\r\n    /**\r\n     * The root Babylon node when loading the asset.\r\n     */\r\n    public get rootBabylonMesh(): Nullable<TransformNode> {\r\n        return this._rootBabylonMesh;\r\n    }\r\n\r\n    /**\r\n     * The root url when loading the asset.\r\n     */\r\n    public get rootUrl(): Nullable<string> {\r\n        return this._rootUrl;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(parent: GLTFFileLoader) {\r\n        this._parent = parent;\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose(): void {\r\n        if (this._disposed) {\r\n            return;\r\n        }\r\n\r\n        this._disposed = true;\r\n\r\n        this._completePromises.length = 0;\r\n\r\n        this._extensions.forEach((extension) => extension.dispose && extension.dispose());\r\n        this._extensions.length = 0;\r\n\r\n        (this._gltf as Nullable<IGLTF>) = null; // TODO\r\n        this._bin = null;\r\n        (this._babylonScene as Nullable<Scene>) = null; // TODO\r\n        this._rootBabylonMesh = null;\r\n        this._defaultBabylonMaterialData = {};\r\n        this._postSceneLoadActions.length = 0;\r\n\r\n        this._parent.dispose();\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public async importMeshAsync(\r\n        meshesNames: string | readonly string[] | null | undefined,\r\n        scene: Scene,\r\n        container: Nullable<AssetContainer>,\r\n        data: IGLTFLoaderData,\r\n        rootUrl: string,\r\n        onProgress?: (event: ISceneLoaderProgressEvent) => void,\r\n        fileName = \"\"\r\n    ): Promise<ISceneLoaderAsyncResult> {\r\n        // eslint-disable-next-line github/no-then\r\n        return await Promise.resolve().then(async () => {\r\n            this._babylonScene = scene;\r\n            this._assetContainer = container;\r\n            this._loadData(data);\r\n\r\n            let nodes: Nullable<Array<number>> = null;\r\n\r\n            if (meshesNames) {\r\n                const nodeMap: { [name: string]: number } = {};\r\n                if (this._gltf.nodes) {\r\n                    for (const node of this._gltf.nodes) {\r\n                        if (node.name) {\r\n                            nodeMap[node.name] = node.index;\r\n                        }\r\n                    }\r\n                }\r\n\r\n                const names = meshesNames instanceof Array ? meshesNames : [meshesNames];\r\n                nodes = names.map((name) => {\r\n                    const node = nodeMap[name];\r\n                    if (node === undefined) {\r\n                        throw new Error(`Failed to find node '${name}'`);\r\n                    }\r\n\r\n                    return node;\r\n                });\r\n            }\r\n\r\n            return await this._loadAsync(rootUrl, fileName, nodes, () => {\r\n                return {\r\n                    meshes: this._getMeshes(),\r\n                    particleSystems: [],\r\n                    skeletons: this._getSkeletons(),\r\n                    animationGroups: this._getAnimationGroups(),\r\n                    lights: this._babylonLights,\r\n                    transformNodes: this._getTransformNodes(),\r\n                    geometries: this._getGeometries(),\r\n                    spriteManagers: [],\r\n                };\r\n            });\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public async loadAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: ISceneLoaderProgressEvent) => void, fileName = \"\"): Promise<void> {\r\n        this._babylonScene = scene;\r\n        this._loadData(data);\r\n        return await this._loadAsync(rootUrl, fileName, null, () => undefined);\r\n    }\r\n\r\n    private async _loadAsync<T>(rootUrl: string, fileName: string, nodes: Nullable<Array<number>>, resultFunc: () => T): Promise<T> {\r\n        return await Promise.resolve()\r\n            .then(async () => {\r\n                this._rootUrl = rootUrl;\r\n                this._uniqueRootUrl = !rootUrl.startsWith(\"file:\") && fileName ? rootUrl : `${rootUrl}${Date.now()}/`;\r\n                this._fileName = fileName;\r\n                this._allMaterialsDirtyRequired = false;\r\n\r\n                await this._loadExtensionsAsync();\r\n\r\n                const loadingToReadyCounterName = `${GLTFLoaderState[GLTFLoaderState.LOADING]} => ${GLTFLoaderState[GLTFLoaderState.READY]}`;\r\n                const loadingToCompleteCounterName = `${GLTFLoaderState[GLTFLoaderState.LOADING]} => ${GLTFLoaderState[GLTFLoaderState.COMPLETE]}`;\r\n\r\n                this._parent._startPerformanceCounter(loadingToReadyCounterName);\r\n                this._parent._startPerformanceCounter(loadingToCompleteCounterName);\r\n\r\n                this._parent._setState(GLTFLoaderState.LOADING);\r\n                this._extensionsOnLoading();\r\n\r\n                const promises = new Array<Promise<unknown>>();\r\n\r\n                // Block the marking of materials dirty until the scene is loaded.\r\n                const oldBlockMaterialDirtyMechanism = this._babylonScene.blockMaterialDirtyMechanism;\r\n                this._babylonScene.blockMaterialDirtyMechanism = true;\r\n\r\n                if (!this.parent.loadOnlyMaterials) {\r\n                    if (nodes) {\r\n                        promises.push(this.loadSceneAsync(\"/nodes\", { nodes: nodes, index: -1 }));\r\n                    } else if (this._gltf.scene != undefined || (this._gltf.scenes && this._gltf.scenes[0])) {\r\n                        const scene = ArrayItem.Get(`/scene`, this._gltf.scenes, this._gltf.scene || 0);\r\n                        promises.push(this.loadSceneAsync(`/scenes/${scene.index}`, scene));\r\n                    }\r\n                }\r\n\r\n                if (!this.parent.skipMaterials && this.parent.loadAllMaterials && this._gltf.materials) {\r\n                    for (let m = 0; m < this._gltf.materials.length; ++m) {\r\n                        const material = this._gltf.materials[m];\r\n                        const context = \"/materials/\" + m;\r\n                        const babylonDrawMode = Material.TriangleFillMode;\r\n\r\n                        promises.push(this._loadMaterialAsync(context, material, null, babylonDrawMode, () => {}));\r\n                    }\r\n                }\r\n\r\n                // Restore the blocking of material dirty.\r\n                if (this._allMaterialsDirtyRequired) {\r\n                    // This can happen if we add a light for instance as it will impact the whole scene.\r\n                    // This automatically resets everything if needed.\r\n                    this._babylonScene.blockMaterialDirtyMechanism = oldBlockMaterialDirtyMechanism;\r\n                } else {\r\n                    // By default a newly created material is dirty so there is no need to flag the full scene as dirty.\r\n                    // For perf reasons, we then bypass blockMaterialDirtyMechanism as this would \"dirty\" the entire scene.\r\n                    this._babylonScene._forceBlockMaterialDirtyMechanism(oldBlockMaterialDirtyMechanism);\r\n                }\r\n\r\n                if (this._parent.compileMaterials) {\r\n                    promises.push(this._compileMaterialsAsync());\r\n                }\r\n\r\n                if (this._parent.compileShadowGenerators) {\r\n                    promises.push(this._compileShadowGeneratorsAsync());\r\n                }\r\n\r\n                const resultPromise = Promise.all(promises).then(() => {\r\n                    if (this._rootBabylonMesh && this._rootBabylonMesh !== this._parent.customRootNode) {\r\n                        this._rootBabylonMesh.setEnabled(true);\r\n                    }\r\n\r\n                    // Making sure we enable enough lights to have all lights together\r\n                    for (const material of this._babylonScene.materials) {\r\n                        const mat = material as any;\r\n\r\n                        if (mat.maxSimultaneousLights !== undefined) {\r\n                            mat.maxSimultaneousLights = Math.max(mat.maxSimultaneousLights, this._babylonScene.lights.length);\r\n                        }\r\n                    }\r\n\r\n                    this._extensionsOnReady();\r\n                    this._parent._setState(GLTFLoaderState.READY);\r\n                    if (!this._skipStartAnimationStep) {\r\n                        this._startAnimations();\r\n                    }\r\n\r\n                    return resultFunc();\r\n                });\r\n\r\n                return await resultPromise.then((result) => {\r\n                    this._parent._endPerformanceCounter(loadingToReadyCounterName);\r\n\r\n                    Tools.SetImmediate(() => {\r\n                        if (!this._disposed) {\r\n                            Promise.all(this._completePromises).then(\r\n                                () => {\r\n                                    this._parent._endPerformanceCounter(loadingToCompleteCounterName);\r\n\r\n                                    this._parent._setState(GLTFLoaderState.COMPLETE);\r\n\r\n                                    this._parent.onCompleteObservable.notifyObservers(undefined);\r\n                                    this._parent.onCompleteObservable.clear();\r\n\r\n                                    this.dispose();\r\n                                },\r\n                                (error) => {\r\n                                    this._parent.onErrorObservable.notifyObservers(error);\r\n                                    this._parent.onErrorObservable.clear();\r\n\r\n                                    this.dispose();\r\n                                }\r\n                            );\r\n                        }\r\n                    });\r\n\r\n                    return result;\r\n                });\r\n            })\r\n            .catch((error) => {\r\n                if (!this._disposed) {\r\n                    this._parent.onErrorObservable.notifyObservers(error);\r\n                    this._parent.onErrorObservable.clear();\r\n\r\n                    this.dispose();\r\n                }\r\n\r\n                throw error;\r\n            });\r\n    }\r\n\r\n    private _loadData(data: IGLTFLoaderData): void {\r\n        this._gltf = data.json as IGLTF;\r\n        this._setupData();\r\n\r\n        if (data.bin) {\r\n            const buffers = this._gltf.buffers;\r\n            if (buffers && buffers[0] && !buffers[0].uri) {\r\n                const binaryBuffer = buffers[0];\r\n                if (binaryBuffer.byteLength < data.bin.byteLength - 3 || binaryBuffer.byteLength > data.bin.byteLength) {\r\n                    Logger.Warn(`Binary buffer length (${binaryBuffer.byteLength}) from JSON does not match chunk length (${data.bin.byteLength})`);\r\n                }\r\n\r\n                this._bin = data.bin;\r\n            } else {\r\n                Logger.Warn(\"Unexpected BIN chunk\");\r\n            }\r\n        }\r\n    }\r\n\r\n    private _setupData(): void {\r\n        ArrayItem.Assign(this._gltf.accessors);\r\n        ArrayItem.Assign(this._gltf.animations);\r\n        ArrayItem.Assign(this._gltf.buffers);\r\n        ArrayItem.Assign(this._gltf.bufferViews);\r\n        ArrayItem.Assign(this._gltf.cameras);\r\n        ArrayItem.Assign(this._gltf.images);\r\n        ArrayItem.Assign(this._gltf.materials);\r\n        ArrayItem.Assign(this._gltf.meshes);\r\n        ArrayItem.Assign(this._gltf.nodes);\r\n        ArrayItem.Assign(this._gltf.samplers);\r\n        ArrayItem.Assign(this._gltf.scenes);\r\n        ArrayItem.Assign(this._gltf.skins);\r\n        ArrayItem.Assign(this._gltf.textures);\r\n\r\n        if (this._gltf.nodes) {\r\n            const nodeParents: { [index: number]: number } = {};\r\n            for (const node of this._gltf.nodes) {\r\n                if (node.children) {\r\n                    for (const index of node.children) {\r\n                        nodeParents[index] = node.index;\r\n                    }\r\n                }\r\n            }\r\n\r\n            const rootNode = this._createRootNode();\r\n            for (const node of this._gltf.nodes) {\r\n                const parentIndex = nodeParents[node.index];\r\n                node.parent = parentIndex === undefined ? rootNode : this._gltf.nodes[parentIndex];\r\n            }\r\n        }\r\n    }\r\n\r\n    private async _loadExtensionsAsync() {\r\n        const extensionPromises: Promise<IGLTFLoaderExtension>[] = [];\r\n\r\n        registeredGLTFExtensions.forEach((registeredExtension, name) => {\r\n            // Don't load explicitly disabled extensions.\r\n            if (this.parent.extensionOptions[name]?.enabled === false) {\r\n                // But warn if the disabled extension is used by the model.\r\n                if (registeredExtension.isGLTFExtension && this.isExtensionUsed(name)) {\r\n                    Logger.Warn(`Extension ${name} is used but has been explicitly disabled.`);\r\n                }\r\n            }\r\n            // Load loader extensions that are not a glTF extension, as well as extensions that are glTF extensions and are used by the model.\r\n            else if (!registeredExtension.isGLTFExtension || this.isExtensionUsed(name)) {\r\n                extensionPromises.push(\r\n                    (async () => {\r\n                        const extension = await registeredExtension.factory(this);\r\n                        if (extension.name !== name) {\r\n                            Logger.Warn(`The name of the glTF loader extension instance does not match the registered name: ${extension.name} !== ${name}`);\r\n                        }\r\n\r\n                        this._parent.onExtensionLoadedObservable.notifyObservers(extension);\r\n                        return extension;\r\n                    })()\r\n                );\r\n            }\r\n        });\r\n\r\n        this._extensions.push(...(await Promise.all(extensionPromises)));\r\n\r\n        this._extensions.sort((a, b) => (a.order || Number.MAX_VALUE) - (b.order || Number.MAX_VALUE));\r\n        this._parent.onExtensionLoadedObservable.clear();\r\n\r\n        if (this._gltf.extensionsRequired) {\r\n            for (const name of this._gltf.extensionsRequired) {\r\n                const available = this._extensions.some((extension) => extension.name === name && extension.enabled);\r\n                if (!available) {\r\n                    if (this.parent.extensionOptions[name]?.enabled === false) {\r\n                        throw new Error(`Required extension ${name} is disabled`);\r\n                    }\r\n                    throw new Error(`Required extension ${name} is not available`);\r\n                }\r\n            }\r\n        }\r\n    }\r\n\r\n    private _createRootNode(): INode {\r\n        if (this._parent.customRootNode !== undefined) {\r\n            this._rootBabylonMesh = this._parent.customRootNode;\r\n            return {\r\n                // eslint-disable-next-line @typescript-eslint/naming-convention\r\n                _babylonTransformNode: this._rootBabylonMesh === null ? undefined : this._rootBabylonMesh,\r\n                index: -1,\r\n            };\r\n        }\r\n        this._babylonScene._blockEntityCollection = !!this._assetContainer;\r\n        const rootMesh = new Mesh(\"__root__\", this._babylonScene);\r\n        this._rootBabylonMesh = rootMesh;\r\n        this._rootBabylonMesh._parentContainer = this._assetContainer;\r\n        this._babylonScene._blockEntityCollection = false;\r\n        this._rootBabylonMesh.setEnabled(false);\r\n\r\n        const rootNode: INode = {\r\n            // eslint-disable-next-line @typescript-eslint/naming-convention\r\n            _babylonTransformNode: this._rootBabylonMesh,\r\n            index: -1,\r\n        };\r\n\r\n        switch (this._parent.coordinateSystemMode) {\r\n            case GLTFLoaderCoordinateSystemMode.AUTO: {\r\n                if (!this._babylonScene.useRightHandedSystem) {\r\n                    rootNode.rotation = [0, 1, 0, 0];\r\n                    rootNode.scale = [1, 1, -1];\r\n                    GLTFLoader._LoadTransform(rootNode, this._rootBabylonMesh);\r\n                }\r\n                break;\r\n            }\r\n            case GLTFLoaderCoordinateSystemMode.FORCE_RIGHT_HANDED: {\r\n                this._babylonScene.useRightHandedSystem = true;\r\n                break;\r\n            }\r\n            default: {\r\n                throw new Error(`Invalid coordinate system mode (${this._parent.coordinateSystemMode})`);\r\n            }\r\n        }\r\n\r\n        this._parent.onMeshLoadedObservable.notifyObservers(rootMesh);\r\n        return rootNode;\r\n    }\r\n\r\n    /**\r\n     * Loads a glTF scene.\r\n     * @param context The context when loading the asset\r\n     * @param scene The glTF scene property\r\n     * @returns A promise that resolves when the load is complete\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax, @typescript-eslint/promise-function-async\r\n    public loadSceneAsync(context: string, scene: IScene): Promise<void> {\r\n        const extensionPromise = this._extensionsLoadSceneAsync(context, scene);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        this.logOpen(`${context} ${scene.name || \"\"}`);\r\n\r\n        if (scene.nodes) {\r\n            for (const index of scene.nodes) {\r\n                const node = ArrayItem.Get(`${context}/nodes/${index}`, this._gltf.nodes, index);\r\n                promises.push(\r\n                    this.loadNodeAsync(`/nodes/${node.index}`, node, (babylonMesh) => {\r\n                        babylonMesh.parent = this._rootBabylonMesh;\r\n                    })\r\n                );\r\n            }\r\n        }\r\n\r\n        for (const action of this._postSceneLoadActions) {\r\n            action();\r\n        }\r\n\r\n        promises.push(this._loadAnimationsAsync());\r\n\r\n        this.logClose();\r\n\r\n        return Promise.all(promises).then(() => {});\r\n    }\r\n\r\n    private _forEachPrimitive(node: INode, callback: (babylonMesh: AbstractMesh) => void): void {\r\n        if (node._primitiveBabylonMeshes) {\r\n            for (const babylonMesh of node._primitiveBabylonMeshes) {\r\n                callback(babylonMesh);\r\n            }\r\n        }\r\n    }\r\n\r\n    private _getGeometries(): Geometry[] {\r\n        const geometries: Geometry[] = [];\r\n\r\n        const nodes = this._gltf.nodes;\r\n        if (nodes) {\r\n            for (const node of nodes) {\r\n                this._forEachPrimitive(node, (babylonMesh) => {\r\n                    const geometry = (babylonMesh as Mesh).geometry;\r\n                    if (geometry && geometries.indexOf(geometry) === -1) {\r\n                        geometries.push(geometry);\r\n                    }\r\n                });\r\n            }\r\n        }\r\n\r\n        return geometries;\r\n    }\r\n\r\n    private _getMeshes(): AbstractMesh[] {\r\n        const meshes: AbstractMesh[] = [];\r\n\r\n        // Root mesh is always first, if available.\r\n        if (this._rootBabylonMesh instanceof AbstractMesh) {\r\n            meshes.push(this._rootBabylonMesh);\r\n        }\r\n\r\n        const nodes = this._gltf.nodes;\r\n        if (nodes) {\r\n            for (const node of nodes) {\r\n                this._forEachPrimitive(node, (babylonMesh) => {\r\n                    meshes.push(babylonMesh);\r\n                });\r\n            }\r\n        }\r\n\r\n        return meshes;\r\n    }\r\n\r\n    private _getTransformNodes(): TransformNode[] {\r\n        const transformNodes: TransformNode[] = [];\r\n\r\n        const nodes = this._gltf.nodes;\r\n        if (nodes) {\r\n            for (const node of nodes) {\r\n                if (node._babylonTransformNode && node._babylonTransformNode.getClassName() === \"TransformNode\") {\r\n                    transformNodes.push(node._babylonTransformNode);\r\n                }\r\n                if (node._babylonTransformNodeForSkin) {\r\n                    transformNodes.push(node._babylonTransformNodeForSkin);\r\n                }\r\n            }\r\n        }\r\n\r\n        return transformNodes;\r\n    }\r\n\r\n    private _getSkeletons(): Skeleton[] {\r\n        const skeletons: Skeleton[] = [];\r\n\r\n        const skins = this._gltf.skins;\r\n        if (skins) {\r\n            for (const skin of skins) {\r\n                if (skin._data) {\r\n                    skeletons.push(skin._data.babylonSkeleton);\r\n                }\r\n            }\r\n        }\r\n\r\n        return skeletons;\r\n    }\r\n\r\n    private _getAnimationGroups(): AnimationGroup[] {\r\n        const animationGroups: AnimationGroup[] = [];\r\n\r\n        const animations = this._gltf.animations;\r\n        if (animations) {\r\n            for (const animation of animations) {\r\n                if (animation._babylonAnimationGroup) {\r\n                    animationGroups.push(animation._babylonAnimationGroup);\r\n                }\r\n            }\r\n        }\r\n\r\n        return animationGroups;\r\n    }\r\n\r\n    private _startAnimations(): void {\r\n        switch (this._parent.animationStartMode) {\r\n            case GLTFLoaderAnimationStartMode.NONE: {\r\n                // do nothing\r\n                break;\r\n            }\r\n            case GLTFLoaderAnimationStartMode.FIRST: {\r\n                const babylonAnimationGroups = this._getAnimationGroups();\r\n                if (babylonAnimationGroups.length !== 0) {\r\n                    babylonAnimationGroups[0].start(true);\r\n                }\r\n                break;\r\n            }\r\n            case GLTFLoaderAnimationStartMode.ALL: {\r\n                const babylonAnimationGroups = this._getAnimationGroups();\r\n                for (const babylonAnimationGroup of babylonAnimationGroups) {\r\n                    babylonAnimationGroup.start(true);\r\n                }\r\n                break;\r\n            }\r\n            default: {\r\n                Logger.Error(`Invalid animation start mode (${this._parent.animationStartMode})`);\r\n                return;\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Loads a glTF node.\r\n     * @param context The context when loading the asset\r\n     * @param node The glTF node property\r\n     * @param assign A function called synchronously after parsing the glTF properties\r\n     * @returns A promise that resolves with the loaded Babylon mesh when the load is complete\r\n     */\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    public loadNodeAsync(context: string, node: INode, assign: (babylonTransformNode: TransformNode) => void = () => {}): Promise<TransformNode> {\r\n        const extensionPromise = this._extensionsLoadNodeAsync(context, node, assign);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        if (node._babylonTransformNode) {\r\n            throw new Error(`${context}: Invalid recursive node hierarchy`);\r\n        }\r\n\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        this.logOpen(`${context} ${node.name || \"\"}`);\r\n\r\n        const loadNode = (babylonTransformNode: TransformNode) => {\r\n            GLTFLoader.AddPointerMetadata(babylonTransformNode, context);\r\n            GLTFLoader._LoadTransform(node, babylonTransformNode);\r\n\r\n            if (node.camera != undefined) {\r\n                const camera = ArrayItem.Get(`${context}/camera`, this._gltf.cameras, node.camera);\r\n                promises.push(\r\n                    this.loadCameraAsync(`/cameras/${camera.index}`, camera, (babylonCamera) => {\r\n                        babylonCamera.parent = babylonTransformNode;\r\n                        if (!this._babylonScene.useRightHandedSystem) {\r\n                            babylonTransformNode.scaling.x = -1; // Cancelling root node scaling for handedness so the view matrix does not end up flipped.\r\n                        }\r\n                    })\r\n                );\r\n            }\r\n\r\n            if (node.children) {\r\n                for (const index of node.children) {\r\n                    const childNode = ArrayItem.Get(`${context}/children/${index}`, this._gltf.nodes, index);\r\n                    promises.push(\r\n                        this.loadNodeAsync(`/nodes/${childNode.index}`, childNode, (childBabylonMesh) => {\r\n                            childBabylonMesh.parent = babylonTransformNode;\r\n                        })\r\n                    );\r\n                }\r\n            }\r\n\r\n            assign(babylonTransformNode);\r\n        };\r\n\r\n        const hasMesh = node.mesh != undefined;\r\n        const hasSkin = this._parent.loadSkins && node.skin != undefined;\r\n\r\n        if (!hasMesh || hasSkin) {\r\n            const nodeName = node.name || `node${node.index}`;\r\n            this._babylonScene._blockEntityCollection = !!this._assetContainer;\r\n            const transformNode = new TransformNode(nodeName, this._babylonScene);\r\n            transformNode._parentContainer = this._assetContainer;\r\n            this._babylonScene._blockEntityCollection = false;\r\n            if (node.mesh == undefined) {\r\n                node._babylonTransformNode = transformNode;\r\n            } else {\r\n                node._babylonTransformNodeForSkin = transformNode;\r\n            }\r\n            loadNode(transformNode);\r\n        }\r\n\r\n        if (hasMesh) {\r\n            if (hasSkin) {\r\n                // See https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins (second implementation note)\r\n                // This code path will place the skinned mesh as a sibling of the skeleton root node without loading the\r\n                // transform, which effectively ignores the transform of the skinned mesh, as per spec.\r\n\r\n                const mesh = ArrayItem.Get(`${context}/mesh`, this._gltf.meshes, node.mesh);\r\n                promises.push(\r\n                    this._loadMeshAsync(`/meshes/${mesh.index}`, node, mesh, (babylonTransformNode) => {\r\n                        const babylonTransformNodeForSkin = node._babylonTransformNodeForSkin!;\r\n\r\n                        // Merge the metadata from the skin node to the skinned mesh in case a loader extension added metadata.\r\n                        babylonTransformNode.metadata = deepMerge(babylonTransformNodeForSkin.metadata, babylonTransformNode.metadata || {});\r\n\r\n                        const skin = ArrayItem.Get(`${context}/skin`, this._gltf.skins, node.skin);\r\n                        promises.push(\r\n                            this._loadSkinAsync(`/skins/${skin.index}`, node, skin, (babylonSkeleton) => {\r\n                                this._forEachPrimitive(node, (babylonMesh) => {\r\n                                    babylonMesh.skeleton = babylonSkeleton;\r\n                                });\r\n\r\n                                // Wait until all the nodes are parented before parenting the skinned mesh.\r\n                                this._postSceneLoadActions.push(() => {\r\n                                    if (skin.skeleton != undefined) {\r\n                                        // Place the skinned mesh node as a sibling of the skeleton root node.\r\n                                        // Handle special case when the parent of the skeleton root is the skinned mesh.\r\n                                        const parentNode = ArrayItem.Get(`/skins/${skin.index}/skeleton`, this._gltf.nodes, skin.skeleton).parent!;\r\n                                        if (node.index === parentNode.index) {\r\n                                            babylonTransformNode.parent = babylonTransformNodeForSkin.parent;\r\n                                        } else {\r\n                                            babylonTransformNode.parent = parentNode._babylonTransformNode!;\r\n                                        }\r\n                                    } else {\r\n                                        babylonTransformNode.parent = this._rootBabylonMesh;\r\n                                    }\r\n\r\n                                    this._parent.onSkinLoadedObservable.notifyObservers({ node: babylonTransformNodeForSkin, skinnedNode: babylonTransformNode });\r\n                                });\r\n                            })\r\n                        );\r\n                    })\r\n                );\r\n            } else {\r\n                const mesh = ArrayItem.Get(`${context}/mesh`, this._gltf.meshes, node.mesh);\r\n                promises.push(this._loadMeshAsync(`/meshes/${mesh.index}`, node, mesh, loadNode));\r\n            }\r\n        }\r\n\r\n        this.logClose();\r\n\r\n        return Promise.all(promises).then(() => {\r\n            this._forEachPrimitive(node, (babylonMesh) => {\r\n                const asMesh = babylonMesh as Mesh;\r\n                if (!asMesh.isAnInstance && asMesh.geometry && asMesh.geometry.useBoundingInfoFromGeometry) {\r\n                    // simply apply the world matrices to the bounding info - the extends are already ok\r\n                    babylonMesh._updateBoundingInfo();\r\n                } else {\r\n                    babylonMesh.refreshBoundingInfo(true, true);\r\n                }\r\n            });\r\n\r\n            return node._babylonTransformNode!;\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadMeshAsync(context: string, node: INode, mesh: IMesh, assign: (babylonTransformNode: TransformNode) => void): Promise<TransformNode> {\r\n        const primitives = mesh.primitives;\r\n        if (!primitives || !primitives.length) {\r\n            throw new Error(`${context}: Primitives are missing`);\r\n        }\r\n\r\n        if (primitives[0].index == undefined) {\r\n            ArrayItem.Assign(primitives);\r\n        }\r\n\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        this.logOpen(`${context} ${mesh.name || \"\"}`);\r\n\r\n        const name = node.name || `node${node.index}`;\r\n\r\n        if (primitives.length === 1) {\r\n            const primitive = mesh.primitives[0];\r\n            promises.push(\r\n                this._loadMeshPrimitiveAsync(`${context}/primitives/${primitive.index}`, name, node, mesh, primitive, (babylonMesh) => {\r\n                    node._babylonTransformNode = babylonMesh;\r\n                    node._primitiveBabylonMeshes = [babylonMesh];\r\n                })\r\n            );\r\n        } else {\r\n            this._babylonScene._blockEntityCollection = !!this._assetContainer;\r\n            node._babylonTransformNode = new TransformNode(name, this._babylonScene);\r\n            node._babylonTransformNode._parentContainer = this._assetContainer;\r\n            this._babylonScene._blockEntityCollection = false;\r\n            node._primitiveBabylonMeshes = [];\r\n            for (const primitive of primitives) {\r\n                promises.push(\r\n                    this._loadMeshPrimitiveAsync(`${context}/primitives/${primitive.index}`, `${name}_primitive${primitive.index}`, node, mesh, primitive, (babylonMesh) => {\r\n                        babylonMesh.parent = node._babylonTransformNode!;\r\n                        node._primitiveBabylonMeshes!.push(babylonMesh);\r\n                    })\r\n                );\r\n            }\r\n        }\r\n\r\n        assign(node._babylonTransformNode!);\r\n\r\n        this.logClose();\r\n\r\n        return Promise.all(promises).then(() => {\r\n            return node._babylonTransformNode!;\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @internal Define this method to modify the default behavior when loading data for mesh primitives.\r\n     * @param context The context when loading the asset\r\n     * @param name The mesh name when loading the asset\r\n     * @param node The glTF node when loading the asset\r\n     * @param mesh The glTF mesh when loading the asset\r\n     * @param primitive The glTF mesh primitive property\r\n     * @param assign A function called synchronously after parsing the glTF properties\r\n     * @returns A promise that resolves with the loaded mesh when the load is complete or null if not handled\r\n     */\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    public _loadMeshPrimitiveAsync(\r\n        context: string,\r\n        name: string,\r\n        node: INode,\r\n        mesh: IMesh,\r\n        primitive: IMeshPrimitive,\r\n        assign: (babylonMesh: AbstractMesh) => void\r\n    ): Promise<AbstractMesh> {\r\n        const extensionPromise = this._extensionsLoadMeshPrimitiveAsync(context, name, node, mesh, primitive, assign);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        this.logOpen(`${context}`);\r\n\r\n        const shouldInstance = this._disableInstancedMesh === 0 && this._parent.createInstances && node.skin == undefined && !mesh.primitives[0].targets;\r\n\r\n        let babylonAbstractMesh: AbstractMesh;\r\n        let promise: Promise<unknown>;\r\n\r\n        if (shouldInstance && primitive._instanceData) {\r\n            this._babylonScene._blockEntityCollection = !!this._assetContainer;\r\n            babylonAbstractMesh = primitive._instanceData.babylonSourceMesh.createInstance(name);\r\n            babylonAbstractMesh._parentContainer = this._assetContainer;\r\n            this._babylonScene._blockEntityCollection = false;\r\n            promise = primitive._instanceData.promise;\r\n        } else {\r\n            const promises = new Array<Promise<unknown>>();\r\n\r\n            this._babylonScene._blockEntityCollection = !!this._assetContainer;\r\n            const babylonMesh = new Mesh(name, this._babylonScene);\r\n            babylonMesh._parentContainer = this._assetContainer;\r\n            this._babylonScene._blockEntityCollection = false;\r\n            babylonMesh.sideOrientation = this._babylonScene.useRightHandedSystem ? Material.CounterClockWiseSideOrientation : Material.ClockWiseSideOrientation;\r\n\r\n            this._createMorphTargets(context, node, mesh, primitive, babylonMesh);\r\n            promises.push(\r\n                this._loadVertexDataAsync(context, primitive, babylonMesh).then(async (babylonGeometry) => {\r\n                    return await this._loadMorphTargetsAsync(context, primitive, babylonMesh, babylonGeometry).then(() => {\r\n                        if (this._disposed) {\r\n                            return;\r\n                        }\r\n\r\n                        this._babylonScene._blockEntityCollection = !!this._assetContainer;\r\n                        babylonGeometry.applyToMesh(babylonMesh);\r\n                        babylonGeometry._parentContainer = this._assetContainer;\r\n                        this._babylonScene._blockEntityCollection = false;\r\n                    });\r\n                })\r\n            );\r\n\r\n            const babylonDrawMode = GLTFLoader._GetDrawMode(context, primitive.mode);\r\n            if (primitive.material == undefined) {\r\n                let babylonMaterial = this._defaultBabylonMaterialData[babylonDrawMode];\r\n                if (!babylonMaterial) {\r\n                    babylonMaterial = this._createDefaultMaterial(\"__GLTFLoader._default\", babylonDrawMode);\r\n                    this._parent.onMaterialLoadedObservable.notifyObservers(babylonMaterial);\r\n                    this._defaultBabylonMaterialData[babylonDrawMode] = babylonMaterial;\r\n                }\r\n                babylonMesh.material = babylonMaterial;\r\n            } else if (!this.parent.skipMaterials) {\r\n                const material = ArrayItem.Get(`${context}/material`, this._gltf.materials, primitive.material);\r\n                promises.push(\r\n                    this._loadMaterialAsync(`/materials/${material.index}`, material, babylonMesh, babylonDrawMode, (babylonMaterial) => {\r\n                        babylonMesh.material = babylonMaterial;\r\n                    })\r\n                );\r\n            }\r\n\r\n            promise = Promise.all(promises);\r\n\r\n            if (shouldInstance) {\r\n                primitive._instanceData = {\r\n                    babylonSourceMesh: babylonMesh,\r\n                    promise: promise,\r\n                };\r\n            }\r\n\r\n            babylonAbstractMesh = babylonMesh;\r\n        }\r\n\r\n        GLTFLoader.AddPointerMetadata(babylonAbstractMesh, context);\r\n        this._parent.onMeshLoadedObservable.notifyObservers(babylonAbstractMesh);\r\n        assign(babylonAbstractMesh);\r\n\r\n        this.logClose();\r\n\r\n        return promise.then(() => {\r\n            return babylonAbstractMesh;\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadVertexDataAsync(context: string, primitive: IMeshPrimitive, babylonMesh: Mesh): Promise<Geometry> {\r\n        const extensionPromise = this._extensionsLoadVertexDataAsync(context, primitive, babylonMesh);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        const attributes = primitive.attributes;\r\n        if (!attributes) {\r\n            throw new Error(`${context}: Attributes are missing`);\r\n        }\r\n\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        const babylonGeometry = new Geometry(babylonMesh.name, this._babylonScene);\r\n\r\n        if (primitive.indices == undefined) {\r\n            babylonMesh.isUnIndexed = true;\r\n        } else {\r\n            const accessor = ArrayItem.Get(`${context}/indices`, this._gltf.accessors, primitive.indices);\r\n            promises.push(\r\n                this._loadIndicesAccessorAsync(`/accessors/${accessor.index}`, accessor).then((data) => {\r\n                    babylonGeometry.setIndices(data);\r\n                })\r\n            );\r\n        }\r\n\r\n        const loadAttribute = (name: string, kind: string, callback?: (accessor: IAccessor) => void) => {\r\n            if (attributes[name] == undefined) {\r\n                return;\r\n            }\r\n\r\n            babylonMesh._delayInfo = babylonMesh._delayInfo || [];\r\n            if (babylonMesh._delayInfo.indexOf(kind) === -1) {\r\n                babylonMesh._delayInfo.push(kind);\r\n            }\r\n\r\n            const accessor = ArrayItem.Get(`${context}/attributes/${name}`, this._gltf.accessors, attributes[name]);\r\n            promises.push(\r\n                this._loadVertexAccessorAsync(`/accessors/${accessor.index}`, accessor, kind).then((babylonVertexBuffer) => {\r\n                    if (babylonVertexBuffer.getKind() === VertexBuffer.PositionKind && !this.parent.alwaysComputeBoundingBox && !babylonMesh.skeleton) {\r\n                        const babylonBoundingInfo = LoadBoundingInfoFromPositionAccessor(accessor);\r\n                        if (babylonBoundingInfo) {\r\n                            babylonGeometry._boundingInfo = babylonBoundingInfo;\r\n                            babylonGeometry.useBoundingInfoFromGeometry = true;\r\n                        }\r\n                    }\r\n                    babylonGeometry.setVerticesBuffer(babylonVertexBuffer, accessor.count);\r\n                })\r\n            );\r\n\r\n            if (kind == VertexBuffer.MatricesIndicesExtraKind) {\r\n                babylonMesh.numBoneInfluencers = 8;\r\n            }\r\n\r\n            if (callback) {\r\n                callback(accessor);\r\n            }\r\n        };\r\n\r\n        loadAttribute(\"POSITION\", VertexBuffer.PositionKind);\r\n        loadAttribute(\"NORMAL\", VertexBuffer.NormalKind);\r\n        loadAttribute(\"TANGENT\", VertexBuffer.TangentKind);\r\n        loadAttribute(\"TEXCOORD_0\", VertexBuffer.UVKind);\r\n        loadAttribute(\"TEXCOORD_1\", VertexBuffer.UV2Kind);\r\n        loadAttribute(\"TEXCOORD_2\", VertexBuffer.UV3Kind);\r\n        loadAttribute(\"TEXCOORD_3\", VertexBuffer.UV4Kind);\r\n        loadAttribute(\"TEXCOORD_4\", VertexBuffer.UV5Kind);\r\n        loadAttribute(\"TEXCOORD_5\", VertexBuffer.UV6Kind);\r\n        loadAttribute(\"JOINTS_0\", VertexBuffer.MatricesIndicesKind);\r\n        loadAttribute(\"WEIGHTS_0\", VertexBuffer.MatricesWeightsKind);\r\n        loadAttribute(\"JOINTS_1\", VertexBuffer.MatricesIndicesExtraKind);\r\n        loadAttribute(\"WEIGHTS_1\", VertexBuffer.MatricesWeightsExtraKind);\r\n        loadAttribute(\"COLOR_0\", VertexBuffer.ColorKind, (accessor) => {\r\n            if (accessor.type === AccessorType.VEC4) {\r\n                babylonMesh.hasVertexAlpha = true;\r\n            }\r\n        });\r\n\r\n        return Promise.all(promises).then(() => {\r\n            return babylonGeometry;\r\n        });\r\n    }\r\n\r\n    private _createMorphTargets(context: string, node: INode, mesh: IMesh, primitive: IMeshPrimitive, babylonMesh: Mesh): void {\r\n        if (!primitive.targets || !this._parent.loadMorphTargets) {\r\n            return;\r\n        }\r\n\r\n        if (node._numMorphTargets == undefined) {\r\n            node._numMorphTargets = primitive.targets.length;\r\n        } else if (primitive.targets.length !== node._numMorphTargets) {\r\n            throw new Error(`${context}: Primitives do not have the same number of targets`);\r\n        }\r\n\r\n        const targetNames = mesh.extras ? mesh.extras.targetNames : null;\r\n\r\n        this._babylonScene._blockEntityCollection = !!this._assetContainer;\r\n        babylonMesh.morphTargetManager = new MorphTargetManager(this._babylonScene);\r\n        babylonMesh.morphTargetManager._parentContainer = this._assetContainer;\r\n        this._babylonScene._blockEntityCollection = false;\r\n\r\n        babylonMesh.morphTargetManager.areUpdatesFrozen = true;\r\n\r\n        for (let index = 0; index < primitive.targets.length; index++) {\r\n            const weight = node.weights ? node.weights[index] : mesh.weights ? mesh.weights[index] : 0;\r\n            const name = targetNames ? targetNames[index] : `morphTarget${index}`;\r\n            babylonMesh.morphTargetManager.addTarget(new MorphTarget(name, weight, babylonMesh.getScene()));\r\n            // TODO: tell the target whether it has positions, normals, tangents\r\n        }\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadMorphTargetsAsync(context: string, primitive: IMeshPrimitive, babylonMesh: Mesh, babylonGeometry: Geometry): Promise<void> {\r\n        if (!primitive.targets || !this._parent.loadMorphTargets) {\r\n            return Promise.resolve();\r\n        }\r\n\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        const morphTargetManager = babylonMesh.morphTargetManager!;\r\n        for (let index = 0; index < morphTargetManager.numTargets; index++) {\r\n            const babylonMorphTarget = morphTargetManager.getTarget(index);\r\n            promises.push(this._loadMorphTargetVertexDataAsync(`${context}/targets/${index}`, babylonGeometry, primitive.targets[index], babylonMorphTarget));\r\n        }\r\n\r\n        return Promise.all(promises).then(() => {\r\n            morphTargetManager.areUpdatesFrozen = false;\r\n        });\r\n    }\r\n\r\n    private async _loadMorphTargetVertexDataAsync(\r\n        context: string,\r\n        babylonGeometry: Geometry,\r\n        attributes: { [name: string]: number },\r\n        babylonMorphTarget: MorphTarget\r\n    ): Promise<void> {\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        const loadAttribute = (attribute: string, kind: string, setData: (babylonVertexBuffer: VertexBuffer, data: Float32Array) => void) => {\r\n            if (attributes[attribute] == undefined) {\r\n                return;\r\n            }\r\n\r\n            const babylonVertexBuffer = babylonGeometry.getVertexBuffer(kind);\r\n            if (!babylonVertexBuffer) {\r\n                return;\r\n            }\r\n\r\n            const accessor = ArrayItem.Get(`${context}/${attribute}`, this._gltf.accessors, attributes[attribute]);\r\n            promises.push(\r\n                this._loadFloatAccessorAsync(`/accessors/${accessor.index}`, accessor).then((data) => {\r\n                    setData(babylonVertexBuffer, data);\r\n                })\r\n            );\r\n        };\r\n\r\n        loadAttribute(\"POSITION\", VertexBuffer.PositionKind, (babylonVertexBuffer, data) => {\r\n            const positions = new Float32Array(data.length);\r\n            babylonVertexBuffer.forEach(data.length, (value, index) => {\r\n                positions[index] = data[index] + value;\r\n            });\r\n\r\n            babylonMorphTarget.setPositions(positions);\r\n        });\r\n\r\n        loadAttribute(\"NORMAL\", VertexBuffer.NormalKind, (babylonVertexBuffer, data) => {\r\n            const normals = new Float32Array(data.length);\r\n            babylonVertexBuffer.forEach(normals.length, (value, index) => {\r\n                normals[index] = data[index] + value;\r\n            });\r\n\r\n            babylonMorphTarget.setNormals(normals);\r\n        });\r\n\r\n        loadAttribute(\"TANGENT\", VertexBuffer.TangentKind, (babylonVertexBuffer, data) => {\r\n            const tangents = new Float32Array((data.length / 3) * 4);\r\n            let dataIndex = 0;\r\n            babylonVertexBuffer.forEach((data.length / 3) * 4, (value, index) => {\r\n                // Tangent data for morph targets is stored as xyz delta.\r\n                // The vertexData.tangent is stored as xyzw.\r\n                // So we need to skip every fourth vertexData.tangent.\r\n                if ((index + 1) % 4 !== 0) {\r\n                    tangents[dataIndex] = data[dataIndex] + value;\r\n                    dataIndex++;\r\n                }\r\n            });\r\n            babylonMorphTarget.setTangents(tangents);\r\n        });\r\n\r\n        loadAttribute(\"TEXCOORD_0\", VertexBuffer.UVKind, (babylonVertexBuffer, data) => {\r\n            const uvs = new Float32Array(data.length);\r\n            babylonVertexBuffer.forEach(data.length, (value, index) => {\r\n                uvs[index] = data[index] + value;\r\n            });\r\n\r\n            babylonMorphTarget.setUVs(uvs);\r\n        });\r\n\r\n        loadAttribute(\"TEXCOORD_1\", VertexBuffer.UV2Kind, (babylonVertexBuffer, data) => {\r\n            const uvs = new Float32Array(data.length);\r\n            babylonVertexBuffer.forEach(data.length, (value, index) => {\r\n                uvs[index] = data[index] + value;\r\n            });\r\n\r\n            babylonMorphTarget.setUV2s(uvs);\r\n        });\r\n\r\n        loadAttribute(\"COLOR_0\", VertexBuffer.ColorKind, (babylonVertexBuffer, data) => {\r\n            let colors = null;\r\n            const componentSize = babylonVertexBuffer.getSize();\r\n            if (componentSize === 3) {\r\n                colors = new Float32Array((data.length / 3) * 4);\r\n                babylonVertexBuffer.forEach(data.length, (value, index) => {\r\n                    const pixid = Math.floor(index / 3);\r\n                    const channel = index % 3;\r\n                    colors[4 * pixid + channel] = data[3 * pixid + channel] + value;\r\n                });\r\n                for (let i = 0; i < data.length / 3; ++i) {\r\n                    colors[4 * i + 3] = 1;\r\n                }\r\n            } else if (componentSize === 4) {\r\n                colors = new Float32Array(data.length);\r\n                babylonVertexBuffer.forEach(data.length, (value, index) => {\r\n                    colors[index] = data[index] + value;\r\n                });\r\n            } else {\r\n                throw new Error(`${context}: Invalid number of components (${componentSize}) for COLOR_0 attribute`);\r\n            }\r\n            babylonMorphTarget.setColors(colors);\r\n        });\r\n\r\n        return await Promise.all(promises).then(() => {});\r\n    }\r\n\r\n    private static _LoadTransform(node: INode, babylonNode: TransformNode): void {\r\n        // Ignore the TRS of skinned nodes.\r\n        // See https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins (second implementation note)\r\n        if (node.skin != undefined) {\r\n            return;\r\n        }\r\n\r\n        let position = Vector3.Zero();\r\n        let rotation = Quaternion.Identity();\r\n        let scaling = Vector3.One();\r\n\r\n        if (node.matrix) {\r\n            const matrix = Matrix.FromArray(node.matrix);\r\n            matrix.decompose(scaling, rotation, position);\r\n        } else {\r\n            if (node.translation) {\r\n                position = Vector3.FromArray(node.translation);\r\n            }\r\n            if (node.rotation) {\r\n                rotation = Quaternion.FromArray(node.rotation);\r\n            }\r\n            if (node.scale) {\r\n                scaling = Vector3.FromArray(node.scale);\r\n            }\r\n        }\r\n\r\n        babylonNode.position = position;\r\n        babylonNode.rotationQuaternion = rotation;\r\n        babylonNode.scaling = scaling;\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadSkinAsync(context: string, node: INode, skin: ISkin, assign: (babylonSkeleton: Skeleton) => void): Promise<void> {\r\n        if (!this._parent.loadSkins) {\r\n            return Promise.resolve();\r\n        }\r\n\r\n        const extensionPromise = this._extensionsLoadSkinAsync(context, node, skin);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        if (skin._data) {\r\n            assign(skin._data.babylonSkeleton);\r\n            return skin._data.promise;\r\n        }\r\n\r\n        const skeletonId = `skeleton${skin.index}`;\r\n        this._babylonScene._blockEntityCollection = !!this._assetContainer;\r\n        const babylonSkeleton = new Skeleton(skin.name || skeletonId, skeletonId, this._babylonScene);\r\n        babylonSkeleton._parentContainer = this._assetContainer;\r\n        this._babylonScene._blockEntityCollection = false;\r\n\r\n        this._loadBones(context, skin, babylonSkeleton);\r\n        const promise = this._loadSkinInverseBindMatricesDataAsync(context, skin).then((inverseBindMatricesData) => {\r\n            this._updateBoneMatrices(babylonSkeleton, inverseBindMatricesData);\r\n        });\r\n\r\n        skin._data = {\r\n            babylonSkeleton: babylonSkeleton,\r\n            promise: promise,\r\n        };\r\n\r\n        assign(babylonSkeleton);\r\n\r\n        return promise;\r\n    }\r\n\r\n    private _loadBones(context: string, skin: ISkin, babylonSkeleton: Skeleton): void {\r\n        if (skin.skeleton == undefined || this._parent.alwaysComputeSkeletonRootNode) {\r\n            const rootNode = this._findSkeletonRootNode(`${context}/joints`, skin.joints);\r\n            if (rootNode) {\r\n                if (skin.skeleton === undefined) {\r\n                    skin.skeleton = rootNode.index;\r\n                } else {\r\n                    const isParent = (a: INode, b: INode): boolean => {\r\n                        for (; b.parent; b = b.parent) {\r\n                            if (b.parent === a) {\r\n                                return true;\r\n                            }\r\n                        }\r\n\r\n                        return false;\r\n                    };\r\n\r\n                    const skeletonNode = ArrayItem.Get(`${context}/skeleton`, this._gltf.nodes, skin.skeleton);\r\n                    if (skeletonNode !== rootNode && !isParent(skeletonNode, rootNode)) {\r\n                        Logger.Warn(`${context}/skeleton: Overriding with nearest common ancestor as skeleton node is not a common root`);\r\n                        skin.skeleton = rootNode.index;\r\n                    }\r\n                }\r\n            } else {\r\n                Logger.Warn(`${context}: Failed to find common root`);\r\n            }\r\n        }\r\n\r\n        const babylonBones: { [index: number]: Bone } = {};\r\n        for (const index of skin.joints) {\r\n            const node = ArrayItem.Get(`${context}/joints/${index}`, this._gltf.nodes, index);\r\n            this._loadBone(node, skin, babylonSkeleton, babylonBones);\r\n        }\r\n    }\r\n\r\n    private _findSkeletonRootNode(context: string, joints: Array<number>): Nullable<INode> {\r\n        if (joints.length === 0) {\r\n            return null;\r\n        }\r\n\r\n        const paths: { [joint: number]: Array<INode> } = {};\r\n        for (const index of joints) {\r\n            const path: INode[] = [];\r\n            let node = ArrayItem.Get(`${context}/${index}`, this._gltf.nodes, index);\r\n            while (node.index !== -1) {\r\n                path.unshift(node);\r\n                node = node.parent!;\r\n            }\r\n            paths[index] = path;\r\n        }\r\n\r\n        let rootNode: Nullable<INode> = null;\r\n        for (let i = 0; ; ++i) {\r\n            let path = paths[joints[0]];\r\n            if (i >= path.length) {\r\n                return rootNode;\r\n            }\r\n\r\n            const node = path[i];\r\n            for (let j = 1; j < joints.length; ++j) {\r\n                path = paths[joints[j]];\r\n                if (i >= path.length || node !== path[i]) {\r\n                    return rootNode;\r\n                }\r\n            }\r\n\r\n            rootNode = node;\r\n        }\r\n    }\r\n\r\n    private _loadBone(node: INode, skin: ISkin, babylonSkeleton: Skeleton, babylonBones: { [index: number]: Bone }): Bone {\r\n        node._isJoint = true;\r\n\r\n        let babylonBone = babylonBones[node.index];\r\n        if (babylonBone) {\r\n            return babylonBone;\r\n        }\r\n\r\n        let parentBabylonBone: Nullable<Bone> = null;\r\n        if (node.index !== skin.skeleton) {\r\n            if (node.parent && node.parent.index !== -1) {\r\n                parentBabylonBone = this._loadBone(node.parent, skin, babylonSkeleton, babylonBones);\r\n            } else if (skin.skeleton !== undefined) {\r\n                Logger.Warn(`/skins/${skin.index}/skeleton: Skeleton node is not a common root`);\r\n            }\r\n        }\r\n\r\n        const boneIndex = skin.joints.indexOf(node.index);\r\n        babylonBone = new Bone(node.name || `joint${node.index}`, babylonSkeleton, parentBabylonBone, this._getNodeMatrix(node), null, null, boneIndex);\r\n        babylonBones[node.index] = babylonBone;\r\n\r\n        // Wait until the scene is loaded to ensure the transform nodes are loaded.\r\n        this._postSceneLoadActions.push(() => {\r\n            // Link the Babylon bone with the corresponding Babylon transform node.\r\n            // A glTF joint is a pointer to a glTF node in the glTF node hierarchy similar to Unity3D.\r\n            babylonBone.linkTransformNode(node._babylonTransformNode!);\r\n        });\r\n\r\n        return babylonBone;\r\n    }\r\n\r\n    private _loadSkinInverseBindMatricesDataAsync(context: string, skin: ISkin): Promise<Nullable<Float32Array>> {\r\n        if (skin.inverseBindMatrices == undefined) {\r\n            return Promise.resolve(null);\r\n        }\r\n\r\n        const accessor = ArrayItem.Get(`${context}/inverseBindMatrices`, this._gltf.accessors, skin.inverseBindMatrices);\r\n        return this._loadFloatAccessorAsync(`/accessors/${accessor.index}`, accessor);\r\n    }\r\n\r\n    private _updateBoneMatrices(babylonSkeleton: Skeleton, inverseBindMatricesData: Nullable<Float32Array>): void {\r\n        for (const babylonBone of babylonSkeleton.bones) {\r\n            const baseMatrix = Matrix.Identity();\r\n            const boneIndex = babylonBone._index!;\r\n            if (inverseBindMatricesData && boneIndex !== -1) {\r\n                Matrix.FromArrayToRef(inverseBindMatricesData, boneIndex * 16, baseMatrix);\r\n                baseMatrix.invertToRef(baseMatrix);\r\n            }\r\n\r\n            const babylonParentBone = babylonBone.getParent();\r\n            if (babylonParentBone) {\r\n                baseMatrix.multiplyToRef(babylonParentBone.getAbsoluteInverseBindMatrix(), baseMatrix);\r\n            }\r\n\r\n            babylonBone.updateMatrix(baseMatrix, false, false);\r\n            babylonBone._updateAbsoluteBindMatrices(undefined, false);\r\n        }\r\n    }\r\n\r\n    private _getNodeMatrix(node: INode): Matrix {\r\n        return node.matrix\r\n            ? Matrix.FromArray(node.matrix)\r\n            : Matrix.Compose(\r\n                  node.scale ? Vector3.FromArray(node.scale) : Vector3.One(),\r\n                  node.rotation ? Quaternion.FromArray(node.rotation) : Quaternion.Identity(),\r\n                  node.translation ? Vector3.FromArray(node.translation) : Vector3.Zero()\r\n              );\r\n    }\r\n\r\n    /**\r\n     * Loads a glTF camera.\r\n     * @param context The context when loading the asset\r\n     * @param camera The glTF camera property\r\n     * @param assign A function called synchronously after parsing the glTF properties\r\n     * @returns A promise that resolves with the loaded Babylon camera when the load is complete\r\n     */\r\n    public loadCameraAsync(context: string, camera: ICamera, assign: (babylonCamera: Camera) => void = () => {}): Promise<Camera> {\r\n        const extensionPromise = this._extensionsLoadCameraAsync(context, camera, assign);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        this.logOpen(`${context} ${camera.name || \"\"}`);\r\n\r\n        this._babylonScene._blockEntityCollection = !!this._assetContainer;\r\n        const babylonCamera = new FreeCamera(camera.name || `camera${camera.index}`, Vector3.Zero(), this._babylonScene, false);\r\n        babylonCamera._parentContainer = this._assetContainer;\r\n        this._babylonScene._blockEntityCollection = false;\r\n        camera._babylonCamera = babylonCamera;\r\n\r\n        // glTF cameras look towards the local -Z axis.\r\n        babylonCamera.setTarget(new Vector3(0, 0, -1));\r\n\r\n        switch (camera.type) {\r\n            case CameraType.PERSPECTIVE: {\r\n                const perspective = camera.perspective;\r\n                if (!perspective) {\r\n                    throw new Error(`${context}: Camera perspective properties are missing`);\r\n                }\r\n\r\n                babylonCamera.fov = perspective.yfov;\r\n                babylonCamera.minZ = perspective.znear;\r\n                babylonCamera.maxZ = perspective.zfar || 0;\r\n                break;\r\n            }\r\n            case CameraType.ORTHOGRAPHIC: {\r\n                if (!camera.orthographic) {\r\n                    throw new Error(`${context}: Camera orthographic properties are missing`);\r\n                }\r\n\r\n                babylonCamera.mode = Camera.ORTHOGRAPHIC_CAMERA;\r\n                babylonCamera.orthoLeft = -camera.orthographic.xmag;\r\n                babylonCamera.orthoRight = camera.orthographic.xmag;\r\n                babylonCamera.orthoBottom = -camera.orthographic.ymag;\r\n                babylonCamera.orthoTop = camera.orthographic.ymag;\r\n                babylonCamera.minZ = camera.orthographic.znear;\r\n                babylonCamera.maxZ = camera.orthographic.zfar;\r\n                break;\r\n            }\r\n            default: {\r\n                throw new Error(`${context}: Invalid camera type (${camera.type})`);\r\n            }\r\n        }\r\n\r\n        GLTFLoader.AddPointerMetadata(babylonCamera, context);\r\n        this._parent.onCameraLoadedObservable.notifyObservers(babylonCamera);\r\n        assign(babylonCamera);\r\n\r\n        this.logClose();\r\n\r\n        return Promise.all(promises).then(() => {\r\n            return babylonCamera;\r\n        });\r\n    }\r\n\r\n    private _loadAnimationsAsync(): Promise<void> {\r\n        this._parent._startPerformanceCounter(\"Load animations\");\r\n\r\n        const animations = this._gltf.animations;\r\n        if (!animations) {\r\n            return Promise.resolve();\r\n        }\r\n\r\n        const promises = new Array<Promise<void>>();\r\n\r\n        for (let index = 0; index < animations.length; index++) {\r\n            const animation = animations[index];\r\n            promises.push(\r\n                this.loadAnimationAsync(`/animations/${animation.index}`, animation).then((animationGroup) => {\r\n                    // Delete the animation group if it ended up not having any animations in it.\r\n                    if (animationGroup.targetedAnimations.length === 0) {\r\n                        animationGroup.dispose();\r\n                    }\r\n                })\r\n            );\r\n        }\r\n\r\n        return Promise.all(promises).then(() => {\r\n            this._parent._endPerformanceCounter(\"Load animations\");\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Loads a glTF animation.\r\n     * @param context The context when loading the asset\r\n     * @param animation The glTF animation property\r\n     * @returns A promise that resolves with the loaded Babylon animation group when the load is complete\r\n     */\r\n    public loadAnimationAsync(context: string, animation: IAnimation): Promise<AnimationGroup> {\r\n        this._parent._startPerformanceCounter(\"Load animation\");\r\n\r\n        const promise = this._extensionsLoadAnimationAsync(context, animation);\r\n        if (promise) {\r\n            return promise;\r\n        }\r\n\r\n        // eslint-disable-next-line @typescript-eslint/naming-convention\r\n        return LazyAnimationGroupModulePromise.value.then(({ AnimationGroup }) => {\r\n            this._babylonScene._blockEntityCollection = !!this._assetContainer;\r\n            const babylonAnimationGroup = new AnimationGroup(animation.name || `animation${animation.index}`, this._babylonScene);\r\n            babylonAnimationGroup._parentContainer = this._assetContainer;\r\n            this._babylonScene._blockEntityCollection = false;\r\n            animation._babylonAnimationGroup = babylonAnimationGroup;\r\n\r\n            const promises = new Array<Promise<unknown>>();\r\n\r\n            ArrayItem.Assign(animation.channels);\r\n            ArrayItem.Assign(animation.samplers);\r\n\r\n            for (const channel of animation.channels) {\r\n                promises.push(\r\n                    this._loadAnimationChannelAsync(`${context}/channels/${channel.index}`, context, animation, channel, (babylonTarget, babylonAnimation) => {\r\n                        babylonTarget.animations = babylonTarget.animations || [];\r\n                        babylonTarget.animations.push(babylonAnimation);\r\n                        babylonAnimationGroup.addTargetedAnimation(babylonAnimation, babylonTarget);\r\n                    })\r\n                );\r\n            }\r\n\r\n            this._parent._endPerformanceCounter(\"Load animation\");\r\n\r\n            return Promise.all(promises).then(() => {\r\n                babylonAnimationGroup.normalize(0);\r\n                return babylonAnimationGroup;\r\n            });\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @hidden\r\n     * Loads a glTF animation channel.\r\n     * @param context The context when loading the asset\r\n     * @param animationContext The context of the animation when loading the asset\r\n     * @param animation The glTF animation property\r\n     * @param channel The glTF animation channel property\r\n     * @param onLoad Called for each animation loaded\r\n     * @returns A void promise that resolves when the load is complete\r\n     */\r\n    public _loadAnimationChannelAsync(\r\n        context: string,\r\n        animationContext: string,\r\n        animation: IAnimation,\r\n        channel: IAnimationChannel,\r\n        onLoad: (babylonAnimatable: IAnimatable, babylonAnimation: Animation) => void\r\n    ): Promise<void> {\r\n        const promise = this._extensionsLoadAnimationChannelAsync(context, animationContext, animation, channel, onLoad);\r\n        if (promise) {\r\n            return promise;\r\n        }\r\n\r\n        if (channel.target.node == undefined) {\r\n            return Promise.resolve();\r\n        }\r\n\r\n        const targetNode = ArrayItem.Get(`${context}/target/node`, this._gltf.nodes, channel.target.node);\r\n        const channelTargetPath = channel.target.path;\r\n        const pathIsWeights = channelTargetPath === AnimationChannelTargetPath.WEIGHTS;\r\n\r\n        // Ignore animations that have no animation targets.\r\n        if ((pathIsWeights && !targetNode._numMorphTargets) || (!pathIsWeights && !targetNode._babylonTransformNode)) {\r\n            return Promise.resolve();\r\n        }\r\n\r\n        // Don't load node animations if disabled.\r\n        if (!this._parent.loadNodeAnimations && !pathIsWeights && !targetNode._isJoint) {\r\n            return Promise.resolve();\r\n        }\r\n\r\n        // async-load the animation sampler to provide the interpolation of the channelTargetPath\r\n        return LazyLoaderAnimationModulePromise.value.then(() => {\r\n            let properties: IInterpolationPropertyInfo[];\r\n            switch (channelTargetPath) {\r\n                case AnimationChannelTargetPath.TRANSLATION: {\r\n                    properties = GetMappingForKey(\"/nodes/{}/translation\")?.interpolation!;\r\n                    break;\r\n                }\r\n                case AnimationChannelTargetPath.ROTATION: {\r\n                    properties = GetMappingForKey(\"/nodes/{}/rotation\")?.interpolation!;\r\n                    break;\r\n                }\r\n                case AnimationChannelTargetPath.SCALE: {\r\n                    properties = GetMappingForKey(\"/nodes/{}/scale\")?.interpolation!;\r\n                    break;\r\n                }\r\n                case AnimationChannelTargetPath.WEIGHTS: {\r\n                    properties = GetMappingForKey(\"/nodes/{}/weights\")?.interpolation!;\r\n                    break;\r\n                }\r\n                default: {\r\n                    throw new Error(`${context}/target/path: Invalid value (${channel.target.path})`);\r\n                }\r\n            }\r\n            // stay safe\r\n            if (!properties) {\r\n                throw new Error(`${context}/target/path: Could not find interpolation properties for target path (${channel.target.path})`);\r\n            }\r\n\r\n            const targetInfo: IObjectInfo<IInterpolationPropertyInfo[]> = {\r\n                object: targetNode,\r\n                info: properties,\r\n            };\r\n\r\n            return this._loadAnimationChannelFromTargetInfoAsync(context, animationContext, animation, channel, targetInfo, onLoad);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @hidden\r\n     * Loads a glTF animation channel.\r\n     * @param context The context when loading the asset\r\n     * @param animationContext The context of the animation when loading the asset\r\n     * @param animation The glTF animation property\r\n     * @param channel The glTF animation channel property\r\n     * @param targetInfo The glTF target and properties\r\n     * @param onLoad Called for each animation loaded\r\n     * @returns A void promise that resolves when the load is complete\r\n     */\r\n    public _loadAnimationChannelFromTargetInfoAsync(\r\n        context: string,\r\n        animationContext: string,\r\n        animation: IAnimation,\r\n        channel: IAnimationChannel,\r\n        targetInfo: IObjectInfo<IInterpolationPropertyInfo[]>,\r\n        onLoad: (babylonAnimatable: IAnimatable, babylonAnimation: Animation) => void\r\n    ): Promise<void> {\r\n        const fps = this.parent.targetFps;\r\n        const invfps = 1 / fps;\r\n\r\n        const sampler = ArrayItem.Get(`${context}/sampler`, animation.samplers, channel.sampler);\r\n        return this._loadAnimationSamplerAsync(`${animationContext}/samplers/${channel.sampler}`, sampler).then((data) => {\r\n            let numAnimations = 0;\r\n\r\n            const target = targetInfo.object;\r\n            const propertyInfos = targetInfo.info;\r\n            // Extract the corresponding values from the read value.\r\n            // GLTF values may be dispatched to several Babylon properties.\r\n            // For example, baseColorFactor [`r`, `g`, `b`, `a`] is dispatched to\r\n            // - albedoColor as Color3(`r`, `g`, `b`)\r\n            // - alpha as `a`\r\n            for (const propertyInfo of propertyInfos) {\r\n                const stride = propertyInfo.getStride(target);\r\n                const input = data.input;\r\n                const output = data.output;\r\n                const keys = new Array<IAnimationKey>(input.length);\r\n                let outputOffset = 0;\r\n\r\n                switch (data.interpolation) {\r\n                    case AnimationSamplerInterpolation.STEP: {\r\n                        for (let index = 0; index < input.length; index++) {\r\n                            const value = propertyInfo.getValue(target, output, outputOffset, 1);\r\n                            outputOffset += stride;\r\n\r\n                            keys[index] = {\r\n                                frame: input[index] * fps,\r\n                                value: value,\r\n                                interpolation: AnimationKeyInterpolation.STEP,\r\n                            };\r\n                        }\r\n                        break;\r\n                    }\r\n                    case AnimationSamplerInterpolation.CUBICSPLINE: {\r\n                        for (let index = 0; index < input.length; index++) {\r\n                            const inTangent = propertyInfo.getValue(target, output, outputOffset, invfps);\r\n                            outputOffset += stride;\r\n                            const value = propertyInfo.getValue(target, output, outputOffset, 1);\r\n                            outputOffset += stride;\r\n                            const outTangent = propertyInfo.getValue(target, output, outputOffset, invfps);\r\n                            outputOffset += stride;\r\n\r\n                            keys[index] = {\r\n                                frame: input[index] * fps,\r\n                                inTangent: inTangent,\r\n                                value: value,\r\n                                outTangent: outTangent,\r\n                            };\r\n                        }\r\n                        break;\r\n                    }\r\n                    case AnimationSamplerInterpolation.LINEAR: {\r\n                        for (let index = 0; index < input.length; index++) {\r\n                            const value = propertyInfo.getValue(target, output, outputOffset, 1);\r\n                            outputOffset += stride;\r\n\r\n                            keys[index] = {\r\n                                frame: input[index] * fps,\r\n                                value: value,\r\n                            };\r\n                        }\r\n                        break;\r\n                    }\r\n                }\r\n\r\n                if (outputOffset > 0) {\r\n                    const name = `${animation.name || `animation${animation.index}`}_channel${channel.index}_${numAnimations}`;\r\n                    const babylonAnimations = propertyInfo.buildAnimations(target, name, fps, keys);\r\n                    for (const babylonAnimation of babylonAnimations) {\r\n                        numAnimations++;\r\n                        onLoad(babylonAnimation.babylonAnimatable, babylonAnimation.babylonAnimation);\r\n                    }\r\n                }\r\n            }\r\n        });\r\n    }\r\n\r\n    private _loadAnimationSamplerAsync(context: string, sampler: IAnimationSampler): Promise<_IAnimationSamplerData> {\r\n        if (sampler._data) {\r\n            return sampler._data;\r\n        }\r\n\r\n        const interpolation = sampler.interpolation || AnimationSamplerInterpolation.LINEAR;\r\n        switch (interpolation) {\r\n            case AnimationSamplerInterpolation.STEP:\r\n            case AnimationSamplerInterpolation.LINEAR:\r\n            case AnimationSamplerInterpolation.CUBICSPLINE: {\r\n                break;\r\n            }\r\n            default: {\r\n                throw new Error(`${context}/interpolation: Invalid value (${sampler.interpolation})`);\r\n            }\r\n        }\r\n\r\n        const inputAccessor = ArrayItem.Get(`${context}/input`, this._gltf.accessors, sampler.input);\r\n        const outputAccessor = ArrayItem.Get(`${context}/output`, this._gltf.accessors, sampler.output);\r\n        sampler._data = Promise.all([\r\n            this._loadFloatAccessorAsync(`/accessors/${inputAccessor.index}`, inputAccessor),\r\n            this._loadFloatAccessorAsync(`/accessors/${outputAccessor.index}`, outputAccessor),\r\n        ]).then(([inputData, outputData]) => {\r\n            return {\r\n                input: inputData,\r\n                interpolation: interpolation,\r\n                output: outputData,\r\n            };\r\n        });\r\n\r\n        return sampler._data;\r\n    }\r\n\r\n    /**\r\n     * Loads a glTF buffer.\r\n     * @param context The context when loading the asset\r\n     * @param buffer The glTF buffer property\r\n     * @param byteOffset The byte offset to use\r\n     * @param byteLength The byte length to use\r\n     * @returns A promise that resolves with the loaded data when the load is complete\r\n     */\r\n    public loadBufferAsync(context: string, buffer: IBuffer, byteOffset: number, byteLength: number): Promise<ArrayBufferView> {\r\n        const extensionPromise = this._extensionsLoadBufferAsync(context, buffer, byteOffset, byteLength);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        if (!buffer._data) {\r\n            if (buffer.uri) {\r\n                buffer._data = this.loadUriAsync(`${context}/uri`, buffer, buffer.uri);\r\n            } else {\r\n                if (!this._bin) {\r\n                    throw new Error(`${context}: Uri is missing or the binary glTF is missing its binary chunk`);\r\n                }\r\n\r\n                buffer._data = this._bin.readAsync(0, buffer.byteLength);\r\n            }\r\n        }\r\n\r\n        return buffer._data.then((data) => {\r\n            try {\r\n                return new Uint8Array(data.buffer, data.byteOffset + byteOffset, byteLength);\r\n            } catch (e) {\r\n                throw new Error(`${context}: ${e.message}`);\r\n            }\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Loads a glTF buffer view.\r\n     * @param context The context when loading the asset\r\n     * @param bufferView The glTF buffer view property\r\n     * @returns A promise that resolves with the loaded data when the load is complete\r\n     */\r\n    public loadBufferViewAsync(context: string, bufferView: IBufferView): Promise<ArrayBufferView> {\r\n        const extensionPromise = this._extensionsLoadBufferViewAsync(context, bufferView);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        if (bufferView._data) {\r\n            return bufferView._data;\r\n        }\r\n\r\n        const buffer = ArrayItem.Get(`${context}/buffer`, this._gltf.buffers, bufferView.buffer);\r\n        bufferView._data = this.loadBufferAsync(`/buffers/${buffer.index}`, buffer, bufferView.byteOffset || 0, bufferView.byteLength);\r\n\r\n        return bufferView._data;\r\n    }\r\n\r\n    private _loadAccessorAsync(context: string, accessor: IAccessor, constructor: TypedArrayConstructor): Promise<ArrayBufferView> {\r\n        if (accessor._data) {\r\n            return accessor._data;\r\n        }\r\n\r\n        const numComponents = GLTFLoader._GetNumComponents(context, accessor.type);\r\n        const byteStride = numComponents * VertexBuffer.GetTypeByteLength(accessor.componentType);\r\n        const length = numComponents * accessor.count;\r\n\r\n        if (accessor.bufferView == undefined) {\r\n            accessor._data = Promise.resolve(new constructor(length));\r\n        } else {\r\n            const bufferView = ArrayItem.Get(`${context}/bufferView`, this._gltf.bufferViews, accessor.bufferView);\r\n            accessor._data = this.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView).then((data) => {\r\n                if (accessor.componentType === AccessorComponentType.FLOAT && !accessor.normalized && (!bufferView.byteStride || bufferView.byteStride === byteStride)) {\r\n                    return GLTFLoader._GetTypedArray(context, accessor.componentType, data, accessor.byteOffset, length);\r\n                } else {\r\n                    const typedArray = new constructor(length);\r\n                    VertexBuffer.ForEach(\r\n                        data,\r\n                        accessor.byteOffset || 0,\r\n                        bufferView.byteStride || byteStride,\r\n                        numComponents,\r\n                        accessor.componentType,\r\n                        typedArray.length,\r\n                        accessor.normalized || false,\r\n                        (value, index) => {\r\n                            typedArray[index] = value;\r\n                        }\r\n                    );\r\n                    return typedArray;\r\n                }\r\n            });\r\n        }\r\n\r\n        if (accessor.sparse) {\r\n            const sparse = accessor.sparse;\r\n            accessor._data = accessor._data.then((data) => {\r\n                const typedArray = data as TypedArray;\r\n                const indicesBufferView = ArrayItem.Get(`${context}/sparse/indices/bufferView`, this._gltf.bufferViews, sparse.indices.bufferView);\r\n                const valuesBufferView = ArrayItem.Get(`${context}/sparse/values/bufferView`, this._gltf.bufferViews, sparse.values.bufferView);\r\n                return Promise.all([\r\n                    this.loadBufferViewAsync(`/bufferViews/${indicesBufferView.index}`, indicesBufferView),\r\n                    this.loadBufferViewAsync(`/bufferViews/${valuesBufferView.index}`, valuesBufferView),\r\n                ]).then(([indicesData, valuesData]) => {\r\n                    const indices = GLTFLoader._GetTypedArray(\r\n                        `${context}/sparse/indices`,\r\n                        sparse.indices.componentType,\r\n                        indicesData,\r\n                        sparse.indices.byteOffset,\r\n                        sparse.count\r\n                    ) as IndicesArray;\r\n\r\n                    const sparseLength = numComponents * sparse.count;\r\n                    let values: TypedArray;\r\n\r\n                    if (accessor.componentType === AccessorComponentType.FLOAT && !accessor.normalized) {\r\n                        values = GLTFLoader._GetTypedArray(`${context}/sparse/values`, accessor.componentType, valuesData, sparse.values.byteOffset, sparseLength);\r\n                    } else {\r\n                        const sparseData = GLTFLoader._GetTypedArray(`${context}/sparse/values`, accessor.componentType, valuesData, sparse.values.byteOffset, sparseLength);\r\n                        values = new constructor(sparseLength);\r\n                        VertexBuffer.ForEach(sparseData, 0, byteStride, numComponents, accessor.componentType, values.length, accessor.normalized || false, (value, index) => {\r\n                            values[index] = value;\r\n                        });\r\n                    }\r\n\r\n                    let valuesIndex = 0;\r\n                    for (let indicesIndex = 0; indicesIndex < indices.length; indicesIndex++) {\r\n                        let dataIndex = indices[indicesIndex] * numComponents;\r\n                        for (let componentIndex = 0; componentIndex < numComponents; componentIndex++) {\r\n                            typedArray[dataIndex++] = values[valuesIndex++];\r\n                        }\r\n                    }\r\n\r\n                    return typedArray;\r\n                });\r\n            });\r\n        }\r\n\r\n        return accessor._data;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public _loadFloatAccessorAsync(context: string, accessor: IAccessor): Promise<Float32Array> {\r\n        return this._loadAccessorAsync(context, accessor, Float32Array) as Promise<Float32Array>;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public _loadIndicesAccessorAsync(context: string, accessor: IAccessor): Promise<IndicesArray> {\r\n        if (accessor.type !== AccessorType.SCALAR) {\r\n            throw new Error(`${context}/type: Invalid value ${accessor.type}`);\r\n        }\r\n\r\n        if (\r\n            accessor.componentType !== AccessorComponentType.UNSIGNED_BYTE &&\r\n            accessor.componentType !== AccessorComponentType.UNSIGNED_SHORT &&\r\n            accessor.componentType !== AccessorComponentType.UNSIGNED_INT\r\n        ) {\r\n            throw new Error(`${context}/componentType: Invalid value ${accessor.componentType}`);\r\n        }\r\n\r\n        if (accessor._data) {\r\n            return accessor._data as Promise<IndicesArray>;\r\n        }\r\n\r\n        if (accessor.sparse) {\r\n            const constructor = GLTFLoader._GetTypedArrayConstructor(`${context}/componentType`, accessor.componentType);\r\n            accessor._data = this._loadAccessorAsync(context, accessor, constructor);\r\n        } else {\r\n            const bufferView = ArrayItem.Get(`${context}/bufferView`, this._gltf.bufferViews, accessor.bufferView);\r\n            accessor._data = this.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView).then((data) => {\r\n                return GLTFLoader._GetTypedArray(context, accessor.componentType, data, accessor.byteOffset, accessor.count);\r\n            });\r\n        }\r\n\r\n        return accessor._data as Promise<IndicesArray>;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public _loadVertexBufferViewAsync(bufferView: IBufferView): Promise<Buffer> {\r\n        if (bufferView._babylonBuffer) {\r\n            return bufferView._babylonBuffer;\r\n        }\r\n\r\n        const engine = this._babylonScene.getEngine();\r\n        bufferView._babylonBuffer = this.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView).then((data) => {\r\n            return new Buffer(engine, data, false);\r\n        });\r\n\r\n        return bufferView._babylonBuffer;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public _loadVertexAccessorAsync(context: string, accessor: IAccessor, kind: string): Promise<VertexBuffer> {\r\n        if (accessor._babylonVertexBuffer?.[kind]) {\r\n            return accessor._babylonVertexBuffer[kind];\r\n        }\r\n\r\n        if (!accessor._babylonVertexBuffer) {\r\n            accessor._babylonVertexBuffer = {};\r\n        }\r\n\r\n        const engine = this._babylonScene.getEngine();\r\n\r\n        if (accessor.sparse || accessor.bufferView == undefined) {\r\n            accessor._babylonVertexBuffer[kind] = this._loadFloatAccessorAsync(context, accessor).then((data) => {\r\n                return new VertexBuffer(engine, data, kind, false);\r\n            });\r\n        } else {\r\n            const bufferView = ArrayItem.Get(`${context}/bufferView`, this._gltf.bufferViews, accessor.bufferView);\r\n            accessor._babylonVertexBuffer[kind] = this._loadVertexBufferViewAsync(bufferView).then((babylonBuffer) => {\r\n                const numComponents = GLTFLoader._GetNumComponents(context, accessor.type);\r\n                return new VertexBuffer(\r\n                    engine,\r\n                    babylonBuffer,\r\n                    kind,\r\n                    false,\r\n                    undefined,\r\n                    bufferView.byteStride,\r\n                    undefined,\r\n                    accessor.byteOffset,\r\n                    numComponents,\r\n                    accessor.componentType,\r\n                    accessor.normalized,\r\n                    true,\r\n                    undefined,\r\n                    true\r\n                );\r\n            });\r\n        }\r\n\r\n        return accessor._babylonVertexBuffer[kind];\r\n    }\r\n\r\n    private _loadMaterialMetallicRoughnessPropertiesAsync(context: string, properties: IMaterialPbrMetallicRoughness, babylonMaterial: Material): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        if (properties) {\r\n            if (properties.baseColorFactor) {\r\n                babylonMaterial.albedoColor = Color3.FromArray(properties.baseColorFactor);\r\n                babylonMaterial.alpha = properties.baseColorFactor[3];\r\n            } else {\r\n                babylonMaterial.albedoColor = Color3.White();\r\n            }\r\n\r\n            babylonMaterial.metallic = properties.metallicFactor == undefined ? 1 : properties.metallicFactor;\r\n            babylonMaterial.roughness = properties.roughnessFactor == undefined ? 1 : properties.roughnessFactor;\r\n\r\n            if (properties.baseColorTexture) {\r\n                promises.push(\r\n                    this.loadTextureInfoAsync(`${context}/baseColorTexture`, properties.baseColorTexture, (texture) => {\r\n                        texture.name = `${babylonMaterial.name} (Base Color)`;\r\n                        babylonMaterial.albedoTexture = texture;\r\n                    })\r\n                );\r\n            }\r\n\r\n            if (properties.metallicRoughnessTexture) {\r\n                properties.metallicRoughnessTexture.nonColorData = true;\r\n                promises.push(\r\n                    this.loadTextureInfoAsync(`${context}/metallicRoughnessTexture`, properties.metallicRoughnessTexture, (texture) => {\r\n                        texture.name = `${babylonMaterial.name} (Metallic Roughness)`;\r\n                        babylonMaterial.metallicTexture = texture;\r\n                    })\r\n                );\r\n\r\n                babylonMaterial.useMetallnessFromMetallicTextureBlue = true;\r\n                babylonMaterial.useRoughnessFromMetallicTextureGreen = true;\r\n                babylonMaterial.useRoughnessFromMetallicTextureAlpha = false;\r\n            }\r\n        }\r\n\r\n        return Promise.all(promises).then(() => {});\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public _loadMaterialAsync(\r\n        context: string,\r\n        material: IMaterial,\r\n        babylonMesh: Nullable<Mesh>,\r\n        babylonDrawMode: number,\r\n        assign: (babylonMaterial: Material) => void = () => {}\r\n    ): Promise<Material> {\r\n        const extensionPromise = this._extensionsLoadMaterialAsync(context, material, babylonMesh, babylonDrawMode, assign);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        material._data = material._data || {};\r\n        let babylonData = material._data[babylonDrawMode];\r\n        if (!babylonData) {\r\n            this.logOpen(`${context} ${material.name || \"\"}`);\r\n\r\n            const babylonMaterial = this.createMaterial(context, material, babylonDrawMode);\r\n\r\n            babylonData = {\r\n                babylonMaterial: babylonMaterial,\r\n                babylonMeshes: [],\r\n                promise: this.loadMaterialPropertiesAsync(context, material, babylonMaterial),\r\n            };\r\n\r\n            material._data[babylonDrawMode] = babylonData;\r\n\r\n            GLTFLoader.AddPointerMetadata(babylonMaterial, context);\r\n            this._parent.onMaterialLoadedObservable.notifyObservers(babylonMaterial);\r\n\r\n            this.logClose();\r\n        }\r\n\r\n        if (babylonMesh) {\r\n            babylonData.babylonMeshes.push(babylonMesh);\r\n\r\n            babylonMesh.onDisposeObservable.addOnce(() => {\r\n                const index = babylonData.babylonMeshes.indexOf(babylonMesh);\r\n                if (index !== -1) {\r\n                    babylonData.babylonMeshes.splice(index, 1);\r\n                }\r\n            });\r\n        }\r\n\r\n        assign(babylonData.babylonMaterial);\r\n\r\n        return babylonData.promise.then(() => {\r\n            return babylonData.babylonMaterial;\r\n        });\r\n    }\r\n\r\n    private _createDefaultMaterial(name: string, babylonDrawMode: number): Material {\r\n        this._babylonScene._blockEntityCollection = !!this._assetContainer;\r\n        const babylonMaterial = new PBRMaterial(name, this._babylonScene);\r\n        babylonMaterial._parentContainer = this._assetContainer;\r\n        this._babylonScene._blockEntityCollection = false;\r\n        // Moved to mesh so user can change materials on gltf meshes: babylonMaterial.sideOrientation = this._babylonScene.useRightHandedSystem ? Material.CounterClockWiseSideOrientation : Material.ClockWiseSideOrientation;\r\n        babylonMaterial.fillMode = babylonDrawMode;\r\n        babylonMaterial.enableSpecularAntiAliasing = true;\r\n        babylonMaterial.useRadianceOverAlpha = !this._parent.transparencyAsCoverage;\r\n        babylonMaterial.useSpecularOverAlpha = !this._parent.transparencyAsCoverage;\r\n        babylonMaterial.transparencyMode = PBRMaterial.PBRMATERIAL_OPAQUE;\r\n        babylonMaterial.metallic = 1;\r\n        babylonMaterial.roughness = 1;\r\n\r\n        return babylonMaterial;\r\n    }\r\n\r\n    /**\r\n     * Creates a Babylon material from a glTF material.\r\n     * @param context The context when loading the asset\r\n     * @param material The glTF material property\r\n     * @param babylonDrawMode The draw mode for the Babylon material\r\n     * @returns The Babylon material\r\n     */\r\n    public createMaterial(context: string, material: IMaterial, babylonDrawMode: number): Material {\r\n        const extensionPromise = this._extensionsCreateMaterial(context, material, babylonDrawMode);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        const name = material.name || `material${material.index}`;\r\n        const babylonMaterial = this._createDefaultMaterial(name, babylonDrawMode);\r\n\r\n        return babylonMaterial;\r\n    }\r\n\r\n    /**\r\n     * Loads properties from a glTF material into a Babylon material.\r\n     * @param context The context when loading the asset\r\n     * @param material The glTF material property\r\n     * @param babylonMaterial The Babylon material\r\n     * @returns A promise that resolves when the load is complete\r\n     */\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Promise<void> {\r\n        const extensionPromise = this._extensionsLoadMaterialPropertiesAsync(context, material, babylonMaterial);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        promises.push(this.loadMaterialBasePropertiesAsync(context, material, babylonMaterial));\r\n\r\n        if (material.pbrMetallicRoughness) {\r\n            promises.push(this._loadMaterialMetallicRoughnessPropertiesAsync(`${context}/pbrMetallicRoughness`, material.pbrMetallicRoughness, babylonMaterial));\r\n        }\r\n\r\n        this.loadMaterialAlphaProperties(context, material, babylonMaterial);\r\n\r\n        return Promise.all(promises).then(() => {});\r\n    }\r\n\r\n    /**\r\n     * Loads the normal, occlusion, and emissive properties from a glTF material into a Babylon material.\r\n     * @param context The context when loading the asset\r\n     * @param material The glTF material property\r\n     * @param babylonMaterial The Babylon material\r\n     * @returns A promise that resolves when the load is complete\r\n     */\r\n    public loadMaterialBasePropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        babylonMaterial.emissiveColor = material.emissiveFactor ? Color3.FromArray(material.emissiveFactor) : new Color3(0, 0, 0);\r\n        if (material.doubleSided) {\r\n            babylonMaterial.backFaceCulling = false;\r\n            babylonMaterial.twoSidedLighting = true;\r\n        }\r\n\r\n        if (material.normalTexture) {\r\n            material.normalTexture.nonColorData = true;\r\n            promises.push(\r\n                this.loadTextureInfoAsync(`${context}/normalTexture`, material.normalTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Normal)`;\r\n                    babylonMaterial.bumpTexture = texture;\r\n                })\r\n            );\r\n\r\n            babylonMaterial.invertNormalMapX = !this._babylonScene.useRightHandedSystem;\r\n            babylonMaterial.invertNormalMapY = this._babylonScene.useRightHandedSystem;\r\n            if (material.normalTexture.scale != undefined && babylonMaterial.bumpTexture) {\r\n                babylonMaterial.bumpTexture.level = material.normalTexture.scale;\r\n            }\r\n\r\n            babylonMaterial.forceIrradianceInFragment = true;\r\n        }\r\n\r\n        if (material.occlusionTexture) {\r\n            material.occlusionTexture.nonColorData = true;\r\n            promises.push(\r\n                this.loadTextureInfoAsync(`${context}/occlusionTexture`, material.occlusionTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Occlusion)`;\r\n                    babylonMaterial.ambientTexture = texture;\r\n                })\r\n            );\r\n\r\n            babylonMaterial.useAmbientInGrayScale = true;\r\n            if (material.occlusionTexture.strength != undefined) {\r\n                babylonMaterial.ambientTextureStrength = material.occlusionTexture.strength;\r\n            }\r\n        }\r\n\r\n        if (material.emissiveTexture) {\r\n            promises.push(\r\n                this.loadTextureInfoAsync(`${context}/emissiveTexture`, material.emissiveTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Emissive)`;\r\n                    babylonMaterial.emissiveTexture = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        return Promise.all(promises).then(() => {});\r\n    }\r\n\r\n    /**\r\n     * Loads the alpha properties from a glTF material into a Babylon material.\r\n     * Must be called after the setting the albedo texture of the Babylon material when the material has an albedo texture.\r\n     * @param context The context when loading the asset\r\n     * @param material The glTF material property\r\n     * @param babylonMaterial The Babylon material\r\n     */\r\n    public loadMaterialAlphaProperties(context: string, material: IMaterial, babylonMaterial: Material): void {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        const alphaMode = material.alphaMode || MaterialAlphaMode.OPAQUE;\r\n        switch (alphaMode) {\r\n            case MaterialAlphaMode.OPAQUE: {\r\n                babylonMaterial.transparencyMode = PBRMaterial.PBRMATERIAL_OPAQUE;\r\n                babylonMaterial.alpha = 1.0; // Force alpha to 1.0 for opaque mode.\r\n                break;\r\n            }\r\n            case MaterialAlphaMode.MASK: {\r\n                babylonMaterial.transparencyMode = PBRMaterial.PBRMATERIAL_ALPHATEST;\r\n                babylonMaterial.alphaCutOff = material.alphaCutoff == undefined ? 0.5 : material.alphaCutoff;\r\n                if (babylonMaterial.albedoTexture) {\r\n                    babylonMaterial.albedoTexture.hasAlpha = true;\r\n                }\r\n                break;\r\n            }\r\n            case MaterialAlphaMode.BLEND: {\r\n                babylonMaterial.transparencyMode = PBRMaterial.PBRMATERIAL_ALPHABLEND;\r\n                if (babylonMaterial.albedoTexture) {\r\n                    babylonMaterial.albedoTexture.hasAlpha = true;\r\n                    babylonMaterial.useAlphaFromAlbedoTexture = true;\r\n                }\r\n                break;\r\n            }\r\n            default: {\r\n                throw new Error(`${context}/alphaMode: Invalid value (${material.alphaMode})`);\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Loads a glTF texture info.\r\n     * @param context The context when loading the asset\r\n     * @param textureInfo The glTF texture info property\r\n     * @param assign A function called synchronously after parsing the glTF properties\r\n     * @returns A promise that resolves with the loaded Babylon texture when the load is complete\r\n     */\r\n    public loadTextureInfoAsync(context: string, textureInfo: ITextureInfo, assign: (babylonTexture: BaseTexture) => void = () => {}): Promise<BaseTexture> {\r\n        const extensionPromise = this._extensionsLoadTextureInfoAsync(context, textureInfo, assign);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        this.logOpen(`${context}`);\r\n\r\n        if (textureInfo.texCoord! >= 6) {\r\n            throw new Error(`${context}/texCoord: Invalid value (${textureInfo.texCoord})`);\r\n        }\r\n\r\n        const texture = ArrayItem.Get(`${context}/index`, this._gltf.textures, textureInfo.index);\r\n        texture._textureInfo = textureInfo;\r\n\r\n        const promise = this._loadTextureAsync(`/textures/${textureInfo.index}`, texture, (babylonTexture) => {\r\n            babylonTexture.coordinatesIndex = textureInfo.texCoord || 0;\r\n            GLTFLoader.AddPointerMetadata(babylonTexture, context);\r\n            this._parent.onTextureLoadedObservable.notifyObservers(babylonTexture);\r\n            assign(babylonTexture);\r\n        });\r\n\r\n        this.logClose();\r\n\r\n        return promise;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public _loadTextureAsync(context: string, texture: ITexture, assign: (babylonTexture: BaseTexture) => void = () => {}): Promise<BaseTexture> {\r\n        const extensionPromise = this._extensionsLoadTextureAsync(context, texture, assign);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        this.logOpen(`${context} ${texture.name || \"\"}`);\r\n\r\n        const sampler = texture.sampler == undefined ? GLTFLoader.DefaultSampler : ArrayItem.Get(`${context}/sampler`, this._gltf.samplers, texture.sampler);\r\n        const image = ArrayItem.Get(`${context}/source`, this._gltf.images, texture.source);\r\n        const promise = this._createTextureAsync(context, sampler, image, assign, undefined, !texture._textureInfo.nonColorData);\r\n\r\n        this.logClose();\r\n\r\n        return promise;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public _createTextureAsync(\r\n        context: string,\r\n        sampler: ISampler,\r\n        image: IImage,\r\n        assign: (babylonTexture: BaseTexture) => void = () => {},\r\n        textureLoaderOptions?: unknown,\r\n        useSRGBBuffer?: boolean\r\n    ): Promise<BaseTexture> {\r\n        const samplerData = this._loadSampler(`/samplers/${sampler.index}`, sampler);\r\n\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        const deferred = new Deferred<void>();\r\n        this._babylonScene._blockEntityCollection = !!this._assetContainer;\r\n        const textureCreationOptions: ITextureCreationOptions = {\r\n            noMipmap: samplerData.noMipMaps,\r\n            invertY: false,\r\n            samplingMode: samplerData.samplingMode,\r\n            onLoad: () => {\r\n                if (!this._disposed) {\r\n                    deferred.resolve();\r\n                }\r\n            },\r\n            onError: (message?: string, exception?: any) => {\r\n                if (!this._disposed) {\r\n                    deferred.reject(new Error(`${context}: ${exception && exception.message ? exception.message : message || \"Failed to load texture\"}`));\r\n                }\r\n            },\r\n            mimeType: image.mimeType ?? GetMimeType(image.uri ?? \"\"),\r\n            loaderOptions: textureLoaderOptions,\r\n            useSRGBBuffer: !!useSRGBBuffer && this._parent.useSRGBBuffers,\r\n        };\r\n        const babylonTexture = new Texture(null, this._babylonScene, textureCreationOptions);\r\n        babylonTexture._parentContainer = this._assetContainer;\r\n        this._babylonScene._blockEntityCollection = false;\r\n        promises.push(deferred.promise);\r\n\r\n        promises.push(\r\n            this.loadImageAsync(`/images/${image.index}`, image).then((data) => {\r\n                const name = image.uri || `${this._fileName}#image${image.index}`;\r\n                const dataUrl = `data:${this._uniqueRootUrl}${name}`;\r\n                babylonTexture.updateURL(dataUrl, data);\r\n\r\n                // Set the internal texture label.\r\n                const internalTexture = babylonTexture.getInternalTexture();\r\n                if (internalTexture) {\r\n                    internalTexture.label = image.name;\r\n                }\r\n            })\r\n        );\r\n\r\n        babylonTexture.wrapU = samplerData.wrapU;\r\n        babylonTexture.wrapV = samplerData.wrapV;\r\n        assign(babylonTexture);\r\n\r\n        if (this._parent.useGltfTextureNames) {\r\n            babylonTexture.name = image.name || image.uri || `image${image.index}`;\r\n        }\r\n\r\n        return Promise.all(promises).then(() => {\r\n            return babylonTexture;\r\n        });\r\n    }\r\n\r\n    private _loadSampler(context: string, sampler: ISampler): _ISamplerData {\r\n        if (!sampler._data) {\r\n            sampler._data = {\r\n                noMipMaps: sampler.minFilter === TextureMinFilter.NEAREST || sampler.minFilter === TextureMinFilter.LINEAR,\r\n                samplingMode: GLTFLoader._GetTextureSamplingMode(context, sampler),\r\n                wrapU: GLTFLoader._GetTextureWrapMode(`${context}/wrapS`, sampler.wrapS),\r\n                wrapV: GLTFLoader._GetTextureWrapMode(`${context}/wrapT`, sampler.wrapT),\r\n            };\r\n        }\r\n\r\n        return sampler._data;\r\n    }\r\n\r\n    /**\r\n     * Loads a glTF image.\r\n     * @param context The context when loading the asset\r\n     * @param image The glTF image property\r\n     * @returns A promise that resolves with the loaded data when the load is complete\r\n     */\r\n    public loadImageAsync(context: string, image: IImage): Promise<ArrayBufferView> {\r\n        if (!image._data) {\r\n            this.logOpen(`${context} ${image.name || \"\"}`);\r\n\r\n            if (image.uri) {\r\n                image._data = this.loadUriAsync(`${context}/uri`, image, image.uri);\r\n            } else {\r\n                const bufferView = ArrayItem.Get(`${context}/bufferView`, this._gltf.bufferViews, image.bufferView);\r\n                image._data = this.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView);\r\n            }\r\n\r\n            this.logClose();\r\n        }\r\n\r\n        return image._data;\r\n    }\r\n\r\n    /**\r\n     * Loads a glTF uri.\r\n     * @param context The context when loading the asset\r\n     * @param property The glTF property associated with the uri\r\n     * @param uri The base64 or relative uri\r\n     * @returns A promise that resolves with the loaded data when the load is complete\r\n     */\r\n    public loadUriAsync(context: string, property: IProperty, uri: string): Promise<ArrayBufferView> {\r\n        const extensionPromise = this._extensionsLoadUriAsync(context, property, uri);\r\n        if (extensionPromise) {\r\n            return extensionPromise;\r\n        }\r\n\r\n        if (!GLTFLoader._ValidateUri(uri)) {\r\n            throw new Error(`${context}: '${uri}' is invalid`);\r\n        }\r\n\r\n        if (IsBase64DataUrl(uri)) {\r\n            const data = new Uint8Array(DecodeBase64UrlToBinary(uri));\r\n            this.log(`${context}: Decoded ${uri.substring(0, 64)}... (${data.length} bytes)`);\r\n            return Promise.resolve(data);\r\n        }\r\n\r\n        this.log(`${context}: Loading ${uri}`);\r\n\r\n        return this._parent.preprocessUrlAsync(this._rootUrl + uri).then((url) => {\r\n            return new Promise((resolve, reject) => {\r\n                this._parent._loadFile(\r\n                    this._babylonScene,\r\n                    url,\r\n                    (data) => {\r\n                        if (!this._disposed) {\r\n                            this.log(`${context}: Loaded ${uri} (${(data as ArrayBuffer).byteLength} bytes)`);\r\n                            resolve(new Uint8Array(data as ArrayBuffer));\r\n                        }\r\n                    },\r\n                    true,\r\n                    (request) => {\r\n                        reject(new LoadFileError(`${context}: Failed to load '${uri}'${request ? \": \" + request.status + \" \" + request.statusText : \"\"}`, request));\r\n                    }\r\n                );\r\n            });\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Adds a JSON pointer to the _internalMetadata of the Babylon object at `<object>._internalMetadata.gltf.pointers`.\r\n     * @param babylonObject the Babylon object with _internalMetadata\r\n     * @param pointer the JSON pointer\r\n     */\r\n    public static AddPointerMetadata(babylonObject: IWithMetadata, pointer: string): void {\r\n        babylonObject.metadata = babylonObject.metadata || {};\r\n        const metadata = (babylonObject._internalMetadata = babylonObject._internalMetadata || {});\r\n        const gltf = (metadata.gltf = metadata.gltf || {});\r\n        const pointers = (gltf.pointers = gltf.pointers || []);\r\n        pointers.push(pointer);\r\n    }\r\n\r\n    private static _GetTextureWrapMode(context: string, mode: TextureWrapMode | undefined): number {\r\n        // Set defaults if undefined\r\n        mode = mode == undefined ? TextureWrapMode.REPEAT : mode;\r\n\r\n        switch (mode) {\r\n            case TextureWrapMode.CLAMP_TO_EDGE:\r\n                return Texture.CLAMP_ADDRESSMODE;\r\n            case TextureWrapMode.MIRRORED_REPEAT:\r\n                return Texture.MIRROR_ADDRESSMODE;\r\n            case TextureWrapMode.REPEAT:\r\n                return Texture.WRAP_ADDRESSMODE;\r\n            default:\r\n                Logger.Warn(`${context}: Invalid value (${mode})`);\r\n                return Texture.WRAP_ADDRESSMODE;\r\n        }\r\n    }\r\n\r\n    private static _GetTextureSamplingMode(context: string, sampler: ISampler): number {\r\n        // Set defaults if undefined\r\n        const magFilter = sampler.magFilter == undefined ? TextureMagFilter.LINEAR : sampler.magFilter;\r\n        const minFilter = sampler.minFilter == undefined ? TextureMinFilter.LINEAR_MIPMAP_LINEAR : sampler.minFilter;\r\n\r\n        if (magFilter === TextureMagFilter.LINEAR) {\r\n            switch (minFilter) {\r\n                case TextureMinFilter.NEAREST:\r\n                    return Texture.LINEAR_NEAREST;\r\n                case TextureMinFilter.LINEAR:\r\n                    return Texture.LINEAR_LINEAR;\r\n                case TextureMinFilter.NEAREST_MIPMAP_NEAREST:\r\n                    return Texture.LINEAR_NEAREST_MIPNEAREST;\r\n                case TextureMinFilter.LINEAR_MIPMAP_NEAREST:\r\n                    return Texture.LINEAR_LINEAR_MIPNEAREST;\r\n                case TextureMinFilter.NEAREST_MIPMAP_LINEAR:\r\n                    return Texture.LINEAR_NEAREST_MIPLINEAR;\r\n                case TextureMinFilter.LINEAR_MIPMAP_LINEAR:\r\n                    return Texture.LINEAR_LINEAR_MIPLINEAR;\r\n                default:\r\n                    Logger.Warn(`${context}/minFilter: Invalid value (${minFilter})`);\r\n                    return Texture.LINEAR_LINEAR_MIPLINEAR;\r\n            }\r\n        } else {\r\n            if (magFilter !== TextureMagFilter.NEAREST) {\r\n                Logger.Warn(`${context}/magFilter: Invalid value (${magFilter})`);\r\n            }\r\n\r\n            switch (minFilter) {\r\n                case TextureMinFilter.NEAREST:\r\n                    return Texture.NEAREST_NEAREST;\r\n                case TextureMinFilter.LINEAR:\r\n                    return Texture.NEAREST_LINEAR;\r\n                case TextureMinFilter.NEAREST_MIPMAP_NEAREST:\r\n                    return Texture.NEAREST_NEAREST_MIPNEAREST;\r\n                case TextureMinFilter.LINEAR_MIPMAP_NEAREST:\r\n                    return Texture.NEAREST_LINEAR_MIPNEAREST;\r\n                case TextureMinFilter.NEAREST_MIPMAP_LINEAR:\r\n                    return Texture.NEAREST_NEAREST_MIPLINEAR;\r\n                case TextureMinFilter.LINEAR_MIPMAP_LINEAR:\r\n                    return Texture.NEAREST_LINEAR_MIPLINEAR;\r\n                default:\r\n                    Logger.Warn(`${context}/minFilter: Invalid value (${minFilter})`);\r\n                    return Texture.NEAREST_NEAREST_MIPNEAREST;\r\n            }\r\n        }\r\n    }\r\n\r\n    private static _GetTypedArrayConstructor(context: string, componentType: AccessorComponentType): TypedArrayConstructor {\r\n        try {\r\n            return GetTypedArrayConstructor(componentType);\r\n        } catch (e) {\r\n            throw new Error(`${context}: ${e.message}`);\r\n        }\r\n    }\r\n\r\n    private static _GetTypedArray(context: string, componentType: AccessorComponentType, bufferView: ArrayBufferView, byteOffset: number | undefined, length: number): TypedArray {\r\n        const buffer = bufferView.buffer;\r\n        byteOffset = bufferView.byteOffset + (byteOffset || 0);\r\n\r\n        const constructor = GLTFLoader._GetTypedArrayConstructor(`${context}/componentType`, componentType);\r\n\r\n        const componentTypeLength = VertexBuffer.GetTypeByteLength(componentType);\r\n        if (byteOffset % componentTypeLength !== 0) {\r\n            // HACK: Copy the buffer if byte offset is not a multiple of component type byte length.\r\n            Logger.Warn(`${context}: Copying buffer as byte offset (${byteOffset}) is not a multiple of component type byte length (${componentTypeLength})`);\r\n            return new constructor(buffer.slice(byteOffset, byteOffset + length * componentTypeLength), 0);\r\n        }\r\n\r\n        return new constructor(buffer, byteOffset, length);\r\n    }\r\n\r\n    private static _GetNumComponents(context: string, type: string): number {\r\n        switch (type) {\r\n            case \"SCALAR\":\r\n                return 1;\r\n            case \"VEC2\":\r\n                return 2;\r\n            case \"VEC3\":\r\n                return 3;\r\n            case \"VEC4\":\r\n                return 4;\r\n            case \"MAT2\":\r\n                return 4;\r\n            case \"MAT3\":\r\n                return 9;\r\n            case \"MAT4\":\r\n                return 16;\r\n        }\r\n\r\n        throw new Error(`${context}: Invalid type (${type})`);\r\n    }\r\n\r\n    private static _ValidateUri(uri: string): boolean {\r\n        return Tools.IsBase64(uri) || uri.indexOf(\"..\") === -1;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public static _GetDrawMode(context: string, mode: number | undefined): number {\r\n        if (mode == undefined) {\r\n            mode = MeshPrimitiveMode.TRIANGLES;\r\n        }\r\n\r\n        switch (mode) {\r\n            case MeshPrimitiveMode.POINTS:\r\n                return Material.PointListDrawMode;\r\n            case MeshPrimitiveMode.LINES:\r\n                return Material.LineListDrawMode;\r\n            case MeshPrimitiveMode.LINE_LOOP:\r\n                return Material.LineLoopDrawMode;\r\n            case MeshPrimitiveMode.LINE_STRIP:\r\n                return Material.LineStripDrawMode;\r\n            case MeshPrimitiveMode.TRIANGLES:\r\n                return Material.TriangleFillMode;\r\n            case MeshPrimitiveMode.TRIANGLE_STRIP:\r\n                return Material.TriangleStripDrawMode;\r\n            case MeshPrimitiveMode.TRIANGLE_FAN:\r\n                return Material.TriangleFanDrawMode;\r\n        }\r\n\r\n        throw new Error(`${context}: Invalid mesh primitive mode (${mode})`);\r\n    }\r\n\r\n    private _compileMaterialsAsync(): Promise<void> {\r\n        this._parent._startPerformanceCounter(\"Compile materials\");\r\n\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        if (this._gltf.materials) {\r\n            for (const material of this._gltf.materials) {\r\n                if (material._data) {\r\n                    for (const babylonDrawMode in material._data) {\r\n                        const babylonData = material._data[babylonDrawMode];\r\n                        for (const babylonMesh of babylonData.babylonMeshes) {\r\n                            // Ensure nonUniformScaling is set if necessary.\r\n                            babylonMesh.computeWorldMatrix(true);\r\n\r\n                            const babylonMaterial = babylonData.babylonMaterial;\r\n                            promises.push(babylonMaterial.forceCompilationAsync(babylonMesh));\r\n                            promises.push(babylonMaterial.forceCompilationAsync(babylonMesh, { useInstances: true }));\r\n                            if (this._parent.useClipPlane) {\r\n                                promises.push(babylonMaterial.forceCompilationAsync(babylonMesh, { clipPlane: true }));\r\n                                promises.push(babylonMaterial.forceCompilationAsync(babylonMesh, { clipPlane: true, useInstances: true }));\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        return Promise.all(promises).then(() => {\r\n            this._parent._endPerformanceCounter(\"Compile materials\");\r\n        });\r\n    }\r\n\r\n    private _compileShadowGeneratorsAsync(): Promise<void> {\r\n        this._parent._startPerformanceCounter(\"Compile shadow generators\");\r\n\r\n        const promises = new Array<Promise<unknown>>();\r\n\r\n        const lights = this._babylonScene.lights;\r\n        for (const light of lights) {\r\n            const generator = light.getShadowGenerator();\r\n            if (generator) {\r\n                promises.push(generator.forceCompilationAsync());\r\n            }\r\n        }\r\n\r\n        return Promise.all(promises).then(() => {\r\n            this._parent._endPerformanceCounter(\"Compile shadow generators\");\r\n        });\r\n    }\r\n\r\n    private _forEachExtensions(action: (extension: IGLTFLoaderExtension) => void): void {\r\n        for (const extension of this._extensions) {\r\n            if (extension.enabled) {\r\n                action(extension);\r\n            }\r\n        }\r\n    }\r\n\r\n    private _applyExtensions<T>(property: IProperty, functionName: string, actionAsync: (extension: IGLTFLoaderExtension) => Nullable<T> | undefined): Nullable<T> {\r\n        for (const extension of this._extensions) {\r\n            if (extension.enabled) {\r\n                const id = `${extension.name}.${functionName}`;\r\n                const loaderProperty = property as ILoaderProperty;\r\n                loaderProperty._activeLoaderExtensionFunctions = loaderProperty._activeLoaderExtensionFunctions || {};\r\n                const activeLoaderExtensionFunctions = loaderProperty._activeLoaderExtensionFunctions;\r\n                if (!activeLoaderExtensionFunctions[id]) {\r\n                    activeLoaderExtensionFunctions[id] = true;\r\n\r\n                    try {\r\n                        const result = actionAsync(extension);\r\n                        if (result) {\r\n                            return result;\r\n                        }\r\n                    } finally {\r\n                        delete activeLoaderExtensionFunctions[id];\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        return null;\r\n    }\r\n\r\n    private _extensionsOnLoading(): void {\r\n        this._forEachExtensions((extension) => extension.onLoading && extension.onLoading());\r\n    }\r\n\r\n    private _extensionsOnReady(): void {\r\n        this._forEachExtensions((extension) => extension.onReady && extension.onReady());\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadSceneAsync(context: string, scene: IScene): Nullable<Promise<void>> {\r\n        return this._applyExtensions(scene, \"loadScene\", (extension) => extension.loadSceneAsync && extension.loadSceneAsync(context, scene));\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadNodeAsync(context: string, node: INode, assign: (babylonTransformNode: TransformNode) => void): Nullable<Promise<TransformNode>> {\r\n        return this._applyExtensions(node, \"loadNode\", (extension) => extension.loadNodeAsync && extension.loadNodeAsync(context, node, assign));\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadCameraAsync(context: string, camera: ICamera, assign: (babylonCamera: Camera) => void): Nullable<Promise<Camera>> {\r\n        return this._applyExtensions(camera, \"loadCamera\", (extension) => extension.loadCameraAsync && extension.loadCameraAsync(context, camera, assign));\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadVertexDataAsync(context: string, primitive: IMeshPrimitive, babylonMesh: Mesh): Nullable<Promise<Geometry>> {\r\n        return this._applyExtensions(primitive, \"loadVertexData\", (extension) => extension._loadVertexDataAsync && extension._loadVertexDataAsync(context, primitive, babylonMesh));\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadMeshPrimitiveAsync(\r\n        context: string,\r\n        name: string,\r\n        node: INode,\r\n        mesh: IMesh,\r\n        primitive: IMeshPrimitive,\r\n        assign: (babylonMesh: AbstractMesh) => void\r\n    ): Nullable<Promise<AbstractMesh>> {\r\n        return this._applyExtensions(\r\n            primitive,\r\n            \"loadMeshPrimitive\",\r\n            (extension) => extension._loadMeshPrimitiveAsync && extension._loadMeshPrimitiveAsync(context, name, node, mesh, primitive, assign)\r\n        );\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadMaterialAsync(\r\n        context: string,\r\n        material: IMaterial,\r\n        babylonMesh: Nullable<Mesh>,\r\n        babylonDrawMode: number,\r\n        assign: (babylonMaterial: Material) => void\r\n    ): Nullable<Promise<Material>> {\r\n        return this._applyExtensions(\r\n            material,\r\n            \"loadMaterial\",\r\n            (extension) => extension._loadMaterialAsync && extension._loadMaterialAsync(context, material, babylonMesh, babylonDrawMode, assign)\r\n        );\r\n    }\r\n\r\n    private _extensionsCreateMaterial(context: string, material: IMaterial, babylonDrawMode: number): Nullable<Material> {\r\n        return this._applyExtensions(material, \"createMaterial\", (extension) => extension.createMaterial && extension.createMaterial(context, material, babylonDrawMode));\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return this._applyExtensions(\r\n            material,\r\n            \"loadMaterialProperties\",\r\n            (extension) => extension.loadMaterialPropertiesAsync && extension.loadMaterialPropertiesAsync(context, material, babylonMaterial)\r\n        );\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadTextureInfoAsync(context: string, textureInfo: ITextureInfo, assign: (babylonTexture: BaseTexture) => void): Nullable<Promise<BaseTexture>> {\r\n        return this._applyExtensions(textureInfo, \"loadTextureInfo\", (extension) => extension.loadTextureInfoAsync && extension.loadTextureInfoAsync(context, textureInfo, assign));\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadTextureAsync(context: string, texture: ITexture, assign: (babylonTexture: BaseTexture) => void): Nullable<Promise<BaseTexture>> {\r\n        return this._applyExtensions(texture, \"loadTexture\", (extension) => extension._loadTextureAsync && extension._loadTextureAsync(context, texture, assign));\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadAnimationAsync(context: string, animation: IAnimation): Nullable<Promise<AnimationGroup>> {\r\n        return this._applyExtensions(animation, \"loadAnimation\", (extension) => extension.loadAnimationAsync && extension.loadAnimationAsync(context, animation));\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadAnimationChannelAsync(\r\n        context: string,\r\n        animationContext: string,\r\n        animation: IAnimation,\r\n        channel: IAnimationChannel,\r\n        onLoad: (babylonAnimatable: IAnimatable, babylonAnimation: Animation) => void\r\n    ): Nullable<Promise<void>> {\r\n        return this._applyExtensions(\r\n            animation,\r\n            \"loadAnimationChannel\",\r\n            (extension) => extension._loadAnimationChannelAsync && extension._loadAnimationChannelAsync(context, animationContext, animation, channel, onLoad)\r\n        );\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadSkinAsync(context: string, node: INode, skin: ISkin): Nullable<Promise<void>> {\r\n        return this._applyExtensions(skin, \"loadSkin\", (extension) => extension._loadSkinAsync && extension._loadSkinAsync(context, node, skin));\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadUriAsync(context: string, property: IProperty, uri: string): Nullable<Promise<ArrayBufferView>> {\r\n        return this._applyExtensions(property, \"loadUri\", (extension) => extension._loadUriAsync && extension._loadUriAsync(context, property, uri));\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadBufferViewAsync(context: string, bufferView: IBufferView): Nullable<Promise<ArrayBufferView>> {\r\n        return this._applyExtensions(bufferView, \"loadBufferView\", (extension) => extension.loadBufferViewAsync && extension.loadBufferViewAsync(context, bufferView));\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    private _extensionsLoadBufferAsync(context: string, buffer: IBuffer, byteOffset: number, byteLength: number): Nullable<Promise<ArrayBufferView>> {\r\n        return this._applyExtensions(buffer, \"loadBuffer\", (extension) => extension.loadBufferAsync && extension.loadBufferAsync(context, buffer, byteOffset, byteLength));\r\n    }\r\n\r\n    /**\r\n     * Helper method called by a loader extension to load an glTF extension.\r\n     * @param context The context when loading the asset\r\n     * @param property The glTF property to load the extension from\r\n     * @param extensionName The name of the extension to load\r\n     * @param actionAsync The action to run\r\n     * @returns The promise returned by actionAsync or null if the extension does not exist\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax, @typescript-eslint/naming-convention\r\n    public static LoadExtensionAsync<TExtension = unknown, TResult = void>(\r\n        context: string,\r\n        property: IProperty,\r\n        extensionName: string,\r\n        actionAsync: (extensionContext: string, extension: TExtension) => Nullable<Promise<TResult>>\r\n    ): Nullable<Promise<TResult>> {\r\n        if (!property.extensions) {\r\n            return null;\r\n        }\r\n\r\n        const extensions = property.extensions;\r\n\r\n        const extension = extensions[extensionName] as TExtension;\r\n        if (!extension) {\r\n            return null;\r\n        }\r\n\r\n        return actionAsync(`${context}/extensions/${extensionName}`, extension);\r\n    }\r\n\r\n    /**\r\n     * Helper method called by a loader extension to load a glTF extra.\r\n     * @param context The context when loading the asset\r\n     * @param property The glTF property to load the extra from\r\n     * @param extensionName The name of the extension to load\r\n     * @param actionAsync The action to run\r\n     * @returns The promise returned by actionAsync or null if the extra does not exist\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax, @typescript-eslint/naming-convention\r\n    public static LoadExtraAsync<TExtra = unknown, TResult = void>(\r\n        context: string,\r\n        property: IProperty,\r\n        extensionName: string,\r\n        actionAsync: (extraContext: string, extra: TExtra) => Nullable<Promise<TResult>>\r\n    ): Nullable<Promise<TResult>> {\r\n        if (!property.extras) {\r\n            return null;\r\n        }\r\n\r\n        const extras = property.extras;\r\n\r\n        const extra = extras[extensionName] as TExtra;\r\n        if (!extra) {\r\n            return null;\r\n        }\r\n\r\n        return actionAsync(`${context}/extras/${extensionName}`, extra);\r\n    }\r\n\r\n    /**\r\n     * Checks for presence of an extension.\r\n     * @param name The name of the extension to check\r\n     * @returns A boolean indicating the presence of the given extension name in `extensionsUsed`\r\n     */\r\n    public isExtensionUsed(name: string): boolean {\r\n        return !!this._gltf.extensionsUsed && this._gltf.extensionsUsed.indexOf(name) !== -1;\r\n    }\r\n\r\n    /**\r\n     * Increments the indentation level and logs a message.\r\n     * @param message The message to log\r\n     */\r\n    public logOpen(message: string): void {\r\n        this._parent._logOpen(message);\r\n    }\r\n\r\n    /**\r\n     * Decrements the indentation level.\r\n     */\r\n    public logClose(): void {\r\n        this._parent._logClose();\r\n    }\r\n\r\n    /**\r\n     * Logs a message\r\n     * @param message The message to log\r\n     */\r\n    public log(message: string): void {\r\n        this._parent._log(message);\r\n    }\r\n\r\n    /**\r\n     * Starts a performance counter.\r\n     * @param counterName The name of the performance counter\r\n     */\r\n    public startPerformanceCounter(counterName: string): void {\r\n        this._parent._startPerformanceCounter(counterName);\r\n    }\r\n\r\n    /**\r\n     * Ends a performance counter.\r\n     * @param counterName The name of the performance counter\r\n     */\r\n    public endPerformanceCounter(counterName: string): void {\r\n        this._parent._endPerformanceCounter(counterName);\r\n    }\r\n}\r\n\r\nGLTFFileLoader._CreateGLTF2Loader = (parent) => new GLTFLoader(parent);\r\n","import type { Nullable } from \"core/types\";\r\nimport { SphericalHarmonics, SphericalPolynomial } from \"core/Maths/sphericalPolynomial\";\r\nimport { Quaternion, Matrix } from \"core/Maths/math.vector\";\r\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\r\nimport { RawCubeTexture } from \"core/Materials/Textures/rawCubeTexture\";\r\n\r\nimport type { IEXTLightsImageBased_LightReferenceImageBased, IEXTLightsImageBased_LightImageBased, IEXTLightsImageBased } from \"babylonjs-gltf2interface\";\r\nimport type { IScene } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader, ArrayItem } from \"../glTFLoader\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"EXT_lights_image_based\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the EXT_lights_image_based extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"EXT_lights_image_based\"]: {};\r\n    }\r\n}\r\n\r\ndeclare module \"babylonjs-gltf2interface\" {\r\n    /** @internal */\r\n    // eslint-disable-next-line @typescript-eslint/naming-convention\r\n    interface IEXTLightsImageBased_LightImageBased {\r\n        _babylonTexture?: BaseTexture;\r\n        _loaded?: Promise<void>;\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Vendor/EXT_lights_image_based/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class EXT_lights_image_based implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    private _loader: GLTFLoader;\r\n    private _lights?: IEXTLightsImageBased_LightImageBased[];\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n        delete this._lights;\r\n    }\r\n\r\n    /** @internal */\r\n    public onLoading(): void {\r\n        const extensions = this._loader.gltf.extensions;\r\n        if (extensions && extensions[this.name]) {\r\n            const extension = extensions[this.name] as IEXTLightsImageBased;\r\n            this._lights = extension.lights;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadSceneAsync(context: string, scene: IScene): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IEXTLightsImageBased_LightReferenceImageBased>(context, scene, this.name, async (extensionContext, extension) => {\r\n            this._loader._allMaterialsDirtyRequired = true;\r\n\r\n            const promises = new Array<Promise<any>>();\r\n\r\n            promises.push(this._loader.loadSceneAsync(context, scene));\r\n\r\n            this._loader.logOpen(`${extensionContext}`);\r\n\r\n            const light = ArrayItem.Get(`${extensionContext}/light`, this._lights, extension.light);\r\n            promises.push(\r\n                // eslint-disable-next-line github/no-then\r\n                this._loadLightAsync(`/extensions/${this.name}/lights/${extension.light}`, light).then((texture) => {\r\n                    this._loader.babylonScene.environmentTexture = texture;\r\n                })\r\n            );\r\n\r\n            this._loader.logClose();\r\n\r\n            // eslint-disable-next-line github/no-then\r\n            return await Promise.all(promises).then(() => {});\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadLightAsync(context: string, light: IEXTLightsImageBased_LightImageBased): Promise<BaseTexture> {\r\n        if (!light._loaded) {\r\n            const promises = new Array<Promise<any>>();\r\n\r\n            this._loader.logOpen(`${context}`);\r\n\r\n            const imageData = new Array<Array<ArrayBufferView>>(light.specularImages.length);\r\n            for (let mipmap = 0; mipmap < light.specularImages.length; mipmap++) {\r\n                const faces = light.specularImages[mipmap];\r\n                imageData[mipmap] = new Array<ArrayBufferView>(faces.length);\r\n                for (let face = 0; face < faces.length; face++) {\r\n                    const specularImageContext = `${context}/specularImages/${mipmap}/${face}`;\r\n                    this._loader.logOpen(`${specularImageContext}`);\r\n\r\n                    const index = faces[face];\r\n                    const image = ArrayItem.Get(specularImageContext, this._loader.gltf.images, index);\r\n                    promises.push(\r\n                        // eslint-disable-next-line github/no-then\r\n                        this._loader.loadImageAsync(`/images/${index}`, image).then((data) => {\r\n                            imageData[mipmap][face] = data;\r\n                        })\r\n                    );\r\n\r\n                    this._loader.logClose();\r\n                }\r\n            }\r\n\r\n            this._loader.logClose();\r\n\r\n            // eslint-disable-next-line github/no-then\r\n            light._loaded = Promise.all(promises).then(async () => {\r\n                const babylonTexture = new RawCubeTexture(this._loader.babylonScene, null, light.specularImageSize);\r\n                babylonTexture.name = light.name || \"environment\";\r\n                light._babylonTexture = babylonTexture;\r\n\r\n                if (light.intensity != undefined) {\r\n                    babylonTexture.level = light.intensity;\r\n                }\r\n\r\n                if (light.rotation) {\r\n                    let rotation = Quaternion.FromArray(light.rotation);\r\n\r\n                    // Invert the rotation so that positive rotation is counter-clockwise.\r\n                    if (!this._loader.babylonScene.useRightHandedSystem) {\r\n                        rotation = Quaternion.Inverse(rotation);\r\n                    }\r\n\r\n                    Matrix.FromQuaternionToRef(rotation, babylonTexture.getReflectionTextureMatrix());\r\n                }\r\n\r\n                if (!light.irradianceCoefficients) {\r\n                    throw new Error(`${context}: Irradiance coefficients are missing`);\r\n                }\r\n\r\n                const sphericalHarmonics = SphericalHarmonics.FromArray(light.irradianceCoefficients);\r\n                sphericalHarmonics.scaleInPlace(light.intensity);\r\n\r\n                sphericalHarmonics.convertIrradianceToLambertianRadiance();\r\n                const sphericalPolynomial = SphericalPolynomial.FromHarmonics(sphericalHarmonics);\r\n\r\n                // Compute the lod generation scale to fit exactly to the number of levels available.\r\n                const lodGenerationScale = (imageData.length - 1) / Math.log2(light.specularImageSize);\r\n                return await babylonTexture.updateRGBDAsync(imageData, sphericalPolynomial, lodGenerationScale);\r\n            });\r\n        }\r\n\r\n        // eslint-disable-next-line github/no-then\r\n        return light._loaded.then(() => {\r\n            return light._babylonTexture!;\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new EXT_lights_image_based(loader));\r\n","import { Vector3, Quaternion, Matrix, TmpVectors } from \"core/Maths/math.vector\";\r\nimport type { Mesh } from \"core/Meshes/mesh\";\r\nimport type { TransformNode } from \"core/Meshes/transformNode\";\r\nimport type { Nullable } from \"core/types\";\r\nimport { GLTFLoader, ArrayItem } from \"../glTFLoader\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport type { INode } from \"../glTFLoaderInterfaces\";\r\nimport type { IEXTMeshGpuInstancing } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nimport \"core/Meshes/thinInstanceMesh\";\r\n\r\nconst NAME = \"EXT_mesh_gpu_instancing\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the EXT_mesh_gpu_instancing extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"EXT_mesh_gpu_instancing\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Vendor/EXT_mesh_gpu_instancing/README.md)\r\n * [Playground Sample](https://playground.babylonjs.com/#QFIGLW#9)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class EXT_mesh_gpu_instancing implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadNodeAsync(context: string, node: INode, assign: (babylonTransformNode: TransformNode) => void): Nullable<Promise<TransformNode>> {\r\n        return GLTFLoader.LoadExtensionAsync<IEXTMeshGpuInstancing, TransformNode>(context, node, this.name, async (extensionContext, extension) => {\r\n            this._loader._disableInstancedMesh++;\r\n\r\n            const promise = this._loader.loadNodeAsync(`/nodes/${node.index}`, node, assign);\r\n\r\n            this._loader._disableInstancedMesh--;\r\n\r\n            if (!node._primitiveBabylonMeshes) {\r\n                return await promise;\r\n            }\r\n\r\n            const promises = new Array<Promise<Nullable<Float32Array>>>();\r\n            let instanceCount = 0;\r\n\r\n            const loadAttribute = (attribute: string) => {\r\n                if (extension.attributes[attribute] == undefined) {\r\n                    promises.push(Promise.resolve(null));\r\n                    return;\r\n                }\r\n\r\n                const accessor = ArrayItem.Get(`${extensionContext}/attributes/${attribute}`, this._loader.gltf.accessors, extension.attributes[attribute]);\r\n                promises.push(this._loader._loadFloatAccessorAsync(`/accessors/${accessor.bufferView}`, accessor));\r\n\r\n                if (instanceCount === 0) {\r\n                    instanceCount = accessor.count;\r\n                } else if (instanceCount !== accessor.count) {\r\n                    throw new Error(`${extensionContext}/attributes: Instance buffer accessors do not have the same count.`);\r\n                }\r\n            };\r\n\r\n            loadAttribute(\"TRANSLATION\");\r\n            loadAttribute(\"ROTATION\");\r\n            loadAttribute(\"SCALE\");\r\n\r\n            // eslint-disable-next-line github/no-then\r\n            return await promise.then(async (babylonTransformNode) => {\r\n                const [translationBuffer, rotationBuffer, scaleBuffer] = await Promise.all(promises);\r\n                const matrices = new Float32Array(instanceCount * 16);\r\n                TmpVectors.Vector3[0].copyFromFloats(0, 0, 0); // translation\r\n                TmpVectors.Quaternion[0].copyFromFloats(0, 0, 0, 1); // rotation\r\n                TmpVectors.Vector3[1].copyFromFloats(1, 1, 1); // scale\r\n                for (let i = 0; i < instanceCount; ++i) {\r\n                    translationBuffer && Vector3.FromArrayToRef(translationBuffer, i * 3, TmpVectors.Vector3[0]);\r\n                    rotationBuffer && Quaternion.FromArrayToRef(rotationBuffer, i * 4, TmpVectors.Quaternion[0]);\r\n                    scaleBuffer && Vector3.FromArrayToRef(scaleBuffer, i * 3, TmpVectors.Vector3[1]);\r\n\r\n                    Matrix.ComposeToRef(TmpVectors.Vector3[1], TmpVectors.Quaternion[0], TmpVectors.Vector3[0], TmpVectors.Matrix[0]);\r\n\r\n                    TmpVectors.Matrix[0].copyToArray(matrices, i * 16);\r\n                }\r\n                for (const babylonMesh of node._primitiveBabylonMeshes!) {\r\n                    (babylonMesh as Mesh).thinInstanceSetBuffer(\"matrix\", matrices, 16, true);\r\n                }\r\n                return babylonTransformNode;\r\n            });\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new EXT_mesh_gpu_instancing(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { ArrayItem, GLTFLoader } from \"../glTFLoader\";\r\nimport type { IBufferView } from \"../glTFLoaderInterfaces\";\r\nimport type { IEXTMeshoptCompression } from \"babylonjs-gltf2interface\";\r\nimport { MeshoptCompression } from \"core/Meshes/Compression/meshoptCompression\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"EXT_meshopt_compression\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the EXT_meshopt_compression extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"EXT_meshopt_compression\"]: {};\r\n    }\r\n}\r\n\r\ninterface IBufferViewMeshopt extends IBufferView {\r\n    _meshOptData?: Promise<ArrayBufferView>;\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Vendor/EXT_meshopt_compression/README.md)\r\n *\r\n * This extension uses a WebAssembly decoder module from https://github.com/zeux/meshoptimizer/tree/master/js\r\n * @since 5.0.0\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class EXT_meshopt_compression implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this.enabled = loader.isExtensionUsed(NAME);\r\n        this._loader = loader;\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadBufferViewAsync(context: string, bufferView: IBufferView): Nullable<Promise<ArrayBufferView>> {\r\n        return GLTFLoader.LoadExtensionAsync<IEXTMeshoptCompression, ArrayBufferView>(context, bufferView, this.name, async (extensionContext, extension) => {\r\n            const bufferViewMeshopt = bufferView as IBufferViewMeshopt;\r\n            if (bufferViewMeshopt._meshOptData) {\r\n                return await bufferViewMeshopt._meshOptData;\r\n            }\r\n\r\n            const buffer = ArrayItem.Get(`${context}/buffer`, this._loader.gltf.buffers, extension.buffer);\r\n            bufferViewMeshopt._meshOptData = this._loader\r\n                .loadBufferAsync(`/buffers/${buffer.index}`, buffer, extension.byteOffset || 0, extension.byteLength)\r\n                // eslint-disable-next-line github/no-then\r\n                .then(async (buffer) => {\r\n                    return await MeshoptCompression.Default.decodeGltfBufferAsync(buffer as Uint8Array, extension.count, extension.byteStride, extension.mode, extension.filter);\r\n                });\r\n\r\n            return await bufferViewMeshopt._meshOptData;\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new EXT_meshopt_compression(loader));\r\n","import type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader, ArrayItem } from \"../glTFLoader\";\r\nimport type { ITexture } from \"../glTFLoaderInterfaces\";\r\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\r\nimport type { Nullable } from \"core/types\";\r\nimport type { IEXTTextureWebP } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"EXT_texture_webp\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the EXT_texture_webp extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"EXT_texture_webp\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Vendor/EXT_texture_webp/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class EXT_texture_webp implements IGLTFLoaderExtension {\r\n    /** The name of this extension. */\r\n    public readonly name = NAME;\r\n\r\n    /** Defines whether this extension is enabled. */\r\n    public enabled: boolean;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public _loadTextureAsync(context: string, texture: ITexture, assign: (babylonTexture: BaseTexture) => void): Nullable<Promise<BaseTexture>> {\r\n        return GLTFLoader.LoadExtensionAsync<IEXTTextureWebP, BaseTexture>(context, texture, this.name, async (extensionContext, extension) => {\r\n            const sampler = texture.sampler == undefined ? GLTFLoader.DefaultSampler : ArrayItem.Get(`${context}/sampler`, this._loader.gltf.samplers, texture.sampler);\r\n            const image = ArrayItem.Get(`${extensionContext}/source`, this._loader.gltf.images, extension.source);\r\n            return await this._loader._createTextureAsync(\r\n                context,\r\n                sampler,\r\n                image,\r\n                (babylonTexture) => {\r\n                    assign(babylonTexture);\r\n                },\r\n                undefined,\r\n                !texture._textureInfo.nonColorData\r\n            );\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new EXT_texture_webp(loader));\r\n","import type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader, ArrayItem } from \"../glTFLoader\";\r\nimport type { ITexture } from \"../glTFLoaderInterfaces\";\r\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\r\nimport type { Nullable } from \"core/types\";\r\nimport type { IEXTTextureAVIF } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"EXT_texture_avif\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the EXT_texture_avif extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"EXT_texture_avif\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [glTF PR](https://github.com/KhronosGroup/glTF/pull/2235)\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Vendor/EXT_texture_avif/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class EXT_texture_avif implements IGLTFLoaderExtension {\r\n    /** The name of this extension. */\r\n    public readonly name = NAME;\r\n\r\n    /** Defines whether this extension is enabled. */\r\n    public enabled: boolean;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public _loadTextureAsync(context: string, texture: ITexture, assign: (babylonTexture: BaseTexture) => void): Nullable<Promise<BaseTexture>> {\r\n        return GLTFLoader.LoadExtensionAsync<IEXTTextureAVIF, BaseTexture>(context, texture, this.name, async (extensionContext, extension) => {\r\n            const sampler = texture.sampler == undefined ? GLTFLoader.DefaultSampler : ArrayItem.Get(`${context}/sampler`, this._loader.gltf.samplers, texture.sampler);\r\n            const image = ArrayItem.Get(`${extensionContext}/source`, this._loader.gltf.images, extension.source);\r\n            return await this._loader._createTextureAsync(\r\n                context,\r\n                sampler,\r\n                image,\r\n                (babylonTexture) => {\r\n                    assign(babylonTexture);\r\n                },\r\n                undefined,\r\n                !texture._textureInfo.nonColorData\r\n            );\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new EXT_texture_avif(loader));\r\n","/* eslint-disable @typescript-eslint/naming-convention */\r\nimport type { Nullable } from \"core/types\";\r\nimport { Vector3 } from \"core/Maths/math.vector\";\r\nimport { Color3 } from \"core/Maths/math.color\";\r\nimport { SpotLight } from \"core/Lights/spotLight\";\r\nimport { Light } from \"core/Lights/light\";\r\nimport type { TransformNode } from \"core/Meshes/transformNode\";\r\n\r\nimport type { IEXTLightsIES_LightReference } from \"babylonjs-gltf2interface\";\r\nimport type { IEXTLightsIES_Light, INode } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader, ArrayItem } from \"../glTFLoader\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\nimport { Texture } from \"core/Materials/Textures/texture\";\r\n\r\nconst NAME = \"EXT_lights_ies\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the EXT_lights_ies extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"EXT_lights_ies\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Vendor/EXT_lights_ies)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class EXT_lights_ies implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /** hidden */\r\n    private _loader: GLTFLoader;\r\n    private _lights?: IEXTLightsIES_Light[];\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n        delete this._lights;\r\n    }\r\n\r\n    /** @internal */\r\n    public onLoading(): void {\r\n        const extensions = this._loader.gltf.extensions;\r\n        if (extensions && extensions[this.name]) {\r\n            const extension = extensions[this.name];\r\n            this._lights = extension.lights;\r\n            ArrayItem.Assign(this._lights);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadNodeAsync(context: string, node: INode, assign: (babylonTransformNode: TransformNode) => void): Nullable<Promise<TransformNode>> {\r\n        return GLTFLoader.LoadExtensionAsync<IEXTLightsIES_LightReference, TransformNode>(context, node, this.name, async (extensionContext, extension) => {\r\n            this._loader._allMaterialsDirtyRequired = true;\r\n\r\n            let babylonSpotLight: SpotLight;\r\n            let light: IEXTLightsIES_Light;\r\n\r\n            const transformNode = await this._loader.loadNodeAsync(context, node, (babylonMesh) => {\r\n                light = ArrayItem.Get(extensionContext, this._lights, extension.light);\r\n                const name = light.name || babylonMesh.name;\r\n\r\n                this._loader.babylonScene._blockEntityCollection = !!this._loader._assetContainer;\r\n\r\n                babylonSpotLight = new SpotLight(name, Vector3.Zero(), Vector3.Backward(), 0, 1, this._loader.babylonScene);\r\n                babylonSpotLight.angle = Math.PI / 2;\r\n                babylonSpotLight.innerAngle = 0;\r\n\r\n                babylonSpotLight._parentContainer = this._loader._assetContainer;\r\n                this._loader.babylonScene._blockEntityCollection = false;\r\n                light._babylonLight = babylonSpotLight;\r\n\r\n                babylonSpotLight.falloffType = Light.FALLOFF_GLTF;\r\n                babylonSpotLight.diffuse = extension.color ? Color3.FromArray(extension.color) : Color3.White();\r\n                babylonSpotLight.intensity = extension.multiplier || 1;\r\n                babylonSpotLight.range = Number.MAX_VALUE;\r\n                babylonSpotLight.parent = babylonMesh;\r\n\r\n                this._loader._babylonLights.push(babylonSpotLight);\r\n\r\n                GLTFLoader.AddPointerMetadata(babylonSpotLight, extensionContext);\r\n\r\n                assign(babylonMesh);\r\n            });\r\n\r\n            // Load the profile\r\n            let bufferData: ArrayBufferView;\r\n            if (light!.uri) {\r\n                bufferData = await this._loader.loadUriAsync(context, light!, light!.uri);\r\n            } else {\r\n                const bufferView = ArrayItem.Get(`${context}/bufferView`, this._loader.gltf.bufferViews, light!.bufferView);\r\n                bufferData = await this._loader.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView);\r\n            }\r\n            babylonSpotLight!.iesProfileTexture = new Texture(\r\n                name + \"_iesProfile\",\r\n                this._loader.babylonScene,\r\n                true,\r\n                false,\r\n                undefined,\r\n                null,\r\n                null,\r\n                bufferData,\r\n                true,\r\n                undefined,\r\n                undefined,\r\n                undefined,\r\n                undefined,\r\n                \".ies\"\r\n            );\r\n\r\n            return transformNode;\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new EXT_lights_ies(loader));\r\n","/* eslint-disable github/no-then */\r\nimport { DracoDecoder } from \"core/Meshes/Compression/dracoDecoder\";\r\nimport type { Nullable } from \"core/types\";\r\nimport { VertexBuffer } from \"core/Buffers/buffer\";\r\nimport type { Geometry } from \"core/Meshes/geometry\";\r\nimport type { Mesh } from \"core/Meshes/mesh\";\r\n\r\nimport { MeshPrimitiveMode } from \"babylonjs-gltf2interface\";\r\nimport type { IKHRDracoMeshCompression } from \"babylonjs-gltf2interface\";\r\nimport type { IMeshPrimitive, IBufferView } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader, ArrayItem, LoadBoundingInfoFromPositionAccessor } from \"../glTFLoader\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_draco_mesh_compression\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_draco_mesh_compression extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_draco_mesh_compression\"]: {};\r\n    }\r\n}\r\n\r\ninterface IBufferViewDraco extends IBufferView {\r\n    _dracoBabylonGeometry?: Promise<Geometry>;\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_draco_mesh_compression/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_draco_mesh_compression implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * The draco decoder used to decode vertex data or DracoDecoder.Default if not defined\r\n     */\r\n    public dracoDecoder?: DracoDecoder;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines whether to use the normalized flag from the glTF accessor instead of the Draco data. Defaults to true.\r\n     */\r\n    public useNormalizedFlagFromAccessor = true;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = DracoDecoder.DefaultAvailable && this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose(): void {\r\n        delete this.dracoDecoder;\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public _loadVertexDataAsync(context: string, primitive: IMeshPrimitive, babylonMesh: Mesh): Nullable<Promise<Geometry>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRDracoMeshCompression, Geometry>(context, primitive, this.name, async (extensionContext, extension) => {\r\n            if (primitive.mode != undefined) {\r\n                if (primitive.mode !== MeshPrimitiveMode.TRIANGLES && primitive.mode !== MeshPrimitiveMode.TRIANGLE_STRIP) {\r\n                    throw new Error(`${context}: Unsupported mode ${primitive.mode}`);\r\n                }\r\n            }\r\n\r\n            const attributes: { [kind: string]: number } = {};\r\n            const normalized: { [kind: string]: boolean } = {};\r\n            const loadAttribute = (name: string, kind: string) => {\r\n                const uniqueId = extension.attributes[name];\r\n                if (uniqueId == undefined) {\r\n                    return;\r\n                }\r\n\r\n                babylonMesh._delayInfo = babylonMesh._delayInfo || [];\r\n                if (babylonMesh._delayInfo.indexOf(kind) === -1) {\r\n                    babylonMesh._delayInfo.push(kind);\r\n                }\r\n\r\n                attributes[kind] = uniqueId;\r\n\r\n                if (this.useNormalizedFlagFromAccessor) {\r\n                    const accessor = ArrayItem.TryGet(this._loader.gltf.accessors, primitive.attributes[name]);\r\n                    if (accessor) {\r\n                        normalized[kind] = accessor.normalized || false;\r\n                    }\r\n                }\r\n            };\r\n\r\n            loadAttribute(\"POSITION\", VertexBuffer.PositionKind);\r\n            loadAttribute(\"NORMAL\", VertexBuffer.NormalKind);\r\n            loadAttribute(\"TANGENT\", VertexBuffer.TangentKind);\r\n            loadAttribute(\"TEXCOORD_0\", VertexBuffer.UVKind);\r\n            loadAttribute(\"TEXCOORD_1\", VertexBuffer.UV2Kind);\r\n            loadAttribute(\"TEXCOORD_2\", VertexBuffer.UV3Kind);\r\n            loadAttribute(\"TEXCOORD_3\", VertexBuffer.UV4Kind);\r\n            loadAttribute(\"TEXCOORD_4\", VertexBuffer.UV5Kind);\r\n            loadAttribute(\"TEXCOORD_5\", VertexBuffer.UV6Kind);\r\n            loadAttribute(\"JOINTS_0\", VertexBuffer.MatricesIndicesKind);\r\n            loadAttribute(\"WEIGHTS_0\", VertexBuffer.MatricesWeightsKind);\r\n            loadAttribute(\"COLOR_0\", VertexBuffer.ColorKind);\r\n\r\n            const bufferView = ArrayItem.Get(extensionContext, this._loader.gltf.bufferViews, extension.bufferView) as IBufferViewDraco;\r\n            if (!bufferView._dracoBabylonGeometry) {\r\n                bufferView._dracoBabylonGeometry = this._loader.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView).then(async (data) => {\r\n                    const dracoDecoder = this.dracoDecoder || DracoDecoder.Default;\r\n                    const positionAccessor = ArrayItem.TryGet(this._loader.gltf.accessors, primitive.attributes[\"POSITION\"]);\r\n                    const babylonBoundingInfo =\r\n                        !this._loader.parent.alwaysComputeBoundingBox && !babylonMesh.skeleton && positionAccessor ? LoadBoundingInfoFromPositionAccessor(positionAccessor) : null;\r\n                    return await dracoDecoder\r\n                        ._decodeMeshToGeometryForGltfAsync(babylonMesh.name, this._loader.babylonScene, data, attributes, normalized, babylonBoundingInfo)\r\n                        .catch((error) => {\r\n                            throw new Error(`${context}: ${error.message}`);\r\n                        });\r\n                });\r\n            }\r\n\r\n            return await bufferView._dracoBabylonGeometry;\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_draco_mesh_compression(loader));\r\n","/* eslint-disable @typescript-eslint/naming-convention */\r\nimport type { Nullable } from \"core/types\";\r\nimport { Vector3 } from \"core/Maths/math.vector\";\r\nimport { Color3 } from \"core/Maths/math.color\";\r\nimport { DirectionalLight } from \"core/Lights/directionalLight\";\r\nimport { PointLight } from \"core/Lights/pointLight\";\r\nimport { SpotLight } from \"core/Lights/spotLight\";\r\nimport { Light } from \"core/Lights/light\";\r\nimport type { TransformNode } from \"core/Meshes/transformNode\";\r\n\r\nimport type { IKHRLightsPunctual_LightReference } from \"babylonjs-gltf2interface\";\r\nimport { KHRLightsPunctual_LightType } from \"babylonjs-gltf2interface\";\r\nimport type { INode, IKHRLightsPunctual_Light } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader, ArrayItem } from \"../glTFLoader\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_lights_punctual\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_lights_punctual extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_lights_punctual\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_lights_punctual/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_lights implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /** hidden */\r\n    private _loader: GLTFLoader;\r\n    private _lights?: IKHRLightsPunctual_Light[];\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n        delete this._lights;\r\n    }\r\n\r\n    /** @internal */\r\n    public onLoading(): void {\r\n        const extensions = this._loader.gltf.extensions;\r\n        if (extensions && extensions[this.name]) {\r\n            const extension = extensions[this.name];\r\n            this._lights = extension.lights;\r\n            ArrayItem.Assign(this._lights);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadNodeAsync(context: string, node: INode, assign: (babylonTransformNode: TransformNode) => void): Nullable<Promise<TransformNode>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRLightsPunctual_LightReference, TransformNode>(context, node, this.name, async (extensionContext, extension) => {\r\n            this._loader._allMaterialsDirtyRequired = true;\r\n\r\n            return await this._loader.loadNodeAsync(context, node, (babylonMesh) => {\r\n                let babylonLight: Light;\r\n\r\n                const light = ArrayItem.Get(extensionContext, this._lights, extension.light);\r\n                const name = light.name || babylonMesh.name;\r\n\r\n                this._loader.babylonScene._blockEntityCollection = !!this._loader._assetContainer;\r\n\r\n                switch (light.type) {\r\n                    case KHRLightsPunctual_LightType.DIRECTIONAL: {\r\n                        const babylonDirectionalLight = new DirectionalLight(name, Vector3.Backward(), this._loader.babylonScene);\r\n                        babylonDirectionalLight.position.setAll(0);\r\n                        babylonLight = babylonDirectionalLight;\r\n                        break;\r\n                    }\r\n                    case KHRLightsPunctual_LightType.POINT: {\r\n                        babylonLight = new PointLight(name, Vector3.Zero(), this._loader.babylonScene);\r\n                        break;\r\n                    }\r\n                    case KHRLightsPunctual_LightType.SPOT: {\r\n                        const babylonSpotLight = new SpotLight(name, Vector3.Zero(), Vector3.Backward(), 0, 1, this._loader.babylonScene);\r\n                        babylonSpotLight.angle = ((light.spot && light.spot.outerConeAngle) || Math.PI / 4) * 2;\r\n                        babylonSpotLight.innerAngle = ((light.spot && light.spot.innerConeAngle) || 0) * 2;\r\n                        babylonLight = babylonSpotLight;\r\n                        break;\r\n                    }\r\n                    default: {\r\n                        this._loader.babylonScene._blockEntityCollection = false;\r\n                        throw new Error(`${extensionContext}: Invalid light type (${light.type})`);\r\n                    }\r\n                }\r\n\r\n                babylonLight._parentContainer = this._loader._assetContainer;\r\n                this._loader.babylonScene._blockEntityCollection = false;\r\n                light._babylonLight = babylonLight;\r\n\r\n                babylonLight.falloffType = Light.FALLOFF_GLTF;\r\n                babylonLight.diffuse = light.color ? Color3.FromArray(light.color) : Color3.White();\r\n                babylonLight.intensity = light.intensity == undefined ? 1 : light.intensity;\r\n                babylonLight.range = light.range == undefined ? Number.MAX_VALUE : light.range;\r\n                babylonLight.parent = babylonMesh;\r\n\r\n                this._loader._babylonLights.push(babylonLight);\r\n\r\n                GLTFLoader.AddPointerMetadata(babylonLight, extensionContext);\r\n\r\n                assign(babylonMesh);\r\n            });\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_lights(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport { Color3 } from \"core/Maths/math.color\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\n\r\nimport type { IMaterial } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IKHRMaterialsPbrSpecularGlossiness } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_materials_pbrSpecularGlossiness\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_pbrSpecularGlossiness extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_pbrSpecularGlossiness\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Archived/KHR_materials_pbrSpecularGlossiness/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_pbrSpecularGlossiness implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 200;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsPbrSpecularGlossiness>(context, material, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(this._loader.loadMaterialBasePropertiesAsync(context, material, babylonMaterial));\r\n            promises.push(this._loadSpecularGlossinessPropertiesAsync(extensionContext, extension, babylonMaterial));\r\n            this._loader.loadMaterialAlphaProperties(context, material, babylonMaterial);\r\n            // eslint-disable-next-line github/no-then\r\n            return await Promise.all(promises).then(() => {});\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadSpecularGlossinessPropertiesAsync(context: string, properties: IKHRMaterialsPbrSpecularGlossiness, babylonMaterial: Material): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        const promises = new Array<Promise<any>>();\r\n\r\n        babylonMaterial.metallic = null;\r\n        babylonMaterial.roughness = null;\r\n\r\n        if (properties.diffuseFactor) {\r\n            babylonMaterial.albedoColor = Color3.FromArray(properties.diffuseFactor);\r\n            babylonMaterial.alpha = properties.diffuseFactor[3];\r\n        } else {\r\n            babylonMaterial.albedoColor = Color3.White();\r\n        }\r\n\r\n        babylonMaterial.reflectivityColor = properties.specularFactor ? Color3.FromArray(properties.specularFactor) : Color3.White();\r\n        babylonMaterial.microSurface = properties.glossinessFactor == undefined ? 1 : properties.glossinessFactor;\r\n\r\n        if (properties.diffuseTexture) {\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/diffuseTexture`, properties.diffuseTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Diffuse)`;\r\n                    babylonMaterial.albedoTexture = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        if (properties.specularGlossinessTexture) {\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/specularGlossinessTexture`, properties.specularGlossinessTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Specular Glossiness)`;\r\n                    babylonMaterial.reflectivityTexture = texture;\r\n                    babylonMaterial.reflectivityTexture.hasAlpha = true;\r\n                })\r\n            );\r\n\r\n            babylonMaterial.useMicroSurfaceFromReflectivityMapAlpha = true;\r\n        }\r\n\r\n        // eslint-disable-next-line github/no-then\r\n        return Promise.all(promises).then(() => {});\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_pbrSpecularGlossiness(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport { Color3 } from \"core/Maths/math.color\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\n\r\nimport type { IMaterial } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_materials_unlit\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_unlit extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_unlit\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_unlit/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_unlit implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 210;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync(context, material, this.name, async () => {\r\n            return await this._loadUnlitPropertiesAsync(context, material, babylonMaterial);\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadUnlitPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        const promises = new Array<Promise<any>>();\r\n        babylonMaterial.unlit = true;\r\n\r\n        const properties = material.pbrMetallicRoughness;\r\n        if (properties) {\r\n            if (properties.baseColorFactor) {\r\n                babylonMaterial.albedoColor = Color3.FromArray(properties.baseColorFactor);\r\n                babylonMaterial.alpha = properties.baseColorFactor[3];\r\n            } else {\r\n                babylonMaterial.albedoColor = Color3.White();\r\n            }\r\n\r\n            if (properties.baseColorTexture) {\r\n                promises.push(\r\n                    this._loader.loadTextureInfoAsync(`${context}/baseColorTexture`, properties.baseColorTexture, (texture) => {\r\n                        texture.name = `${babylonMaterial.name} (Base Color)`;\r\n                        babylonMaterial.albedoTexture = texture;\r\n                    })\r\n                );\r\n            }\r\n        }\r\n\r\n        if (material.doubleSided) {\r\n            babylonMaterial.backFaceCulling = false;\r\n            babylonMaterial.twoSidedLighting = true;\r\n        }\r\n\r\n        this._loader.loadMaterialAlphaProperties(context, material, babylonMaterial);\r\n\r\n        // eslint-disable-next-line github/no-then\r\n        return Promise.all(promises).then(() => {});\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_unlit(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\n\r\nimport type { IMaterial, ITextureInfo } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IKHRMaterialsClearcoat } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_materials_clearcoat\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_clearcoat extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_clearcoat\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_clearcoat/README.md)\r\n * [Playground Sample](https://www.babylonjs-playground.com/frame.html#7F7PN6#8)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_clearcoat implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 190;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsClearcoat>(context, material, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));\r\n            promises.push(this._loadClearCoatPropertiesAsync(extensionContext, extension, babylonMaterial));\r\n            await Promise.all(promises);\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadClearCoatPropertiesAsync(context: string, properties: IKHRMaterialsClearcoat, babylonMaterial: Material): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        const promises = new Array<Promise<any>>();\r\n\r\n        babylonMaterial.clearCoat.isEnabled = true;\r\n        babylonMaterial.clearCoat.useRoughnessFromMainTexture = false;\r\n        babylonMaterial.clearCoat.remapF0OnInterfaceChange = false;\r\n\r\n        if (properties.clearcoatFactor != undefined) {\r\n            babylonMaterial.clearCoat.intensity = properties.clearcoatFactor;\r\n        } else {\r\n            babylonMaterial.clearCoat.intensity = 0;\r\n        }\r\n\r\n        if (properties.clearcoatTexture) {\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/clearcoatTexture`, properties.clearcoatTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (ClearCoat)`;\r\n                    babylonMaterial.clearCoat.texture = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        if (properties.clearcoatRoughnessFactor != undefined) {\r\n            babylonMaterial.clearCoat.roughness = properties.clearcoatRoughnessFactor;\r\n        } else {\r\n            babylonMaterial.clearCoat.roughness = 0;\r\n        }\r\n\r\n        if (properties.clearcoatRoughnessTexture) {\r\n            (properties.clearcoatRoughnessTexture as ITextureInfo).nonColorData = true;\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/clearcoatRoughnessTexture`, properties.clearcoatRoughnessTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (ClearCoat Roughness)`;\r\n                    babylonMaterial.clearCoat.textureRoughness = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        if (properties.clearcoatNormalTexture) {\r\n            (properties.clearcoatNormalTexture as ITextureInfo).nonColorData = true;\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/clearcoatNormalTexture`, properties.clearcoatNormalTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (ClearCoat Normal)`;\r\n                    babylonMaterial.clearCoat.bumpTexture = texture;\r\n                })\r\n            );\r\n\r\n            babylonMaterial.invertNormalMapX = !babylonMaterial.getScene().useRightHandedSystem;\r\n            babylonMaterial.invertNormalMapY = babylonMaterial.getScene().useRightHandedSystem;\r\n            if (properties.clearcoatNormalTexture.scale != undefined) {\r\n                babylonMaterial.clearCoat.bumpTexture!.level = properties.clearcoatNormalTexture.scale;\r\n            }\r\n        }\r\n\r\n        // eslint-disable-next-line github/no-then\r\n        return Promise.all(promises).then(() => {});\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_clearcoat(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\n\r\nimport type { IMaterial } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IKHRMaterialsIridescence } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_materials_iridescence\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_iridescence extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_iridescence\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_iridescence/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_iridescence implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 195;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsIridescence>(context, material, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));\r\n            promises.push(this._loadIridescencePropertiesAsync(extensionContext, extension, babylonMaterial));\r\n            // eslint-disable-next-line github/no-then\r\n            return await Promise.all(promises).then(() => {});\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadIridescencePropertiesAsync(context: string, properties: IKHRMaterialsIridescence, babylonMaterial: Material): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        const promises = new Array<Promise<any>>();\r\n\r\n        babylonMaterial.iridescence.isEnabled = true;\r\n\r\n        babylonMaterial.iridescence.intensity = properties.iridescenceFactor ?? 0;\r\n        babylonMaterial.iridescence.indexOfRefraction = properties.iridescenceIor ?? (properties as any).iridescenceIOR ?? 1.3;\r\n        babylonMaterial.iridescence.minimumThickness = properties.iridescenceThicknessMinimum ?? 100;\r\n        babylonMaterial.iridescence.maximumThickness = properties.iridescenceThicknessMaximum ?? 400;\r\n\r\n        if (properties.iridescenceTexture) {\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/iridescenceTexture`, properties.iridescenceTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Iridescence)`;\r\n                    babylonMaterial.iridescence.texture = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        if (properties.iridescenceThicknessTexture) {\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/iridescenceThicknessTexture`, properties.iridescenceThicknessTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Iridescence Thickness)`;\r\n                    babylonMaterial.iridescence.thicknessTexture = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        // eslint-disable-next-line github/no-then\r\n        return Promise.all(promises).then(() => {});\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_iridescence(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\n\r\nimport type { IMaterial, ITextureInfo } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IKHRMaterialsAnisotropy } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_materials_anisotropy\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_anisotropy extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_anisotropy\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_anisotropy)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_anisotropy implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 195;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsAnisotropy>(context, material, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));\r\n            promises.push(this._loadIridescencePropertiesAsync(extensionContext, extension, babylonMaterial));\r\n            await Promise.all(promises);\r\n        });\r\n    }\r\n\r\n    private async _loadIridescencePropertiesAsync(context: string, properties: IKHRMaterialsAnisotropy, babylonMaterial: Material): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        const promises = new Array<Promise<any>>();\r\n\r\n        babylonMaterial.anisotropy.isEnabled = true;\r\n\r\n        babylonMaterial.anisotropy.intensity = properties.anisotropyStrength ?? 0;\r\n        babylonMaterial.anisotropy.angle = properties.anisotropyRotation ?? 0;\r\n\r\n        if (properties.anisotropyTexture) {\r\n            (properties.anisotropyTexture as ITextureInfo).nonColorData = true;\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/anisotropyTexture`, properties.anisotropyTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Anisotropy Intensity)`;\r\n                    babylonMaterial.anisotropy.texture = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        await Promise.all(promises);\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_anisotropy(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\n\r\nimport type { IMaterial } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IKHRMaterialsEmissiveStrength } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_materials_emissive_strength\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_emissive_strength extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_emissive_strength\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_emissive_strength/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_emissive_strength implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 170;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsEmissiveStrength>(context, material, this.name, async (extensionContext, extension) => {\r\n            // eslint-disable-next-line github/no-then\r\n            return await this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial).then(() => {\r\n                this._loadEmissiveProperties(extensionContext, extension, babylonMaterial);\r\n            });\r\n        });\r\n    }\r\n\r\n    private _loadEmissiveProperties(context: string, properties: IKHRMaterialsEmissiveStrength, babylonMaterial: Material): void {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        if (properties.emissiveStrength !== undefined) {\r\n            babylonMaterial.emissiveIntensity = properties.emissiveStrength;\r\n        }\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_emissive_strength(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\n\r\nimport type { IMaterial, ITextureInfo } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport { Color3 } from \"core/Maths/math.color\";\r\nimport type { IKHRMaterialsSheen } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_materials_sheen\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_sheen extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_sheen\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_sheen/README.md)\r\n * [Playground Sample](https://www.babylonjs-playground.com/frame.html#BNIZX6#4)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_sheen implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 190;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsSheen>(context, material, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));\r\n            promises.push(this._loadSheenPropertiesAsync(extensionContext, extension, babylonMaterial));\r\n            // eslint-disable-next-line github/no-then\r\n            return await Promise.all(promises).then(() => {});\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadSheenPropertiesAsync(context: string, properties: IKHRMaterialsSheen, babylonMaterial: Material): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        const promises = new Array<Promise<any>>();\r\n\r\n        babylonMaterial.sheen.isEnabled = true;\r\n        babylonMaterial.sheen.intensity = 1;\r\n\r\n        if (properties.sheenColorFactor != undefined) {\r\n            babylonMaterial.sheen.color = Color3.FromArray(properties.sheenColorFactor);\r\n        } else {\r\n            babylonMaterial.sheen.color = Color3.Black();\r\n        }\r\n\r\n        if (properties.sheenColorTexture) {\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/sheenColorTexture`, properties.sheenColorTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Sheen Color)`;\r\n                    babylonMaterial.sheen.texture = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        if (properties.sheenRoughnessFactor !== undefined) {\r\n            babylonMaterial.sheen.roughness = properties.sheenRoughnessFactor;\r\n        } else {\r\n            babylonMaterial.sheen.roughness = 0;\r\n        }\r\n\r\n        if (properties.sheenRoughnessTexture) {\r\n            (properties.sheenRoughnessTexture as ITextureInfo).nonColorData = true;\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/sheenRoughnessTexture`, properties.sheenRoughnessTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Sheen Roughness)`;\r\n                    babylonMaterial.sheen.textureRoughness = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        babylonMaterial.sheen.albedoScaling = true;\r\n        babylonMaterial.sheen.useRoughnessFromMainTexture = false;\r\n\r\n        // eslint-disable-next-line github/no-then\r\n        return Promise.all(promises).then(() => {});\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_sheen(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\n\r\nimport type { IMaterial, ITextureInfo } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport { Color3 } from \"core/Maths/math.color\";\r\nimport { Constants } from \"core/Engines/constants\";\r\nimport type { IEXTMaterialsSpecularEdgeColor, IKHRMaterialsSpecular } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_materials_specular\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_specular extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_specular\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_specular/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_specular implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 190;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsSpecular>(context, material, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));\r\n            promises.push(this._loadSpecularPropertiesAsync(extensionContext, extension, babylonMaterial));\r\n            // Handle the EXT_materials_specular_edge_color sub-extension\r\n            // https://github.com/KhronosGroup/glTF/blob/2a1111b88f052cbd3e2d82abb9faee56e7494904/extensions/2.0/Vendor/EXT_materials_specular_edge_color/README.md\r\n            if (extension.extensions && extension.extensions.EXT_materials_specular_edge_color && babylonMaterial instanceof PBRMaterial) {\r\n                const specularEdgeColorExtension = extension.extensions.EXT_materials_specular_edge_color as IEXTMaterialsSpecularEdgeColor;\r\n                if (specularEdgeColorExtension.specularEdgeColorEnabled) {\r\n                    babylonMaterial.brdf.dielectricSpecularModel = Constants.MATERIAL_DIELECTRIC_SPECULAR_MODEL_OPENPBR;\r\n                    babylonMaterial.brdf.conductorSpecularModel = Constants.MATERIAL_CONDUCTOR_SPECULAR_MODEL_OPENPBR;\r\n                }\r\n            }\r\n            // eslint-disable-next-line github/no-then\r\n            return await Promise.all(promises).then(() => {});\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadSpecularPropertiesAsync(context: string, properties: IKHRMaterialsSpecular, babylonMaterial: Material): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        const promises = new Array<Promise<any>>();\r\n\r\n        if (properties.specularFactor !== undefined) {\r\n            babylonMaterial.metallicF0Factor = properties.specularFactor;\r\n        }\r\n\r\n        if (properties.specularColorFactor !== undefined) {\r\n            babylonMaterial.metallicReflectanceColor = Color3.FromArray(properties.specularColorFactor);\r\n        }\r\n\r\n        if (properties.specularTexture) {\r\n            (properties.specularTexture as ITextureInfo).nonColorData = true;\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/specularTexture`, properties.specularTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Specular)`;\r\n                    babylonMaterial.metallicReflectanceTexture = texture;\r\n                    babylonMaterial.useOnlyMetallicFromMetallicReflectanceTexture = true;\r\n                })\r\n            );\r\n        }\r\n\r\n        if (properties.specularColorTexture) {\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/specularColorTexture`, properties.specularColorTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Specular Color)`;\r\n                    babylonMaterial.reflectanceTexture = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        // eslint-disable-next-line github/no-then\r\n        return Promise.all(promises).then(() => {});\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_specular(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\n\r\nimport type { IMaterial } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IKHRMaterialsIor } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_materials_ior\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_ior extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_ior\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_ior/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_ior implements IGLTFLoaderExtension {\r\n    /**\r\n     * Default ior Value from the spec.\r\n     */\r\n    private static readonly _DEFAULT_IOR = 1.5;\r\n\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 180;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsIor>(context, material, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));\r\n            promises.push(this._loadIorPropertiesAsync(extensionContext, extension, babylonMaterial));\r\n            // eslint-disable-next-line github/no-then\r\n            return await Promise.all(promises).then(() => {});\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadIorPropertiesAsync(context: string, properties: IKHRMaterialsIor, babylonMaterial: Material): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        if (properties.ior !== undefined) {\r\n            babylonMaterial.indexOfRefraction = properties.ior;\r\n        } else {\r\n            babylonMaterial.indexOfRefraction = KHR_materials_ior._DEFAULT_IOR;\r\n        }\r\n\r\n        return Promise.resolve();\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_ior(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader, ArrayItem } from \"../glTFLoader\";\r\n\r\nimport type { Material } from \"core/Materials/material\";\r\nimport { Mesh } from \"core/Meshes/mesh\";\r\nimport type { Node } from \"core/node\";\r\nimport type { AbstractMesh } from \"core/Meshes/abstractMesh\";\r\nimport type { INode, IMeshPrimitive, IMesh } from \"../glTFLoaderInterfaces\";\r\nimport type { IKHRMaterialVariants_Mapping, IKHRMaterialVariants_Variant, IKHRMaterialVariants_Variants } from \"babylonjs-gltf2interface\";\r\nimport type { TransformNode } from \"core/Meshes/transformNode\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\nimport type { MaterialVariantsController } from \"../../glTFFileLoader\";\r\n\r\nconst NAME = \"KHR_materials_variants\";\r\n\r\nexport { MaterialVariantsController };\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // Define options related types here so they can be referenced in the options,\r\n    // but export the types at the module level. This ensures the types are in the\r\n    // correct namespace for UMD.\r\n    type MaterialVariantsController = {\r\n        /**\r\n         * The list of available variant names for this asset.\r\n         */\r\n        readonly variants: readonly string[];\r\n\r\n        /**\r\n         * Gets or sets the selected variant.\r\n         */\r\n        selectedVariant: string;\r\n    };\r\n\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_variants extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_variants\"]: Partial<{\r\n            /**\r\n             * Specifies the name of the variant that should be selected by default.\r\n             */\r\n            defaultVariant: string;\r\n\r\n            /**\r\n             * Defines a callback that will be called if material variants are loaded.\r\n             * @experimental\r\n             */\r\n            onLoaded: (controller: MaterialVariantsController) => void;\r\n        }>;\r\n    }\r\n}\r\n\r\ninterface IVariantsMap {\r\n    [key: string]: Array<{ mesh: AbstractMesh; material: Nullable<Material> }>;\r\n}\r\n\r\ninterface IExtensionMetadata {\r\n    lastSelected: Nullable<string | Array<string>>;\r\n    original: Array<{ mesh: AbstractMesh; material: Nullable<Material> }>;\r\n    variants: IVariantsMap;\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_variants/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_variants implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    private _variants?: Array<IKHRMaterialVariants_Variant>;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME) && !this._loader.parent.skipMaterials;\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * Gets the list of available variant names for this asset.\r\n     * @param rootNode The glTF root node\r\n     * @returns the list of all the variant names for this model\r\n     */\r\n    public static GetAvailableVariants(rootNode: TransformNode): string[] {\r\n        const extensionMetadata = this._GetExtensionMetadata(rootNode);\r\n        if (!extensionMetadata) {\r\n            return [];\r\n        }\r\n\r\n        return Object.keys(extensionMetadata.variants);\r\n    }\r\n\r\n    /**\r\n     * Gets the list of available variant names for this asset.\r\n     * @param rootNode The glTF root node\r\n     * @returns the list of all the variant names for this model\r\n     */\r\n    public getAvailableVariants(rootNode: TransformNode): string[] {\r\n        return KHR_materials_variants.GetAvailableVariants(rootNode);\r\n    }\r\n\r\n    /**\r\n     * Select a variant given a variant name or a list of variant names.\r\n     * @param rootNode The glTF root node\r\n     * @param variantName The variant name(s) to select.\r\n     */\r\n    public static SelectVariant(rootNode: TransformNode, variantName: string | string[]): void {\r\n        const extensionMetadata = this._GetExtensionMetadata(rootNode);\r\n        if (!extensionMetadata) {\r\n            throw new Error(`Cannot select variant on a glTF mesh that does not have the ${NAME} extension`);\r\n        }\r\n\r\n        const select = (variantName: string): void => {\r\n            const entries = extensionMetadata.variants[variantName];\r\n            if (entries) {\r\n                for (const entry of entries) {\r\n                    entry.mesh.material = entry.material;\r\n                }\r\n            }\r\n        };\r\n\r\n        if (variantName instanceof Array) {\r\n            for (const name of variantName) {\r\n                select(name);\r\n            }\r\n        } else {\r\n            select(variantName);\r\n        }\r\n\r\n        extensionMetadata.lastSelected = variantName;\r\n    }\r\n\r\n    /**\r\n     * Select a variant given a variant name or a list of variant names.\r\n     * @param rootNode The glTF root node\r\n     * @param variantName The variant name(s) to select.\r\n     */\r\n    public selectVariant(rootNode: TransformNode, variantName: string | string[]): void {\r\n        KHR_materials_variants.SelectVariant(rootNode, variantName);\r\n    }\r\n\r\n    /**\r\n     * Reset back to the original before selecting a variant.\r\n     * @param rootNode The glTF root node\r\n     */\r\n    public static Reset(rootNode: TransformNode): void {\r\n        const extensionMetadata = this._GetExtensionMetadata(rootNode);\r\n        if (!extensionMetadata) {\r\n            throw new Error(`Cannot reset on a glTF mesh that does not have the ${NAME} extension`);\r\n        }\r\n\r\n        for (const entry of extensionMetadata.original) {\r\n            entry.mesh.material = entry.material;\r\n        }\r\n\r\n        extensionMetadata.lastSelected = null;\r\n    }\r\n\r\n    /**\r\n     * Reset back to the original before selecting a variant.\r\n     * @param rootNode The glTF root node\r\n     */\r\n    public reset(rootNode: TransformNode): void {\r\n        KHR_materials_variants.Reset(rootNode);\r\n    }\r\n\r\n    /**\r\n     * Gets the last selected variant name(s) or null if original.\r\n     * @param rootNode The glTF root node\r\n     * @returns The selected variant name(s).\r\n     */\r\n    public static GetLastSelectedVariant(rootNode: TransformNode): Nullable<string | string[]> {\r\n        const extensionMetadata = this._GetExtensionMetadata(rootNode);\r\n        if (!extensionMetadata) {\r\n            throw new Error(`Cannot get the last selected variant on a glTF mesh that does not have the ${NAME} extension`);\r\n        }\r\n\r\n        return extensionMetadata.lastSelected;\r\n    }\r\n\r\n    /**\r\n     * Gets the last selected variant name(s) or null if original.\r\n     * @param rootNode The glTF root node\r\n     * @returns The selected variant name(s).\r\n     */\r\n    public getLastSelectedVariant(rootNode: TransformNode): Nullable<string | string[]> {\r\n        return KHR_materials_variants.GetLastSelectedVariant(rootNode);\r\n    }\r\n\r\n    private static _GetExtensionMetadata(rootNode: Nullable<TransformNode>): Nullable<IExtensionMetadata> {\r\n        return rootNode?._internalMetadata?.gltf?.[NAME] || null;\r\n    }\r\n\r\n    /** @internal */\r\n    public onLoading(): void {\r\n        const extensions = this._loader.gltf.extensions;\r\n        if (extensions && extensions[this.name]) {\r\n            const extension = extensions[this.name] as IKHRMaterialVariants_Variants;\r\n            this._variants = extension.variants;\r\n        }\r\n    }\r\n\r\n    /** @internal */\r\n    public onReady(): void {\r\n        const rootNode = this._loader.rootBabylonMesh;\r\n        if (rootNode) {\r\n            const options = this._loader.parent.extensionOptions[NAME];\r\n            if (options?.defaultVariant) {\r\n                KHR_materials_variants.SelectVariant(rootNode, options.defaultVariant);\r\n            }\r\n\r\n            options?.onLoaded?.({\r\n                get variants() {\r\n                    return KHR_materials_variants.GetAvailableVariants(rootNode);\r\n                },\r\n                get selectedVariant(): string {\r\n                    const lastSelectedVariant = KHR_materials_variants.GetLastSelectedVariant(rootNode);\r\n                    if (!lastSelectedVariant) {\r\n                        return KHR_materials_variants.GetAvailableVariants(rootNode)[0];\r\n                    }\r\n                    if (Array.isArray(lastSelectedVariant)) {\r\n                        return lastSelectedVariant[0];\r\n                    }\r\n                    return lastSelectedVariant;\r\n                },\r\n                set selectedVariant(variantName) {\r\n                    KHR_materials_variants.SelectVariant(rootNode, variantName);\r\n                },\r\n            });\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public _loadMeshPrimitiveAsync(\r\n        context: string,\r\n        name: string,\r\n        node: INode,\r\n        mesh: IMesh,\r\n        primitive: IMeshPrimitive,\r\n        assign: (babylonMesh: AbstractMesh) => void\r\n    ): Nullable<Promise<AbstractMesh>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialVariants_Mapping, AbstractMesh>(context, primitive, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(\r\n                this._loader._loadMeshPrimitiveAsync(context, name, node, mesh, primitive, (babylonMesh) => {\r\n                    assign(babylonMesh);\r\n\r\n                    if (babylonMesh instanceof Mesh) {\r\n                        const babylonDrawMode = GLTFLoader._GetDrawMode(context, primitive.mode);\r\n\r\n                        const root = this._loader.rootBabylonMesh;\r\n                        const metadata = root ? (root._internalMetadata = root._internalMetadata || {}) : {};\r\n                        const gltf = (metadata.gltf = metadata.gltf || {});\r\n                        const extensionMetadata: IExtensionMetadata = (gltf[NAME] = gltf[NAME] || { lastSelected: null, original: [], variants: {} });\r\n\r\n                        // Store the original material.\r\n                        extensionMetadata.original.push({ mesh: babylonMesh, material: babylonMesh.material });\r\n\r\n                        // For each mapping, look at the variants and make a new entry for them.\r\n                        for (let mappingIndex = 0; mappingIndex < extension.mappings.length; ++mappingIndex) {\r\n                            const mapping = extension.mappings[mappingIndex];\r\n                            const material = ArrayItem.Get(`${extensionContext}/mappings/${mappingIndex}/material`, this._loader.gltf.materials, mapping.material);\r\n                            promises.push(\r\n                                this._loader._loadMaterialAsync(`#/materials/${mapping.material}`, material, babylonMesh, babylonDrawMode, (babylonMaterial) => {\r\n                                    for (let mappingVariantIndex = 0; mappingVariantIndex < mapping.variants.length; ++mappingVariantIndex) {\r\n                                        const variantIndex = mapping.variants[mappingVariantIndex];\r\n                                        const variant = ArrayItem.Get(`/extensions/${NAME}/variants/${variantIndex}`, this._variants, variantIndex);\r\n                                        extensionMetadata.variants[variant.name] = extensionMetadata.variants[variant.name] || [];\r\n                                        extensionMetadata.variants[variant.name].push({\r\n                                            mesh: babylonMesh,\r\n                                            material: babylonMaterial,\r\n                                        });\r\n\r\n                                        // Replace the target when original mesh is cloned\r\n                                        babylonMesh.onClonedObservable.add((newOne: Node) => {\r\n                                            const newMesh = newOne as Mesh;\r\n                                            let metadata: Nullable<IExtensionMetadata> = null;\r\n                                            let newRoot: Nullable<Node> = newMesh;\r\n\r\n                                            // Find root to get medata\r\n                                            do {\r\n                                                newRoot = newRoot.parent;\r\n                                                if (!newRoot) {\r\n                                                    return;\r\n                                                }\r\n                                                metadata = KHR_materials_variants._GetExtensionMetadata(newRoot as Mesh);\r\n                                            } while (metadata === null);\r\n\r\n                                            // Need to clone the metadata on the root (first time only)\r\n                                            if (root && metadata === KHR_materials_variants._GetExtensionMetadata(root)) {\r\n                                                // Copy main metadata\r\n                                                newRoot._internalMetadata = {};\r\n                                                for (const key in root._internalMetadata) {\r\n                                                    newRoot._internalMetadata[key] = root._internalMetadata[key];\r\n                                                }\r\n\r\n                                                // Copy the gltf metadata\r\n                                                newRoot._internalMetadata.gltf = [];\r\n                                                for (const key in root._internalMetadata.gltf) {\r\n                                                    newRoot._internalMetadata.gltf[key] = root._internalMetadata.gltf[key];\r\n                                                }\r\n\r\n                                                // Duplicate the extension specific metadata\r\n                                                newRoot._internalMetadata.gltf[NAME] = { lastSelected: null, original: [], variants: {} };\r\n                                                for (const original of metadata.original) {\r\n                                                    newRoot._internalMetadata.gltf[NAME].original.push({\r\n                                                        mesh: original.mesh,\r\n                                                        material: original.material,\r\n                                                    });\r\n                                                }\r\n                                                for (const key in metadata.variants) {\r\n                                                    if (Object.prototype.hasOwnProperty.call(metadata.variants, key)) {\r\n                                                        newRoot._internalMetadata.gltf[NAME].variants[key] = [];\r\n                                                        for (const variantEntry of metadata.variants[key]) {\r\n                                                            newRoot._internalMetadata.gltf[NAME].variants[key].push({\r\n                                                                mesh: variantEntry.mesh,\r\n                                                                material: variantEntry.material,\r\n                                                            });\r\n                                                        }\r\n                                                    }\r\n                                                }\r\n\r\n                                                metadata = newRoot._internalMetadata.gltf[NAME];\r\n                                            }\r\n\r\n                                            // Relocate\r\n                                            for (const target of metadata!.original) {\r\n                                                if (target.mesh === babylonMesh) {\r\n                                                    target.mesh = newMesh;\r\n                                                }\r\n                                            }\r\n                                            for (const target of metadata!.variants[variant.name]) {\r\n                                                if (target.mesh === babylonMesh) {\r\n                                                    target.mesh = newMesh;\r\n                                                }\r\n                                            }\r\n                                        });\r\n                                    }\r\n                                })\r\n                            );\r\n                        }\r\n                    }\r\n                })\r\n            );\r\n            // eslint-disable-next-line github/no-then\r\n            return await Promise.all(promises).then(([babylonMesh]) => {\r\n                return babylonMesh;\r\n            });\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_variants(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\r\nimport type { IMaterial, ITextureInfo } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IKHRMaterialsTransmission } from \"babylonjs-gltf2interface\";\r\nimport type { Scene } from \"core/scene\";\r\nimport type { AbstractMesh } from \"core/Meshes/abstractMesh\";\r\nimport type { Texture } from \"core/Materials/Textures/texture\";\r\nimport { RenderTargetTexture } from \"core/Materials/Textures/renderTargetTexture\";\r\nimport type { Observer } from \"core/Misc/observable\";\r\nimport { Observable } from \"core/Misc/observable\";\r\nimport { Constants } from \"core/Engines/constants\";\r\nimport { Tools } from \"core/Misc/tools\";\r\nimport type { Color4 } from \"core/Maths/math.color\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\ninterface ITransmissionHelperHolder {\r\n    /**\r\n     * @internal\r\n     */\r\n    _transmissionHelper: TransmissionHelper | undefined;\r\n}\r\n\r\ninterface ITransmissionHelperOptions {\r\n    /**\r\n     * The size of the render buffers (default: 1024)\r\n     */\r\n    renderSize: number;\r\n\r\n    /**\r\n     * The number of samples to use when generating the render target texture for opaque meshes (default: 4)\r\n     */\r\n    samples: number;\r\n\r\n    /**\r\n     * Scale to apply when selecting the LOD level to sample the refraction texture (default: 1)\r\n     */\r\n    lodGenerationScale: number;\r\n\r\n    /**\r\n     * Offset to apply when selecting the LOD level to sample the refraction texture (default: -4)\r\n     */\r\n    lodGenerationOffset: number;\r\n\r\n    /**\r\n     * Type of the refraction render target texture (default: TEXTURETYPE_HALF_FLOAT)\r\n     */\r\n    renderTargetTextureType: number;\r\n\r\n    /**\r\n     * Defines if the mipmaps for the refraction render target texture must be generated (default: true)\r\n     */\r\n    generateMipmaps: boolean;\r\n\r\n    /**\r\n     * Clear color of the opaque texture. If not provided, use the scene clear color (which will be converted to linear space).\r\n     * If provided, should be in linear space\r\n     */\r\n    clearColor?: Color4;\r\n}\r\n\r\n/**\r\n * A class to handle setting up the rendering of opaque objects to be shown through transmissive objects.\r\n */\r\nclass TransmissionHelper {\r\n    /**\r\n     * Creates the default options for the helper.\r\n     * @returns the default options\r\n     */\r\n    private static _GetDefaultOptions(): ITransmissionHelperOptions {\r\n        return {\r\n            renderSize: 1024,\r\n            samples: 4,\r\n            lodGenerationScale: 1,\r\n            lodGenerationOffset: -4,\r\n            renderTargetTextureType: Constants.TEXTURETYPE_HALF_FLOAT,\r\n            generateMipmaps: true,\r\n        };\r\n    }\r\n\r\n    /**\r\n     * Stores the creation options.\r\n     */\r\n    private readonly _scene: Scene & ITransmissionHelperHolder;\r\n\r\n    private _options: ITransmissionHelperOptions;\r\n\r\n    private _opaqueRenderTarget: Nullable<RenderTargetTexture> = null;\r\n    private _opaqueMeshesCache: AbstractMesh[] = [];\r\n    private _transparentMeshesCache: AbstractMesh[] = [];\r\n    private _materialObservers: { [id: string]: Nullable<Observer<AbstractMesh>> } = {};\r\n\r\n    /**\r\n     * This observable will be notified with any error during the creation of the environment,\r\n     * mainly texture creation errors.\r\n     */\r\n    public onErrorObservable: Observable<{ message?: string; exception?: any }>;\r\n\r\n    /**\r\n     * constructor\r\n     * @param options Defines the options we want to customize the helper\r\n     * @param scene The scene to add the material to\r\n     */\r\n    constructor(options: Partial<ITransmissionHelperOptions>, scene: Scene) {\r\n        this._options = {\r\n            ...TransmissionHelper._GetDefaultOptions(),\r\n            ...options,\r\n        };\r\n        this._scene = scene as any;\r\n        this._scene._transmissionHelper = this;\r\n\r\n        this.onErrorObservable = new Observable();\r\n        this._scene.onDisposeObservable.addOnce(() => {\r\n            this.dispose();\r\n        });\r\n\r\n        this._parseScene();\r\n        this._setupRenderTargets();\r\n    }\r\n\r\n    /**\r\n     * Updates the background according to the new options\r\n     * @param options\r\n     */\r\n    public updateOptions(options: Partial<ITransmissionHelperOptions>) {\r\n        // First check if any options are actually being changed. If not, exit.\r\n        const newValues = Object.keys(options).filter((key: string) => (this._options as any)[key] !== (options as any)[key]);\r\n        if (!newValues.length) {\r\n            return;\r\n        }\r\n\r\n        const newOptions = {\r\n            ...this._options,\r\n            ...options,\r\n        };\r\n\r\n        const oldOptions = this._options;\r\n        this._options = newOptions;\r\n\r\n        // If size changes, recreate everything\r\n        if (\r\n            newOptions.renderSize !== oldOptions.renderSize ||\r\n            newOptions.renderTargetTextureType !== oldOptions.renderTargetTextureType ||\r\n            newOptions.generateMipmaps !== oldOptions.generateMipmaps ||\r\n            !this._opaqueRenderTarget\r\n        ) {\r\n            this._setupRenderTargets();\r\n        } else {\r\n            this._opaqueRenderTarget.samples = newOptions.samples;\r\n            this._opaqueRenderTarget.lodGenerationScale = newOptions.lodGenerationScale;\r\n            this._opaqueRenderTarget.lodGenerationOffset = newOptions.lodGenerationOffset;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @returns the opaque render target texture or null if not available.\r\n     */\r\n    public getOpaqueTarget(): Nullable<Texture> {\r\n        return this._opaqueRenderTarget;\r\n    }\r\n\r\n    private _shouldRenderAsTransmission(material: Nullable<Material>): boolean {\r\n        if (!material) {\r\n            return false;\r\n        }\r\n        if (material instanceof PBRMaterial && material.subSurface.isRefractionEnabled) {\r\n            return true;\r\n        }\r\n        return false;\r\n    }\r\n\r\n    private _addMesh(mesh: AbstractMesh): void {\r\n        this._materialObservers[mesh.uniqueId] = mesh.onMaterialChangedObservable.add(this._onMeshMaterialChanged.bind(this));\r\n\r\n        // we need to defer the processing because _addMesh may be called as part as an instance mesh creation, in which case some\r\n        // internal properties are not setup yet, like _sourceMesh (needed when doing mesh.material below)\r\n        Tools.SetImmediate(() => {\r\n            if (this._shouldRenderAsTransmission(mesh.material)) {\r\n                (mesh.material as PBRMaterial).refractionTexture = this._opaqueRenderTarget;\r\n                if (this._transparentMeshesCache.indexOf(mesh) === -1) {\r\n                    this._transparentMeshesCache.push(mesh);\r\n                }\r\n            } else {\r\n                if (this._opaqueMeshesCache.indexOf(mesh) === -1) {\r\n                    this._opaqueMeshesCache.push(mesh);\r\n                }\r\n            }\r\n        });\r\n    }\r\n\r\n    private _removeMesh(mesh: AbstractMesh): void {\r\n        mesh.onMaterialChangedObservable.remove(this._materialObservers[mesh.uniqueId]);\r\n        delete this._materialObservers[mesh.uniqueId];\r\n        let idx = this._transparentMeshesCache.indexOf(mesh);\r\n        if (idx !== -1) {\r\n            this._transparentMeshesCache.splice(idx, 1);\r\n        }\r\n        idx = this._opaqueMeshesCache.indexOf(mesh);\r\n        if (idx !== -1) {\r\n            this._opaqueMeshesCache.splice(idx, 1);\r\n        }\r\n    }\r\n\r\n    private _parseScene(): void {\r\n        this._scene.meshes.forEach(this._addMesh.bind(this));\r\n        // Listen for when a mesh is added to the scene and add it to our cache lists.\r\n        this._scene.onNewMeshAddedObservable.add(this._addMesh.bind(this));\r\n        // Listen for when a mesh is removed from to the scene and remove it from our cache lists.\r\n        this._scene.onMeshRemovedObservable.add(this._removeMesh.bind(this));\r\n    }\r\n\r\n    // When one of the meshes in the scene has its material changed, make sure that it's in the correct cache list.\r\n    private _onMeshMaterialChanged(mesh: AbstractMesh) {\r\n        const transparentIdx = this._transparentMeshesCache.indexOf(mesh);\r\n        const opaqueIdx = this._opaqueMeshesCache.indexOf(mesh);\r\n\r\n        // If the material is transparent, make sure that it's added to the transparent list and removed from the opaque list\r\n        const useTransmission = this._shouldRenderAsTransmission(mesh.material);\r\n        if (useTransmission) {\r\n            if (mesh.material instanceof PBRMaterial) {\r\n                mesh.material.subSurface.refractionTexture = this._opaqueRenderTarget;\r\n            }\r\n            if (opaqueIdx !== -1) {\r\n                this._opaqueMeshesCache.splice(opaqueIdx, 1);\r\n                this._transparentMeshesCache.push(mesh);\r\n            } else if (transparentIdx === -1) {\r\n                this._transparentMeshesCache.push(mesh);\r\n            }\r\n            // If the material is opaque, make sure that it's added to the opaque list and removed from the transparent list\r\n        } else {\r\n            if (transparentIdx !== -1) {\r\n                this._transparentMeshesCache.splice(transparentIdx, 1);\r\n                this._opaqueMeshesCache.push(mesh);\r\n            } else if (opaqueIdx === -1) {\r\n                this._opaqueMeshesCache.push(mesh);\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     * Check if the opaque render target has not been disposed and can still be used.\r\n     * @returns\r\n     */\r\n    public _isRenderTargetValid() {\r\n        return this._opaqueRenderTarget?.getInternalTexture() !== null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     * Setup the render targets according to the specified options.\r\n     */\r\n    public _setupRenderTargets(): void {\r\n        if (this._opaqueRenderTarget) {\r\n            this._opaqueRenderTarget.dispose();\r\n        }\r\n        this._opaqueRenderTarget = new RenderTargetTexture(\r\n            \"opaqueSceneTexture\",\r\n            this._options.renderSize,\r\n            this._scene,\r\n            this._options.generateMipmaps,\r\n            undefined,\r\n            this._options.renderTargetTextureType\r\n        );\r\n        this._opaqueRenderTarget.ignoreCameraViewport = true;\r\n        this._opaqueRenderTarget.renderList = this._opaqueMeshesCache;\r\n        this._opaqueRenderTarget.clearColor = this._options.clearColor?.clone() ?? this._scene.clearColor.clone();\r\n        this._opaqueRenderTarget.gammaSpace = false;\r\n        this._opaqueRenderTarget.lodGenerationScale = this._options.lodGenerationScale;\r\n        this._opaqueRenderTarget.lodGenerationOffset = this._options.lodGenerationOffset;\r\n        this._opaqueRenderTarget.samples = this._options.samples;\r\n        this._opaqueRenderTarget.renderSprites = true;\r\n        this._opaqueRenderTarget.renderParticles = true;\r\n        this._opaqueRenderTarget.disableImageProcessing = true;\r\n\r\n        let saveSceneEnvIntensity: number;\r\n        this._opaqueRenderTarget.onBeforeBindObservable.add((opaqueRenderTarget) => {\r\n            saveSceneEnvIntensity = this._scene.environmentIntensity;\r\n            this._scene.environmentIntensity = 1.0;\r\n            if (!this._options.clearColor) {\r\n                this._scene.clearColor.toLinearSpaceToRef(opaqueRenderTarget.clearColor, this._scene.getEngine().useExactSrgbConversions);\r\n            } else {\r\n                opaqueRenderTarget.clearColor.copyFrom(this._options.clearColor);\r\n            }\r\n        });\r\n        this._opaqueRenderTarget.onAfterUnbindObservable.add(() => {\r\n            this._scene.environmentIntensity = saveSceneEnvIntensity;\r\n        });\r\n\r\n        for (const mesh of this._transparentMeshesCache) {\r\n            if (this._shouldRenderAsTransmission(mesh.material)) {\r\n                (mesh.material as PBRMaterial).refractionTexture = this._opaqueRenderTarget;\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Dispose all the elements created by the Helper.\r\n     */\r\n    public dispose(): void {\r\n        this._scene._transmissionHelper = undefined;\r\n        if (this._opaqueRenderTarget) {\r\n            this._opaqueRenderTarget.dispose();\r\n            this._opaqueRenderTarget = null;\r\n        }\r\n        this._transparentMeshesCache = [];\r\n        this._opaqueMeshesCache = [];\r\n    }\r\n}\r\n\r\nconst NAME = \"KHR_materials_transmission\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_transmission extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_transmission\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_transmission/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_transmission implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 175;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n        if (this.enabled) {\r\n            loader.parent.transparencyAsCoverage = true;\r\n        }\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsTransmission>(context, material, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));\r\n            promises.push(this._loadTransparentPropertiesAsync(extensionContext, material, babylonMaterial, extension));\r\n            // eslint-disable-next-line github/no-then\r\n            return await Promise.all(promises).then(() => {});\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax, @typescript-eslint/promise-function-async\r\n    private _loadTransparentPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material, extension: IKHRMaterialsTransmission): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n        const pbrMaterial = babylonMaterial;\r\n\r\n        // Enables \"refraction\" texture which represents transmitted light.\r\n        pbrMaterial.subSurface.isRefractionEnabled = true;\r\n\r\n        // Since this extension models thin-surface transmission only, we must make IOR = 1.0\r\n        pbrMaterial.subSurface.volumeIndexOfRefraction = 1.0;\r\n\r\n        // Albedo colour will tint transmission.\r\n        pbrMaterial.subSurface.useAlbedoToTintRefraction = true;\r\n\r\n        if (extension.transmissionFactor !== undefined) {\r\n            pbrMaterial.subSurface.refractionIntensity = extension.transmissionFactor;\r\n            const scene = pbrMaterial.getScene() as unknown as ITransmissionHelperHolder;\r\n            if (pbrMaterial.subSurface.refractionIntensity && !scene._transmissionHelper) {\r\n                new TransmissionHelper({}, pbrMaterial.getScene());\r\n            } else if (pbrMaterial.subSurface.refractionIntensity && !scene._transmissionHelper?._isRenderTargetValid()) {\r\n                // If the render target is not valid, recreate it.\r\n                scene._transmissionHelper?._setupRenderTargets();\r\n            }\r\n        } else {\r\n            pbrMaterial.subSurface.refractionIntensity = 0.0;\r\n            pbrMaterial.subSurface.isRefractionEnabled = false;\r\n            return Promise.resolve();\r\n        }\r\n\r\n        pbrMaterial.subSurface.minimumThickness = 0.0;\r\n        pbrMaterial.subSurface.maximumThickness = 0.0;\r\n        if (extension.transmissionTexture) {\r\n            (extension.transmissionTexture as ITextureInfo).nonColorData = true;\r\n            // eslint-disable-next-line github/no-then\r\n            return this._loader.loadTextureInfoAsync(`${context}/transmissionTexture`, extension.transmissionTexture, undefined).then((texture: BaseTexture) => {\r\n                texture.name = `${babylonMaterial.name} (Transmission)`;\r\n                pbrMaterial.subSurface.refractionIntensityTexture = texture;\r\n                pbrMaterial.subSurface.useGltfStyleTextures = true;\r\n            });\r\n        } else {\r\n            return Promise.resolve();\r\n        }\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_transmission(loader));\r\n","/* eslint-disable github/no-then */\r\nimport type { Nullable } from \"core/types\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\r\nimport type { IMaterial, ITextureInfo } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IKHRMaterialsDiffuseTransmission } from \"babylonjs-gltf2interface\";\r\nimport { Color3 } from \"core/Maths/math.color\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_materials_diffuse_transmission\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_diffuse_transmission extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_diffuse_transmission\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Proposed Specification](https://github.com/KhronosGroup/glTF/pull/1825)\r\n * !!! Experimental Extension Subject to Changes !!!\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_diffuse_transmission implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 174;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n        if (this.enabled) {\r\n            loader.parent.transparencyAsCoverage = true;\r\n        }\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsDiffuseTransmission>(context, material, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));\r\n            promises.push(this._loadTranslucentPropertiesAsync(extensionContext, material, babylonMaterial, extension));\r\n            return await Promise.all(promises).then(() => {});\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax, @typescript-eslint/promise-function-async\r\n    private _loadTranslucentPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material, extension: IKHRMaterialsDiffuseTransmission): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        const pbrMaterial = babylonMaterial;\r\n\r\n        // Enables \"translucency\" texture which represents diffusely-transmitted light.\r\n        pbrMaterial.subSurface.isTranslucencyEnabled = true;\r\n\r\n        // Since this extension models thin-surface transmission only, we must make the\r\n        // internal IOR == 1.0 and set the thickness to 0.\r\n        pbrMaterial.subSurface.volumeIndexOfRefraction = 1.0;\r\n        pbrMaterial.subSurface.minimumThickness = 0.0;\r\n        pbrMaterial.subSurface.maximumThickness = 0.0;\r\n\r\n        // Tint color will be used for transmission.\r\n        pbrMaterial.subSurface.useAlbedoToTintTranslucency = false;\r\n\r\n        if (extension.diffuseTransmissionFactor !== undefined) {\r\n            pbrMaterial.subSurface.translucencyIntensity = extension.diffuseTransmissionFactor;\r\n        } else {\r\n            pbrMaterial.subSurface.translucencyIntensity = 0.0;\r\n            pbrMaterial.subSurface.isTranslucencyEnabled = false;\r\n            return Promise.resolve();\r\n        }\r\n\r\n        const promises = new Array<Promise<any>>();\r\n\r\n        pbrMaterial.subSurface.useGltfStyleTextures = true;\r\n\r\n        if (extension.diffuseTransmissionTexture) {\r\n            (extension.diffuseTransmissionTexture as ITextureInfo).nonColorData = true;\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/diffuseTransmissionTexture`, extension.diffuseTransmissionTexture).then((texture: BaseTexture) => {\r\n                    texture.name = `${babylonMaterial.name} (Diffuse Transmission)`;\r\n                    pbrMaterial.subSurface.translucencyIntensityTexture = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        if (extension.diffuseTransmissionColorFactor !== undefined) {\r\n            pbrMaterial.subSurface.translucencyColor = Color3.FromArray(extension.diffuseTransmissionColorFactor);\r\n        } else {\r\n            pbrMaterial.subSurface.translucencyColor = Color3.White();\r\n        }\r\n\r\n        if (extension.diffuseTransmissionColorTexture) {\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/diffuseTransmissionColorTexture`, extension.diffuseTransmissionColorTexture).then((texture: BaseTexture) => {\r\n                    texture.name = `${babylonMaterial.name} (Diffuse Transmission Color)`;\r\n                    pbrMaterial.subSurface.translucencyColorTexture = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        return Promise.all(promises).then(() => {});\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_diffuse_transmission(loader));\r\n","/* eslint-disable @typescript-eslint/naming-convention */\r\nimport type { Nullable } from \"core/types\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\r\nimport type { IMaterial, ITextureInfo } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IKHRMaterialsVolume } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_materials_volume\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_volume extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_volume\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_volume/README.md)\r\n * @since 5.0.0\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_volume implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 173;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n        if (this.enabled) {\r\n            // We need to disable instance usage because the attenuation factor depends on the node scale of each individual mesh\r\n            this._loader._disableInstancedMesh++;\r\n        }\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        if (this.enabled) {\r\n            this._loader._disableInstancedMesh--;\r\n        }\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsVolume>(context, material, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));\r\n            promises.push(this._loadVolumePropertiesAsync(extensionContext, material, babylonMaterial, extension));\r\n            // eslint-disable-next-line github/no-then\r\n            return await Promise.all(promises).then(() => {});\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadVolumePropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material, extension: IKHRMaterialsVolume): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        // If transparency isn't enabled already, this extension shouldn't do anything.\r\n        // i.e. it requires either the KHR_materials_transmission or KHR_materials_diffuse_transmission extensions.\r\n        if ((!babylonMaterial.subSurface.isRefractionEnabled && !babylonMaterial.subSurface.isTranslucencyEnabled) || !extension.thicknessFactor) {\r\n            return Promise.resolve();\r\n        }\r\n\r\n        // IOR in this extension only affects interior.\r\n        babylonMaterial.subSurface.volumeIndexOfRefraction = babylonMaterial.indexOfRefraction;\r\n        const attenuationDistance = extension.attenuationDistance !== undefined ? extension.attenuationDistance : Number.MAX_VALUE;\r\n        babylonMaterial.subSurface.tintColorAtDistance = attenuationDistance;\r\n        if (extension.attenuationColor !== undefined && extension.attenuationColor.length == 3) {\r\n            babylonMaterial.subSurface.tintColor.copyFromFloats(extension.attenuationColor[0], extension.attenuationColor[1], extension.attenuationColor[2]);\r\n        }\r\n\r\n        babylonMaterial.subSurface.minimumThickness = 0.0;\r\n        babylonMaterial.subSurface.maximumThickness = extension.thicknessFactor;\r\n        babylonMaterial.subSurface.useThicknessAsDepth = true;\r\n        if (extension.thicknessTexture) {\r\n            (extension.thicknessTexture as ITextureInfo).nonColorData = true;\r\n            // eslint-disable-next-line github/no-then\r\n            return this._loader.loadTextureInfoAsync(`${context}/thicknessTexture`, extension.thicknessTexture).then((texture: BaseTexture) => {\r\n                texture.name = `${babylonMaterial.name} (Thickness)`;\r\n                babylonMaterial.subSurface.thicknessTexture = texture;\r\n                babylonMaterial.subSurface.useGltfStyleTextures = true;\r\n            });\r\n        } else {\r\n            return Promise.resolve();\r\n        }\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_volume(loader));\r\n","/* eslint-disable @typescript-eslint/naming-convention */\r\nimport type { Nullable } from \"core/types\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\nimport type { IMaterial } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IKHRMaterialsDispersion } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_materials_dispersion\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_materials_dispersion extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_materials_dispersion\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/87bd64a7f5e23c84b6aef2e6082069583ed0ddb4/extensions/2.0/Khronos/KHR_materials_dispersion/README.md)\r\n * @experimental\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_materials_dispersion implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 174;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRMaterialsDispersion>(context, material, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));\r\n            promises.push(this._loadDispersionPropertiesAsync(extensionContext, material, babylonMaterial, extension));\r\n            // eslint-disable-next-line github/no-then\r\n            return await Promise.all(promises).then(() => {});\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadDispersionPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material, extension: IKHRMaterialsDispersion): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        // If transparency isn't enabled already, this extension shouldn't do anything.\r\n        // i.e. it requires either the KHR_materials_transmission or KHR_materials_diffuse_transmission extensions.\r\n        if (!babylonMaterial.subSurface.isRefractionEnabled || !extension.dispersion) {\r\n            return Promise.resolve();\r\n        }\r\n        babylonMaterial.subSurface.isDispersionEnabled = true;\r\n        babylonMaterial.subSurface.dispersion = extension.dispersion;\r\n        return Promise.resolve();\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_materials_dispersion(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\nimport type { Material } from \"core/Materials/material\";\r\n\r\nimport type { IMaterial } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IEXTMaterialsDiffuseRoughness } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\nimport { Constants } from \"core/Engines/constants\";\r\n\r\nconst NAME = \"EXT_materials_diffuse_roughness\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the EXT_materials_diffuse_roughness extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"EXT_materials_diffuse_roughness\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/fdee35425ae560ea378092e38977216d63a094ec/extensions/2.0/Khronos/EXT_materials_diffuse_roughness/README.md)\r\n * @experimental\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class EXT_materials_diffuse_roughness implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 190;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IEXTMaterialsDiffuseRoughness>(context, material, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n            promises.push(this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial));\r\n            promises.push(this._loadDiffuseRoughnessPropertiesAsync(extensionContext, extension, babylonMaterial));\r\n            // eslint-disable-next-line github/no-then\r\n            return await Promise.all(promises).then(() => {});\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadDiffuseRoughnessPropertiesAsync(context: string, properties: IEXTMaterialsDiffuseRoughness, babylonMaterial: Material): Promise<void> {\r\n        if (!(babylonMaterial instanceof PBRMaterial)) {\r\n            throw new Error(`${context}: Material type not supported`);\r\n        }\r\n\r\n        const promises = new Array<Promise<any>>();\r\n\r\n        babylonMaterial.brdf.baseDiffuseModel = Constants.MATERIAL_DIFFUSE_MODEL_E_OREN_NAYAR;\r\n\r\n        if (properties.diffuseRoughnessFactor != undefined) {\r\n            babylonMaterial.baseDiffuseRoughness = properties.diffuseRoughnessFactor;\r\n        } else {\r\n            babylonMaterial.baseDiffuseRoughness = 0;\r\n        }\r\n\r\n        if (properties.diffuseRoughnessTexture) {\r\n            promises.push(\r\n                this._loader.loadTextureInfoAsync(`${context}/diffuseRoughnessTexture`, properties.diffuseRoughnessTexture, (texture) => {\r\n                    texture.name = `${babylonMaterial.name} (Diffuse Roughness)`;\r\n                    babylonMaterial.baseDiffuseRoughnessTexture = texture;\r\n                })\r\n            );\r\n        }\r\n\r\n        // eslint-disable-next-line github/no-then\r\n        return Promise.all(promises).then(() => {});\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new EXT_materials_diffuse_roughness(loader));\r\n","import type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport type { GLTFLoader } from \"../glTFLoader\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_mesh_quantization\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_mesh_quantization extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_mesh_quantization\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_mesh_quantization/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_mesh_quantization implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this.enabled = loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {}\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_mesh_quantization(loader));\r\n","import type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader, ArrayItem } from \"../glTFLoader\";\r\nimport type { ITexture } from \"../glTFLoaderInterfaces\";\r\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\r\nimport type { Nullable } from \"core/types\";\r\nimport type { IKHRTextureBasisU } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_texture_basisu\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_texture_basisu extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_texture_basisu\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_texture_basisu/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_texture_basisu implements IGLTFLoaderExtension {\r\n    /** The name of this extension. */\r\n    public readonly name = NAME;\r\n\r\n    /** Defines whether this extension is enabled. */\r\n    public enabled: boolean;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public _loadTextureAsync(context: string, texture: ITexture, assign: (babylonTexture: BaseTexture) => void): Nullable<Promise<BaseTexture>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRTextureBasisU, BaseTexture>(context, texture, this.name, async (extensionContext, extension) => {\r\n            const sampler = texture.sampler == undefined ? GLTFLoader.DefaultSampler : ArrayItem.Get(`${context}/sampler`, this._loader.gltf.samplers, texture.sampler);\r\n            const image = ArrayItem.Get(`${extensionContext}/source`, this._loader.gltf.images, extension.source);\r\n            return await this._loader._createTextureAsync(\r\n                context,\r\n                sampler,\r\n                image,\r\n                (babylonTexture) => {\r\n                    assign(babylonTexture);\r\n                },\r\n                texture._textureInfo.nonColorData ? { useRGBAIfASTCBC7NotAvailableWhenUASTC: true } : undefined,\r\n                !texture._textureInfo.nonColorData\r\n            );\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_texture_basisu(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\r\nimport { Texture } from \"core/Materials/Textures/texture\";\r\n\r\nimport type { ITextureInfo } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IKHRTextureTransform } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_texture_transform\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_texture_transform extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_texture_transform\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_texture_transform/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_texture_transform implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadTextureInfoAsync(context: string, textureInfo: ITextureInfo, assign: (babylonTexture: BaseTexture) => void): Nullable<Promise<BaseTexture>> {\r\n        return GLTFLoader.LoadExtensionAsync<IKHRTextureTransform, BaseTexture>(context, textureInfo, this.name, async (extensionContext, extension) => {\r\n            return await this._loader.loadTextureInfoAsync(context, textureInfo, (babylonTexture) => {\r\n                if (!(babylonTexture instanceof Texture)) {\r\n                    throw new Error(`${extensionContext}: Texture type not supported`);\r\n                }\r\n\r\n                if (extension.offset) {\r\n                    babylonTexture.uOffset = extension.offset[0];\r\n                    babylonTexture.vOffset = extension.offset[1];\r\n                }\r\n\r\n                // Always rotate around the origin.\r\n                babylonTexture.uRotationCenter = 0;\r\n                babylonTexture.vRotationCenter = 0;\r\n\r\n                if (extension.rotation) {\r\n                    babylonTexture.wAng = -extension.rotation;\r\n                }\r\n\r\n                if (extension.scale) {\r\n                    babylonTexture.uScale = extension.scale[0];\r\n                    babylonTexture.vScale = extension.scale[1];\r\n                }\r\n\r\n                if (extension.texCoord != undefined) {\r\n                    babylonTexture.coordinatesIndex = extension.texCoord;\r\n                }\r\n\r\n                assign(babylonTexture);\r\n            });\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_texture_transform(loader));\r\n","import type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport type { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IKHRXmpJsonLd_Gltf, IKHRXmpJsonLd_Node } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"KHR_xmp_json_ld\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_xmp_json_ld extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_xmp_json_ld\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_xmp_json_ld/README.md)\r\n * @since 5.0.0\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_xmp_json_ld implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 100;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * Called after the loader state changes to LOADING.\r\n     */\r\n    public onLoading(): void {\r\n        if (this._loader.rootBabylonMesh === null) {\r\n            return;\r\n        }\r\n\r\n        const xmpGltf = this._loader.gltf.extensions?.KHR_xmp_json_ld as IKHRXmpJsonLd_Gltf;\r\n        const xmpNode = this._loader.gltf.asset?.extensions?.KHR_xmp_json_ld as IKHRXmpJsonLd_Node;\r\n        if (xmpGltf && xmpNode) {\r\n            const packet = +xmpNode.packet;\r\n            if (xmpGltf.packets && packet < xmpGltf.packets.length) {\r\n                this._loader.rootBabylonMesh.metadata = this._loader.rootBabylonMesh.metadata || {};\r\n                this._loader.rootBabylonMesh.metadata.xmp = xmpGltf.packets[packet];\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_xmp_json_ld(loader));\r\n","/* eslint-disable @typescript-eslint/naming-convention */\r\n\r\nimport { Animation } from \"core/Animations/animation\";\r\nimport type { ICamera, IKHRLightsPunctual_Light, IMaterial } from \"../glTFLoaderInterfaces\";\r\nimport type { IAnimatable } from \"core/Animations/animatable.interface\";\r\nimport { AnimationPropertyInfo } from \"../glTFLoaderAnimation\";\r\nimport { Color3 } from \"core/Maths/math.color\";\r\nimport { SetInterpolationForKey } from \"./objectModelMapping\";\r\n\r\nfunction getColor3(_target: any, source: Float32Array, offset: number, scale: number): Color3 {\r\n    return Color3.FromArray(source, offset).scale(scale);\r\n}\r\n\r\nfunction getAlpha(_target: any, source: Float32Array, offset: number, scale: number): number {\r\n    return source[offset + 3] * scale;\r\n}\r\n\r\nfunction getFloat(_target: any, source: Float32Array, offset: number, scale: number): number {\r\n    return source[offset] * scale;\r\n}\r\n\r\nfunction getMinusFloat(_target: any, source: Float32Array, offset: number, scale: number): number {\r\n    return -source[offset] * scale;\r\n}\r\n\r\nfunction getNextFloat(_target: any, source: Float32Array, offset: number, scale: number): number {\r\n    return source[offset + 1] * scale;\r\n}\r\n\r\nfunction getFloatBy2(_target: any, source: Float32Array, offset: number, scale: number): number {\r\n    return source[offset] * scale * 2;\r\n}\r\n\r\nfunction getTextureTransformTree(textureName: string) {\r\n    return {\r\n        scale: [\r\n            new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, `${textureName}.uScale`, getFloat, () => 2),\r\n            new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, `${textureName}.vScale`, getNextFloat, () => 2),\r\n        ],\r\n        offset: [\r\n            new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, `${textureName}.uOffset`, getFloat, () => 2),\r\n            new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, `${textureName}.vOffset`, getNextFloat, () => 2),\r\n        ],\r\n        rotation: [new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, `${textureName}.wAng`, getMinusFloat, () => 1)],\r\n    };\r\n}\r\n\r\nclass CameraAnimationPropertyInfo extends AnimationPropertyInfo {\r\n    /** @internal */\r\n    public buildAnimations(target: ICamera, name: string, fps: number, keys: any[]) {\r\n        return [{ babylonAnimatable: target._babylonCamera!, babylonAnimation: this._buildAnimation(name, fps, keys) }];\r\n    }\r\n}\r\n\r\nclass MaterialAnimationPropertyInfo extends AnimationPropertyInfo {\r\n    /** @internal */\r\n    public buildAnimations(target: IMaterial, name: string, fps: number, keys: any[]) {\r\n        const babylonAnimations: { babylonAnimatable: IAnimatable; babylonAnimation: Animation }[] = [];\r\n        for (const fillMode in target._data!) {\r\n            babylonAnimations.push({\r\n                babylonAnimatable: target._data[fillMode].babylonMaterial,\r\n                babylonAnimation: this._buildAnimation(name, fps, keys),\r\n            });\r\n        }\r\n        return babylonAnimations;\r\n    }\r\n}\r\n\r\nclass LightAnimationPropertyInfo extends AnimationPropertyInfo {\r\n    /** @internal */\r\n    public buildAnimations(target: IKHRLightsPunctual_Light, name: string, fps: number, keys: any[]) {\r\n        return [{ babylonAnimatable: target._babylonLight!, babylonAnimation: this._buildAnimation(name, fps, keys) }];\r\n    }\r\n}\r\n\r\nSetInterpolationForKey(\"/cameras/{}/orthographic/xmag\", [\r\n    new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"orthoLeft\", getMinusFloat, () => 1),\r\n    new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"orthoRight\", getNextFloat, () => 1),\r\n]);\r\n\r\nSetInterpolationForKey(\"/cameras/{}/orthographic/ymag\", [\r\n    new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"orthoBottom\", getMinusFloat, () => 1),\r\n    new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"orthoTop\", getNextFloat, () => 1),\r\n]);\r\n\r\nSetInterpolationForKey(\"/cameras/{}/orthographic/zfar\", [new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"maxZ\", getFloat, () => 1)]);\r\nSetInterpolationForKey(\"/cameras/{}/orthographic/znear\", [new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"minZ\", getFloat, () => 1)]);\r\n\r\nSetInterpolationForKey(\"/cameras/{}/perspective/yfov\", [new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"fov\", getFloat, () => 1)]);\r\nSetInterpolationForKey(\"/cameras/{}/perspective/zfar\", [new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"maxZ\", getFloat, () => 1)]);\r\nSetInterpolationForKey(\"/cameras/{}/perspective/znear\", [new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"minZ\", getFloat, () => 1)]);\r\n\r\n// add interpolation to the materials mapping\r\nSetInterpolationForKey(\"/materials/{}/pbrMetallicRoughness/baseColorFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_COLOR3, \"albedoColor\", getColor3, () => 4),\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"alpha\", getAlpha, () => 4),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/pbrMetallicRoughness/metallicFactor\", [new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"metallic\", getFloat, () => 1)]);\r\nSetInterpolationForKey(\"/materials/{}/pbrMetallicRoughness/metallicFactor\", [new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"roughness\", getFloat, () => 1)]);\r\nconst baseColorTextureInterpolation = getTextureTransformTree(\"albedoTexture\");\r\nSetInterpolationForKey(\"/materials/{}/pbrMetallicRoughness/baseColorTexture/extensions/KHR_texture_transform/scale\", baseColorTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/pbrMetallicRoughness/baseColorTexture/extensions/KHR_texture_transform/offset\", baseColorTextureInterpolation.offset);\r\nSetInterpolationForKey(\"/materials/{}/pbrMetallicRoughness/baseColorTexture/extensions/KHR_texture_transform/rotation\", baseColorTextureInterpolation.rotation);\r\n\r\nconst metallicRoughnessTextureInterpolation = getTextureTransformTree(\"metallicTexture\");\r\nSetInterpolationForKey(\"//materials/{}/pbrMetallicRoughness/metallicRoughnessTexture/scale\", metallicRoughnessTextureInterpolation.scale);\r\nSetInterpolationForKey(\"//materials/{}/pbrMetallicRoughness/metallicRoughnessTexture/offset\", metallicRoughnessTextureInterpolation.offset);\r\nSetInterpolationForKey(\"//materials/{}/pbrMetallicRoughness/metallicRoughnessTexture/rotation\", metallicRoughnessTextureInterpolation.rotation);\r\n\r\nSetInterpolationForKey(\"/materials/{}/emissiveFactor\", [new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_COLOR3, \"emissiveColor\", getColor3, () => 3)]);\r\nconst normalTextureInterpolation = getTextureTransformTree(\"bumpTexture\");\r\nSetInterpolationForKey(\"/materials/{}/normalTexture/scale\", [new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"bumpTexture.level\", getFloat, () => 1)]);\r\n\r\nSetInterpolationForKey(\"/materials/{}/normalTexture/extensions/KHR_texture_transform/scale\", normalTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/normalTexture/extensions/KHR_texture_transform/offset\", normalTextureInterpolation.offset);\r\nSetInterpolationForKey(\"/materials/{}/normalTexture/extensions/KHR_texture_transform/rotation\", normalTextureInterpolation.rotation);\r\n\r\nSetInterpolationForKey(\"/materials/{}/occlusionTexture/strength\", [new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"ambientTextureStrength\", getFloat, () => 1)]);\r\n\r\nconst occlusionTextureInterpolation = getTextureTransformTree(\"ambientTexture\");\r\nSetInterpolationForKey(\"/materials/{}/occlusionTexture/extensions/KHR_texture_transform/scale\", occlusionTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/occlusionTexture/extensions/KHR_texture_transform/offset\", occlusionTextureInterpolation.offset);\r\nSetInterpolationForKey(\"/materials/{}/occlusionTexture/extensions/KHR_texture_transform/rotation\", occlusionTextureInterpolation.rotation);\r\nconst emissiveTextureInterpolation = getTextureTransformTree(\"emissiveTexture\");\r\nSetInterpolationForKey(\"/materials/{}/emissiveTexture/extensions/KHR_texture_transform/scale\", emissiveTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/emissiveTexture/extensions/KHR_texture_transform/offset\", emissiveTextureInterpolation.offset);\r\nSetInterpolationForKey(\"/materials/{}/emissiveTexture/extensions/KHR_texture_transform/rotation\", emissiveTextureInterpolation.rotation);\r\n\r\n// materials extensions\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_anisotropy/anisotropyStrength\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"anisotropy.intensity\", getFloat, () => 1),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_anisotropy/anisotropyRotation\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"anisotropy.angle\", getFloat, () => 1),\r\n]);\r\nconst anisotropyTextureInterpolation = getTextureTransformTree(\"anisotropy.texture\");\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_anisotropy/anisotropyTexture/extensions/KHR_texture_transform/scale\", anisotropyTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_anisotropy/anisotropyTexture/extensions/KHR_texture_transform/offset\", anisotropyTextureInterpolation.offset);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_anisotropy/anisotropyTexture/extensions/KHR_texture_transform/rotation\", anisotropyTextureInterpolation.rotation);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_clearcoat/clearcoatFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"clearCoat.intensity\", getFloat, () => 1),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_clearcoat/clearcoatRoughnessFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"clearCoat.roughness\", getFloat, () => 1),\r\n]);\r\nconst clearcoatTextureInterpolation = getTextureTransformTree(\"clearCoat.texture\");\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_clearcoat/clearcoatTexture/extensions/KHR_texture_transform/scale\", clearcoatTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_clearcoat/clearcoatTexture/extensions/KHR_texture_transform/offset\", clearcoatTextureInterpolation.offset);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_clearcoat/clearcoatTexture/extensions/KHR_texture_transform/rotation\", clearcoatTextureInterpolation.rotation);\r\nconst clearcoatNormalTextureInterpolation = getTextureTransformTree(\"clearCoat.bumpTexture\");\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_clearcoat/clearcoatNormalTexture/scale\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"clearCoat.bumpTexture.level\", getFloat, () => 1),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_clearcoat/clearcoatNormalTexture/extensions/KHR_texture_transform/scale\", clearcoatNormalTextureInterpolation.scale);\r\nSetInterpolationForKey(\r\n    \"/materials/{}/extensions/KHR_materials_clearcoat/clearcoatNormalTexture/extensions/KHR_texture_transform/offset\",\r\n    clearcoatNormalTextureInterpolation.offset\r\n);\r\nSetInterpolationForKey(\r\n    \"/materials/{}/extensions/KHR_materials_clearcoat/clearcoatNormalTexture/extensions/KHR_texture_transform/rotation\",\r\n    clearcoatNormalTextureInterpolation.rotation\r\n);\r\nconst clearcoatRoughnessTextureInterpolation = getTextureTransformTree(\"clearCoat.textureRoughness\");\r\nSetInterpolationForKey(\r\n    \"/materials/{}/extensions/KHR_materials_clearcoat/clearcoatRoughnessTexture/extensions/KHR_texture_transform/scale\",\r\n    clearcoatRoughnessTextureInterpolation.scale\r\n);\r\nSetInterpolationForKey(\r\n    \"/materials/{}/extensions/KHR_materials_clearcoat/clearcoatRoughnessTexture/extensions/KHR_texture_transform/offset\",\r\n    clearcoatRoughnessTextureInterpolation.offset\r\n);\r\nSetInterpolationForKey(\r\n    \"/materials/{}/extensions/KHR_materials_clearcoat/clearcoatRoughnessTexture/extensions/KHR_texture_transform/rotation\",\r\n    clearcoatRoughnessTextureInterpolation.rotation\r\n);\r\n\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_dispersion/dispersionFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"subSurface.dispersion\", getFloat, () => 1),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_emissive_strength/emissiveStrength\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"emissiveIntensity\", getFloat, () => 1),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_ior/ior\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"indexOfRefraction\", getFloat, () => 1),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_iridescence/iridescenceFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"iridescence.intensity\", getFloat, () => 1),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_iridescence/iridescenceIor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"iridescence.indexOfRefraction\", getFloat, () => 1),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_iridescence/iridescenceThicknessMinimum\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"iridescence.minimumThickness\", getFloat, () => 1),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_iridescence/iridescenceThicknessMaximum\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"iridescence.maximumThickness\", getFloat, () => 1),\r\n]);\r\n\r\nconst iridescenceTextureInterpolation = getTextureTransformTree(\"iridescence.texture\");\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_iridescence/iridescenceTexture/extensions/KHR_texture_transform/scale\", iridescenceTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_iridescence/iridescenceTexture/extensions/KHR_texture_transform/offset\", iridescenceTextureInterpolation.offset);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_iridescence/iridescenceTexture/extensions/KHR_texture_transform/rotation\", iridescenceTextureInterpolation.rotation);\r\n\r\nconst iridescenceThicknessTextureInterpolation = getTextureTransformTree(\"iridescence.thicknessTexture\");\r\nSetInterpolationForKey(\r\n    \"/materials/{}/extensions/KHR_materials_iridescence/iridescenceThicknessTexture/extensions/KHR_texture_transform/scale\",\r\n    iridescenceThicknessTextureInterpolation.scale\r\n);\r\nSetInterpolationForKey(\r\n    \"/materials/{}/extensions/KHR_materials_iridescence/iridescenceThicknessTexture/extensions/KHR_texture_transform/offset\",\r\n    iridescenceThicknessTextureInterpolation.offset\r\n);\r\nSetInterpolationForKey(\r\n    \"/materials/{}/extensions/KHR_materials_iridescence/iridescenceThicknessTexture/extensions/KHR_texture_transform/rotation\",\r\n    iridescenceThicknessTextureInterpolation.rotation\r\n);\r\n\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_sheen/sheenColorFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_COLOR3, \"sheen.color\", getColor3, () => 3),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_sheen/sheenRoughnessFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"sheen.roughness\", getFloat, () => 1),\r\n]);\r\n\r\nconst sheenTextureInterpolation = getTextureTransformTree(\"sheen.texture\");\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_sheen/sheenColorTexture/extensions/KHR_texture_transform/scale\", sheenTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_sheen/sheenColorTexture/extensions/KHR_texture_transform/offset\", sheenTextureInterpolation.offset);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_sheen/sheenColorTexture/extensions/KHR_texture_transform/rotation\", sheenTextureInterpolation.rotation);\r\n\r\nconst sheenRoughnessTextureInterpolation = getTextureTransformTree(\"sheen.textureRoughness\");\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_sheen/sheenRoughnessTexture/extensions/KHR_texture_transform/scale\", sheenRoughnessTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_sheen/sheenRoughnessTexture/extensions/KHR_texture_transform/offset\", sheenRoughnessTextureInterpolation.offset);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_sheen/sheenRoughnessTexture/extensions/KHR_texture_transform/rotation\", sheenRoughnessTextureInterpolation.rotation);\r\n\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_specular/specularFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"metallicF0Factor\", getFloat, () => 1),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_specular/specularColorFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_COLOR3, \"metallicReflectanceColor\", getColor3, () => 3),\r\n]);\r\n\r\nconst specularTextureInterpolation = getTextureTransformTree(\"metallicReflectanceTexture\");\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_specular/specularTexture/extensions/KHR_texture_transform/scale\", specularTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_specular/specularTexture/extensions/KHR_texture_transform/offset\", specularTextureInterpolation.offset);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_specular/specularTexture/extensions/KHR_texture_transform/rotation\", specularTextureInterpolation.rotation);\r\nconst specularColorTextureInterpolation = getTextureTransformTree(\"reflectanceTexture\");\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_specular/specularColorTexture/extensions/KHR_texture_transform/scale\", specularColorTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_specular/specularColorTexture/extensions/KHR_texture_transform/offset\", specularColorTextureInterpolation.offset);\r\nSetInterpolationForKey(\r\n    \"/materials/{}/extensions/KHR_materials_specular/specularColorTexture/extensions/KHR_texture_transform/rotation\",\r\n    specularColorTextureInterpolation.rotation\r\n);\r\n\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_transmission/transmissionFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"subSurface.refractionIntensity\", getFloat, () => 1),\r\n]);\r\nconst transmissionTextureInterpolation = getTextureTransformTree(\"subSurface.refractionIntensityTexture\");\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_transmission/transmissionTexture/extensions/KHR_texture_transform/scale\", transmissionTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_transmission/transmissionTexture/extensions/KHR_texture_transform/offset\", transmissionTextureInterpolation.offset);\r\nSetInterpolationForKey(\r\n    \"/materials/{}/extensions/KHR_materials_transmission/transmissionTexture/extensions/KHR_texture_transform/rotation\",\r\n    transmissionTextureInterpolation.rotation\r\n);\r\n\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_volume/attenuationColor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_COLOR3, \"subSurface.tintColor\", getColor3, () => 3),\r\n]);\r\n\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_volume/attenuationDistance\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"subSurface.tintColorAtDistance\", getFloat, () => 1),\r\n]);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_volume/thicknessFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"subSurface.maximumThickness\", getFloat, () => 1),\r\n]);\r\n\r\nconst thicknessTextureInterpolation = getTextureTransformTree(\"subSurface.thicknessTexture\");\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_volume/thicknessTexture/extensions/KHR_texture_transform/scale\", thicknessTextureInterpolation.scale);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_volume/thicknessTexture/extensions/KHR_texture_transform/offset\", thicknessTextureInterpolation.offset);\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_volume/thicknessTexture/extensions/KHR_texture_transform/rotation\", thicknessTextureInterpolation.rotation);\r\n\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_diffuse_transmission/diffuseTransmissionFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"subSurface.translucencyIntensity\", getFloat, () => 1),\r\n]);\r\n\r\nconst diffuseTransmissionTextureInterpolation = getTextureTransformTree(\"subSurface.translucencyIntensityTexture\");\r\nSetInterpolationForKey(\r\n    \"materials/{}/extensions/KHR_materials_diffuse_transmission/diffuseTransmissionTexture/extensions/KHR_texture_transform/scale\",\r\n    diffuseTransmissionTextureInterpolation.scale\r\n);\r\nSetInterpolationForKey(\r\n    \"materials/{}/extensions/KHR_materials_diffuse_transmission/diffuseTransmissionTexture/extensions/KHR_texture_transform/offset\",\r\n    diffuseTransmissionTextureInterpolation.offset\r\n);\r\nSetInterpolationForKey(\r\n    \"materials/{}/extensions/KHR_materials_diffuse_transmission/diffuseTransmissionTexture/extensions/KHR_texture_transform/rotation\",\r\n    diffuseTransmissionTextureInterpolation.rotation\r\n);\r\n\r\nSetInterpolationForKey(\"/materials/{}/extensions/KHR_materials_diffuse_transmission/diffuseTransmissionColorFactor\", [\r\n    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_COLOR3, \"subSurface.translucencyColor\", getColor3, () => 3),\r\n]);\r\n\r\nconst diffuseTransmissionColorTextureInterpolation = getTextureTransformTree(\"subSurface.translucencyColorTexture\");\r\nSetInterpolationForKey(\r\n    \"materials/{}/extensions/KHR_materials_diffuse_transmission/diffuseTransmissionColorTexture/extensions/KHR_texture_transform/scale\",\r\n    diffuseTransmissionColorTextureInterpolation.scale\r\n);\r\nSetInterpolationForKey(\r\n    \"materials/{}/extensions/KHR_materials_diffuse_transmission/diffuseTransmissionColorTexture/extensions/KHR_texture_transform/offset\",\r\n    diffuseTransmissionColorTextureInterpolation.offset\r\n);\r\nSetInterpolationForKey(\r\n    \"materials/{}/extensions/KHR_materials_diffuse_transmission/diffuseTransmissionColorTexture/extensions/KHR_texture_transform/rotation\",\r\n    diffuseTransmissionColorTextureInterpolation.rotation\r\n);\r\n\r\nSetInterpolationForKey(\"/extensions/KHR_lights_punctual/lights/{}/color\", [new LightAnimationPropertyInfo(Animation.ANIMATIONTYPE_COLOR3, \"diffuse\", getColor3, () => 3)]);\r\nSetInterpolationForKey(\"/extensions/KHR_lights_punctual/lights/{}/intensity\", [new LightAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"intensity\", getFloat, () => 1)]);\r\nSetInterpolationForKey(\"/extensions/KHR_lights_punctual/lights/{}/range\", [new LightAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"range\", getFloat, () => 1)]);\r\nSetInterpolationForKey(\"/extensions/KHR_lights_punctual/lights/{}/spot/innerConeAngle\", [\r\n    new LightAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"innerAngle\", getFloatBy2, () => 1),\r\n]);\r\nSetInterpolationForKey(\"/extensions/KHR_lights_punctual/lights/{}/spot/outerConeAngle\", [\r\n    new LightAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"angle\", getFloatBy2, () => 1),\r\n]);\r\n\r\nSetInterpolationForKey(\"/nodes/{}/extensions/EXT_lights_ies/color\", [new LightAnimationPropertyInfo(Animation.ANIMATIONTYPE_COLOR3, \"diffuse\", getColor3, () => 3)]);\r\nSetInterpolationForKey(\"/nodes/{}/extensions/EXT_lights_ies/multiplier\", [new LightAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, \"intensity\", getFloat, () => 1)]);\r\n","import type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport type { GLTFLoader } from \"../glTFLoader\";\r\nimport type { Nullable } from \"core/types\";\r\nimport type { Animation } from \"core/Animations/animation\";\r\nimport type { IAnimatable } from \"core/Animations/animatable.interface\";\r\nimport type { IAnimation, IAnimationChannel } from \"../glTFLoaderInterfaces\";\r\nimport type { IKHRAnimationPointer } from \"babylonjs-gltf2interface\";\r\nimport { AnimationChannelTargetPath } from \"babylonjs-gltf2interface\";\r\nimport { Logger } from \"core/Misc/logger\";\r\nimport type { GLTFPathToObjectConverter } from \"./gltfPathToObjectConverter\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\nimport { GetPathToObjectConverter } from \"./objectModelMapping\";\r\nimport \"./KHR_animation_pointer.data\";\r\n\r\nconst NAME = \"KHR_animation_pointer\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_animation_pointer extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_animation_pointer\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * [Specification PR](https://github.com/KhronosGroup/glTF/pull/2147)\r\n * !!! Experimental Extension Subject to Changes !!!\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class KHR_animation_pointer implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    private _loader: GLTFLoader;\r\n    private _pathToObjectConverter?: GLTFPathToObjectConverter<any, any, any>;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this._pathToObjectConverter = GetPathToObjectConverter(this._loader.gltf);\r\n    }\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public get enabled(): boolean {\r\n        return this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n        delete this._pathToObjectConverter; // GC\r\n    }\r\n\r\n    /**\r\n     * Loads a glTF animation channel.\r\n     * @param context The context when loading the asset\r\n     * @param animationContext The context of the animation when loading the asset\r\n     * @param animation The glTF animation property\r\n     * @param channel The glTF animation channel property\r\n     * @param onLoad Called for each animation loaded\r\n     * @returns A void promise that resolves when the load is complete or null if not handled\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public _loadAnimationChannelAsync(\r\n        context: string,\r\n        animationContext: string,\r\n        animation: IAnimation,\r\n        channel: IAnimationChannel,\r\n        onLoad: (babylonAnimatable: IAnimatable, babylonAnimation: Animation) => void\r\n    ): Nullable<Promise<void>> {\r\n        const extension = channel.target.extensions?.KHR_animation_pointer as IKHRAnimationPointer;\r\n        if (!extension || !this._pathToObjectConverter) {\r\n            return null;\r\n        }\r\n\r\n        if (channel.target.path !== AnimationChannelTargetPath.POINTER) {\r\n            Logger.Warn(`${context}/target/path: Value (${channel.target.path}) must be (${AnimationChannelTargetPath.POINTER}) when using the ${this.name} extension`);\r\n        }\r\n\r\n        if (channel.target.node != undefined) {\r\n            Logger.Warn(`${context}/target/node: Value (${channel.target.node}) must not be present when using the ${this.name} extension`);\r\n        }\r\n\r\n        const extensionContext = `${context}/extensions/${this.name}`;\r\n\r\n        const pointer = extension.pointer;\r\n        if (!pointer) {\r\n            throw new Error(`${extensionContext}: Pointer is missing`);\r\n        }\r\n\r\n        try {\r\n            const obj = this._pathToObjectConverter.convert(pointer);\r\n            if (!obj.info.interpolation) {\r\n                throw new Error(`${extensionContext}/pointer: Interpolation is missing`);\r\n            }\r\n            return this._loader._loadAnimationChannelFromTargetInfoAsync(\r\n                context,\r\n                animationContext,\r\n                animation,\r\n                channel,\r\n                {\r\n                    object: obj.object,\r\n                    info: obj.info.interpolation,\r\n                },\r\n                onLoad\r\n            );\r\n        } catch (e) {\r\n            Logger.Warn(`${extensionContext}/pointer: Invalid pointer (${pointer}) skipped`);\r\n            return null;\r\n        }\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_animation_pointer(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport { Vector3 } from \"core/Maths/math.vector\";\r\nimport { Tools } from \"core/Misc/tools\";\r\nimport type { AnimationGroup } from \"core/Animations/animationGroup\";\r\nimport { AnimationEvent } from \"core/Animations/animationEvent\";\r\nimport type { TransformNode } from \"core/Meshes/transformNode\";\r\nimport { Sound } from \"core/Audio/sound\";\r\nimport { WeightedSound } from \"core/Audio/weightedsound\";\r\n\r\nimport type { IArrayItem, IScene, INode, IAnimation } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader, ArrayItem } from \"../glTFLoader\";\r\nimport type { IMSFTAudioEmitter_Clip, IMSFTAudioEmitter_Emitter, IMSFTAudioEmitter_EmittersReference, IMSFTAudioEmitter_AnimationEvent } from \"babylonjs-gltf2interface\";\r\nimport { IMSFTAudioEmitter_AnimationEventAction } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nimport \"core/Audio/audioSceneComponent\";\r\n\r\nconst NAME = \"MSFT_audio_emitter\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the MSFT_audio_emitter extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"MSFT_audio_emitter\"]: {};\r\n    }\r\n}\r\n\r\ninterface ILoaderClip extends IMSFTAudioEmitter_Clip, IArrayItem {\r\n    _objectURL?: Promise<string>;\r\n}\r\n\r\ninterface ILoaderEmitter extends IMSFTAudioEmitter_Emitter, IArrayItem {\r\n    _babylonData?: {\r\n        sound?: WeightedSound;\r\n        loaded: Promise<void>;\r\n    };\r\n    _babylonSounds: Sound[];\r\n}\r\n\r\ninterface IMSFTAudioEmitter {\r\n    clips: ILoaderClip[];\r\n    emitters: ILoaderEmitter[];\r\n}\r\n\r\ninterface ILoaderAnimationEvent extends IMSFTAudioEmitter_AnimationEvent, IArrayItem {}\r\n\r\ninterface ILoaderAnimationEvents {\r\n    events: ILoaderAnimationEvent[];\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/najadojo/glTF/blob/MSFT_audio_emitter/extensions/2.0/Vendor/MSFT_audio_emitter/README.md)\r\n * !!! Experimental Extension Subject to Changes !!!\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class MSFT_audio_emitter implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    private _loader: GLTFLoader;\r\n    private _clips: Array<ILoaderClip>;\r\n    private _emitters: Array<ILoaderEmitter>;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n        (this._clips as any) = null;\r\n        (this._emitters as any) = null;\r\n    }\r\n\r\n    /** @internal */\r\n    public onLoading(): void {\r\n        const extensions = this._loader.gltf.extensions;\r\n        if (extensions && extensions[this.name]) {\r\n            const extension = extensions[this.name] as IMSFTAudioEmitter;\r\n\r\n            this._clips = extension.clips;\r\n            this._emitters = extension.emitters;\r\n\r\n            ArrayItem.Assign(this._clips);\r\n            ArrayItem.Assign(this._emitters);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadSceneAsync(context: string, scene: IScene): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtensionAsync<IMSFTAudioEmitter_EmittersReference>(context, scene, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n\r\n            promises.push(this._loader.loadSceneAsync(context, scene));\r\n\r\n            for (const emitterIndex of extension.emitters) {\r\n                const emitter = ArrayItem.Get(`${extensionContext}/emitters`, this._emitters, emitterIndex);\r\n                if (\r\n                    emitter.refDistance != undefined ||\r\n                    emitter.maxDistance != undefined ||\r\n                    emitter.rolloffFactor != undefined ||\r\n                    emitter.distanceModel != undefined ||\r\n                    emitter.innerAngle != undefined ||\r\n                    emitter.outerAngle != undefined\r\n                ) {\r\n                    throw new Error(`${extensionContext}: Direction or Distance properties are not allowed on emitters attached to a scene`);\r\n                }\r\n\r\n                promises.push(this._loadEmitterAsync(`${extensionContext}/emitters/${emitter.index}`, emitter));\r\n            }\r\n\r\n            await Promise.all(promises);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadNodeAsync(context: string, node: INode, assign: (babylonTransformNode: TransformNode) => void): Nullable<Promise<TransformNode>> {\r\n        return GLTFLoader.LoadExtensionAsync<IMSFTAudioEmitter_EmittersReference, TransformNode>(context, node, this.name, async (extensionContext, extension) => {\r\n            const promises = new Array<Promise<any>>();\r\n\r\n            const babylonMesh = await this._loader.loadNodeAsync(extensionContext, node, (babylonMesh) => {\r\n                for (const emitterIndex of extension.emitters) {\r\n                    const emitter = ArrayItem.Get(`${extensionContext}/emitters`, this._emitters, emitterIndex);\r\n                    promises.push(\r\n                        // eslint-disable-next-line github/no-then\r\n                        this._loadEmitterAsync(`${extensionContext}/emitters/${emitter.index}`, emitter).then(() => {\r\n                            for (const sound of emitter._babylonSounds) {\r\n                                sound.attachToMesh(babylonMesh);\r\n                                if (emitter.innerAngle != undefined || emitter.outerAngle != undefined) {\r\n                                    sound.setLocalDirectionToMesh(Vector3.Forward());\r\n                                    sound.setDirectionalCone(\r\n                                        2 * Tools.ToDegrees(emitter.innerAngle == undefined ? Math.PI : emitter.innerAngle),\r\n                                        2 * Tools.ToDegrees(emitter.outerAngle == undefined ? Math.PI : emitter.outerAngle),\r\n                                        0\r\n                                    );\r\n                                }\r\n                            }\r\n                        })\r\n                    );\r\n                }\r\n\r\n                assign(babylonMesh);\r\n            });\r\n            await Promise.all(promises);\r\n            return babylonMesh;\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadAnimationAsync(context: string, animation: IAnimation): Nullable<Promise<AnimationGroup>> {\r\n        return GLTFLoader.LoadExtensionAsync<ILoaderAnimationEvents, AnimationGroup>(context, animation, this.name, async (extensionContext, extension) => {\r\n            const babylonAnimationGroup = await this._loader.loadAnimationAsync(context, animation);\r\n            const promises = new Array<Promise<any>>();\r\n            ArrayItem.Assign(extension.events);\r\n            for (const event of extension.events) {\r\n                promises.push(this._loadAnimationEventAsync(`${extensionContext}/events/${event.index}`, context, animation, event, babylonAnimationGroup));\r\n            }\r\n            await Promise.all(promises);\r\n            return babylonAnimationGroup;\r\n        });\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadClipAsync(context: string, clip: ILoaderClip): Promise<string> {\r\n        if (clip._objectURL) {\r\n            return clip._objectURL;\r\n        }\r\n\r\n        let promise: Promise<ArrayBufferView>;\r\n        if (clip.uri) {\r\n            promise = this._loader.loadUriAsync(context, clip, clip.uri);\r\n        } else {\r\n            const bufferView = ArrayItem.Get(`${context}/bufferView`, this._loader.gltf.bufferViews, clip.bufferView);\r\n            promise = this._loader.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView);\r\n        }\r\n\r\n        // eslint-disable-next-line github/no-then\r\n        clip._objectURL = promise.then((data) => {\r\n            return URL.createObjectURL(new Blob([data], { type: clip.mimeType }));\r\n        });\r\n\r\n        return clip._objectURL;\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadEmitterAsync(context: string, emitter: ILoaderEmitter): Promise<void> {\r\n        emitter._babylonSounds = emitter._babylonSounds || [];\r\n        if (!emitter._babylonData) {\r\n            const clipPromises = new Array<Promise<any>>();\r\n            const name = emitter.name || `emitter${emitter.index}`;\r\n            const options = {\r\n                loop: false,\r\n                autoplay: false,\r\n                volume: emitter.volume == undefined ? 1 : emitter.volume,\r\n            };\r\n\r\n            for (let i = 0; i < emitter.clips.length; i++) {\r\n                const clipContext = `/extensions/${this.name}/clips`;\r\n                const clip = ArrayItem.Get(clipContext, this._clips, emitter.clips[i].clip);\r\n                clipPromises.push(\r\n                    // eslint-disable-next-line github/no-then\r\n                    this._loadClipAsync(`${clipContext}/${emitter.clips[i].clip}`, clip).then((objectURL: string) => {\r\n                        const sound = (emitter._babylonSounds[i] = new Sound(name, objectURL, this._loader.babylonScene, null, options));\r\n                        sound.refDistance = emitter.refDistance || 1;\r\n                        sound.maxDistance = emitter.maxDistance || 256;\r\n                        sound.rolloffFactor = emitter.rolloffFactor || 1;\r\n                        sound.distanceModel = emitter.distanceModel || \"exponential\";\r\n                    })\r\n                );\r\n            }\r\n\r\n            // eslint-disable-next-line github/no-then\r\n            const promise = Promise.all(clipPromises).then(() => {\r\n                const weights = emitter.clips.map((clip) => {\r\n                    return clip.weight || 1;\r\n                });\r\n                const weightedSound = new WeightedSound(emitter.loop || false, emitter._babylonSounds, weights);\r\n                if (emitter.innerAngle) {\r\n                    weightedSound.directionalConeInnerAngle = 2 * Tools.ToDegrees(emitter.innerAngle);\r\n                }\r\n                if (emitter.outerAngle) {\r\n                    weightedSound.directionalConeOuterAngle = 2 * Tools.ToDegrees(emitter.outerAngle);\r\n                }\r\n                if (emitter.volume) {\r\n                    weightedSound.volume = emitter.volume;\r\n                }\r\n                emitter._babylonData!.sound = weightedSound;\r\n            });\r\n\r\n            emitter._babylonData = {\r\n                loaded: promise,\r\n            };\r\n        }\r\n\r\n        return emitter._babylonData.loaded;\r\n    }\r\n\r\n    private _getEventAction(\r\n        context: string,\r\n        sound: WeightedSound,\r\n        action: IMSFTAudioEmitter_AnimationEventAction,\r\n        time: number,\r\n        startOffset?: number\r\n    ): (currentFrame: number) => void {\r\n        switch (action) {\r\n            case IMSFTAudioEmitter_AnimationEventAction.play: {\r\n                return (currentFrame: number) => {\r\n                    const frameOffset = (startOffset || 0) + (currentFrame - time);\r\n                    sound.play(frameOffset);\r\n                };\r\n            }\r\n            case IMSFTAudioEmitter_AnimationEventAction.stop: {\r\n                return () => {\r\n                    sound.stop();\r\n                };\r\n            }\r\n            case IMSFTAudioEmitter_AnimationEventAction.pause: {\r\n                return () => {\r\n                    sound.pause();\r\n                };\r\n            }\r\n            default: {\r\n                throw new Error(`${context}: Unsupported action ${action}`);\r\n            }\r\n        }\r\n    }\r\n\r\n    // eslint-disable-next-line @typescript-eslint/promise-function-async, no-restricted-syntax\r\n    private _loadAnimationEventAsync(\r\n        context: string,\r\n        animationContext: string,\r\n        animation: IAnimation,\r\n        event: ILoaderAnimationEvent,\r\n        babylonAnimationGroup: AnimationGroup\r\n    ): Promise<void> {\r\n        if (babylonAnimationGroup.targetedAnimations.length == 0) {\r\n            return Promise.resolve();\r\n        }\r\n        const babylonAnimation = babylonAnimationGroup.targetedAnimations[0];\r\n        const emitterIndex = event.emitter;\r\n        const emitter = ArrayItem.Get(`/extensions/${this.name}/emitters`, this._emitters, emitterIndex);\r\n        // eslint-disable-next-line github/no-then\r\n        return this._loadEmitterAsync(context, emitter).then(() => {\r\n            const sound = emitter._babylonData!.sound;\r\n            if (sound) {\r\n                const babylonAnimationEvent = new AnimationEvent(event.time, this._getEventAction(context, sound, event.action, event.time, event.startOffset));\r\n                babylonAnimation.animation.addEvent(babylonAnimationEvent);\r\n                // Make sure all started audio stops when this animation is terminated.\r\n                babylonAnimationGroup.onAnimationGroupEndObservable.add(() => {\r\n                    sound.stop();\r\n                });\r\n                babylonAnimationGroup.onAnimationGroupPauseObservable.add(() => {\r\n                    sound.pause();\r\n                });\r\n            }\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new MSFT_audio_emitter(loader));\r\n","/* eslint-disable github/no-then */\r\nimport type { Nullable } from \"core/types\";\r\nimport { Observable } from \"core/Misc/observable\";\r\nimport { Deferred } from \"core/Misc/deferred\";\r\nimport type { Material } from \"core/Materials/material\";\r\nimport type { TransformNode } from \"core/Meshes/transformNode\";\r\nimport type { Mesh } from \"core/Meshes/mesh\";\r\nimport type { BaseTexture } from \"core/Materials/Textures/baseTexture\";\r\nimport type { INode, IMaterial, IBuffer, IScene } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader, ArrayItem } from \"../glTFLoader\";\r\nimport type { IProperty, IMSFTLOD } from \"babylonjs-gltf2interface\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"MSFT_lod\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the MSFT_lod extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"MSFT_lod\"]: Partial<{\r\n            /**\r\n             * Maximum number of LODs to load, starting from the lowest LOD.\r\n             */\r\n            maxLODsToLoad: number;\r\n        }>;\r\n    }\r\n}\r\n\r\ninterface IBufferInfo {\r\n    start: number;\r\n    end: number;\r\n    loaded: Deferred<ArrayBufferView>;\r\n}\r\n\r\n/**\r\n * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Vendor/MSFT_lod/README.md)\r\n */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class MSFT_lod implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    /**\r\n     * Defines a number that determines the order the extensions are applied.\r\n     */\r\n    public order = 100;\r\n\r\n    /**\r\n     * Maximum number of LODs to load, starting from the lowest LOD.\r\n     */\r\n    public maxLODsToLoad = 10;\r\n\r\n    /**\r\n     * Observable raised when all node LODs of one level are loaded.\r\n     * The event data is the index of the loaded LOD starting from zero.\r\n     * Dispose the loader to cancel the loading of the next level of LODs.\r\n     */\r\n    public onNodeLODsLoadedObservable = new Observable<number>();\r\n\r\n    /**\r\n     * Observable raised when all material LODs of one level are loaded.\r\n     * The event data is the index of the loaded LOD starting from zero.\r\n     * Dispose the loader to cancel the loading of the next level of LODs.\r\n     */\r\n    public onMaterialLODsLoadedObservable = new Observable<number>();\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    private _bufferLODs = new Array<IBufferInfo>();\r\n\r\n    private _nodeIndexLOD: Nullable<number> = null;\r\n    private _nodeSignalLODs = new Array<Deferred<void>>();\r\n    private _nodePromiseLODs = new Array<Array<Promise<any>>>();\r\n    private _nodeBufferLODs = new Array<IBufferInfo>();\r\n\r\n    private _materialIndexLOD: Nullable<number> = null;\r\n    private _materialSignalLODs = new Array<Deferred<void>>();\r\n    private _materialPromiseLODs = new Array<Array<Promise<any>>>();\r\n    private _materialBufferLODs = new Array<IBufferInfo>();\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        // Options takes precedence. The maxLODsToLoad extension property is retained for back compat.\r\n        // For new extensions, they should only use options.\r\n        this.maxLODsToLoad = this._loader.parent.extensionOptions[NAME]?.maxLODsToLoad ?? this.maxLODsToLoad;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n\r\n        this._nodeIndexLOD = null;\r\n        this._nodeSignalLODs.length = 0;\r\n        this._nodePromiseLODs.length = 0;\r\n        this._nodeBufferLODs.length = 0;\r\n\r\n        this._materialIndexLOD = null;\r\n        this._materialSignalLODs.length = 0;\r\n        this._materialPromiseLODs.length = 0;\r\n        this._materialBufferLODs.length = 0;\r\n\r\n        this.onMaterialLODsLoadedObservable.clear();\r\n        this.onNodeLODsLoadedObservable.clear();\r\n    }\r\n\r\n    /** @internal */\r\n    public onReady(): void {\r\n        for (let indexLOD = 0; indexLOD < this._nodePromiseLODs.length; indexLOD++) {\r\n            const promise = Promise.all(this._nodePromiseLODs[indexLOD]).then(() => {\r\n                if (indexLOD !== 0) {\r\n                    this._loader.endPerformanceCounter(`Node LOD ${indexLOD}`);\r\n                    this._loader.log(`Loaded node LOD ${indexLOD}`);\r\n                }\r\n\r\n                this.onNodeLODsLoadedObservable.notifyObservers(indexLOD);\r\n\r\n                if (indexLOD !== this._nodePromiseLODs.length - 1) {\r\n                    this._loader.startPerformanceCounter(`Node LOD ${indexLOD + 1}`);\r\n                    this._loadBufferLOD(this._nodeBufferLODs, indexLOD + 1);\r\n                    if (this._nodeSignalLODs[indexLOD]) {\r\n                        this._nodeSignalLODs[indexLOD].resolve();\r\n                    }\r\n                }\r\n            });\r\n\r\n            this._loader._completePromises.push(promise);\r\n        }\r\n\r\n        for (let indexLOD = 0; indexLOD < this._materialPromiseLODs.length; indexLOD++) {\r\n            const promise = Promise.all(this._materialPromiseLODs[indexLOD]).then(() => {\r\n                if (indexLOD !== 0) {\r\n                    this._loader.endPerformanceCounter(`Material LOD ${indexLOD}`);\r\n                    this._loader.log(`Loaded material LOD ${indexLOD}`);\r\n                }\r\n\r\n                this.onMaterialLODsLoadedObservable.notifyObservers(indexLOD);\r\n\r\n                if (indexLOD !== this._materialPromiseLODs.length - 1) {\r\n                    this._loader.startPerformanceCounter(`Material LOD ${indexLOD + 1}`);\r\n                    this._loadBufferLOD(this._materialBufferLODs, indexLOD + 1);\r\n                    if (this._materialSignalLODs[indexLOD]) {\r\n                        this._materialSignalLODs[indexLOD].resolve();\r\n                    }\r\n                }\r\n            });\r\n\r\n            this._loader._completePromises.push(promise);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadSceneAsync(context: string, scene: IScene): Nullable<Promise<void>> {\r\n        const promise = this._loader.loadSceneAsync(context, scene);\r\n        this._loadBufferLOD(this._bufferLODs, 0);\r\n        return promise;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadNodeAsync(context: string, node: INode, assign: (babylonTransformNode: TransformNode) => void): Nullable<Promise<TransformNode>> {\r\n        return GLTFLoader.LoadExtensionAsync<IMSFTLOD, TransformNode>(context, node, this.name, async (extensionContext, extension) => {\r\n            let firstPromise: Promise<TransformNode>;\r\n\r\n            const nodeLODs = this._getLODs(extensionContext, node, this._loader.gltf.nodes, extension.ids);\r\n            this._loader.logOpen(`${extensionContext}`);\r\n\r\n            for (let indexLOD = 0; indexLOD < nodeLODs.length; indexLOD++) {\r\n                const nodeLOD = nodeLODs[indexLOD];\r\n\r\n                if (indexLOD !== 0) {\r\n                    this._nodeIndexLOD = indexLOD;\r\n                    this._nodeSignalLODs[indexLOD] = this._nodeSignalLODs[indexLOD] || new Deferred();\r\n                }\r\n\r\n                const assignWrap = (babylonTransformNode: TransformNode) => {\r\n                    assign(babylonTransformNode);\r\n                    babylonTransformNode.setEnabled(false);\r\n                };\r\n\r\n                const promise = this._loader.loadNodeAsync(`/nodes/${nodeLOD.index}`, nodeLOD, assignWrap).then((babylonMesh) => {\r\n                    if (indexLOD !== 0) {\r\n                        // TODO: should not rely on _babylonTransformNode\r\n                        const previousNodeLOD = nodeLODs[indexLOD - 1];\r\n                        if (previousNodeLOD._babylonTransformNode) {\r\n                            this._disposeTransformNode(previousNodeLOD._babylonTransformNode);\r\n                            delete previousNodeLOD._babylonTransformNode;\r\n                        }\r\n                    }\r\n\r\n                    babylonMesh.setEnabled(true);\r\n                    return babylonMesh;\r\n                });\r\n\r\n                this._nodePromiseLODs[indexLOD] = this._nodePromiseLODs[indexLOD] || [];\r\n\r\n                if (indexLOD === 0) {\r\n                    firstPromise = promise;\r\n                } else {\r\n                    this._nodeIndexLOD = null;\r\n                    this._nodePromiseLODs[indexLOD].push(promise);\r\n                }\r\n            }\r\n\r\n            this._loader.logClose();\r\n            return await firstPromise!;\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public _loadMaterialAsync(\r\n        context: string,\r\n        material: IMaterial,\r\n        babylonMesh: Nullable<Mesh>,\r\n        babylonDrawMode: number,\r\n        assign: (babylonMaterial: Material) => void\r\n    ): Nullable<Promise<Material>> {\r\n        // Don't load material LODs if already loading a node LOD.\r\n        if (this._nodeIndexLOD) {\r\n            return null;\r\n        }\r\n\r\n        return GLTFLoader.LoadExtensionAsync<IMSFTLOD, Material>(context, material, this.name, async (extensionContext, extension) => {\r\n            let firstPromise: Promise<Material>;\r\n\r\n            const materialLODs = this._getLODs(extensionContext, material, this._loader.gltf.materials, extension.ids);\r\n            this._loader.logOpen(`${extensionContext}`);\r\n\r\n            for (let indexLOD = 0; indexLOD < materialLODs.length; indexLOD++) {\r\n                const materialLOD = materialLODs[indexLOD];\r\n\r\n                if (indexLOD !== 0) {\r\n                    this._materialIndexLOD = indexLOD;\r\n                }\r\n\r\n                const promise = this._loader\r\n                    ._loadMaterialAsync(`/materials/${materialLOD.index}`, materialLOD, babylonMesh, babylonDrawMode, (babylonMaterial) => {\r\n                        if (indexLOD === 0) {\r\n                            assign(babylonMaterial);\r\n                        }\r\n                    })\r\n                    .then((babylonMaterial) => {\r\n                        if (indexLOD !== 0) {\r\n                            assign(babylonMaterial);\r\n\r\n                            // TODO: should not rely on _data\r\n                            const previousDataLOD = materialLODs[indexLOD - 1]._data!;\r\n                            if (previousDataLOD[babylonDrawMode]) {\r\n                                this._disposeMaterials([previousDataLOD[babylonDrawMode].babylonMaterial]);\r\n                                delete previousDataLOD[babylonDrawMode];\r\n                            }\r\n                        }\r\n\r\n                        return babylonMaterial;\r\n                    });\r\n\r\n                this._materialPromiseLODs[indexLOD] = this._materialPromiseLODs[indexLOD] || [];\r\n\r\n                if (indexLOD === 0) {\r\n                    firstPromise = promise;\r\n                } else {\r\n                    this._materialIndexLOD = null;\r\n                    this._materialPromiseLODs[indexLOD].push(promise);\r\n                }\r\n            }\r\n\r\n            this._loader.logClose();\r\n            return await firstPromise!;\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public _loadUriAsync(context: string, property: IProperty, uri: string): Nullable<Promise<ArrayBufferView>> {\r\n        // Defer the loading of uris if loading a node or material LOD.\r\n        if (this._nodeIndexLOD !== null) {\r\n            this._loader.log(`deferred`);\r\n            const previousIndexLOD = this._nodeIndexLOD - 1;\r\n            this._nodeSignalLODs[previousIndexLOD] = this._nodeSignalLODs[previousIndexLOD] || new Deferred<void>();\r\n            return this._nodeSignalLODs[this._nodeIndexLOD - 1].promise.then(async () => {\r\n                return await this._loader.loadUriAsync(context, property, uri);\r\n            });\r\n        } else if (this._materialIndexLOD !== null) {\r\n            this._loader.log(`deferred`);\r\n            const previousIndexLOD = this._materialIndexLOD - 1;\r\n            this._materialSignalLODs[previousIndexLOD] = this._materialSignalLODs[previousIndexLOD] || new Deferred<void>();\r\n            return this._materialSignalLODs[previousIndexLOD].promise.then(async () => {\r\n                return await this._loader.loadUriAsync(context, property, uri);\r\n            });\r\n        }\r\n\r\n        return null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadBufferAsync(context: string, buffer: IBuffer, byteOffset: number, byteLength: number): Nullable<Promise<ArrayBufferView>> {\r\n        if (this._loader.parent.useRangeRequests && !buffer.uri) {\r\n            if (!this._loader.bin) {\r\n                throw new Error(`${context}: Uri is missing or the binary glTF is missing its binary chunk`);\r\n            }\r\n\r\n            const loadAsync = async (bufferLODs: Array<IBufferInfo>, indexLOD: number) => {\r\n                const start = byteOffset;\r\n                const end = start + byteLength - 1;\r\n                let bufferLOD = bufferLODs[indexLOD];\r\n                if (bufferLOD) {\r\n                    bufferLOD.start = Math.min(bufferLOD.start, start);\r\n                    bufferLOD.end = Math.max(bufferLOD.end, end);\r\n                } else {\r\n                    bufferLOD = { start: start, end: end, loaded: new Deferred() };\r\n                    bufferLODs[indexLOD] = bufferLOD;\r\n                }\r\n\r\n                return await bufferLOD.loaded.promise.then((data) => {\r\n                    return new Uint8Array(data.buffer, data.byteOffset + byteOffset - bufferLOD.start, byteLength);\r\n                });\r\n            };\r\n\r\n            this._loader.log(`deferred`);\r\n\r\n            if (this._nodeIndexLOD !== null) {\r\n                return loadAsync(this._nodeBufferLODs, this._nodeIndexLOD);\r\n            } else if (this._materialIndexLOD !== null) {\r\n                return loadAsync(this._materialBufferLODs, this._materialIndexLOD);\r\n            } else {\r\n                return loadAsync(this._bufferLODs, 0);\r\n            }\r\n        }\r\n\r\n        return null;\r\n    }\r\n\r\n    private _loadBufferLOD(bufferLODs: Array<IBufferInfo>, indexLOD: number): void {\r\n        const bufferLOD = bufferLODs[indexLOD];\r\n        if (bufferLOD) {\r\n            this._loader.log(`Loading buffer range [${bufferLOD.start}-${bufferLOD.end}]`);\r\n            this._loader.bin!.readAsync(bufferLOD.start, bufferLOD.end - bufferLOD.start + 1).then(\r\n                (data) => {\r\n                    bufferLOD.loaded.resolve(data);\r\n                },\r\n                (error) => {\r\n                    bufferLOD.loaded.reject(error);\r\n                }\r\n            );\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @returns an array of LOD properties from lowest to highest.\r\n     * @param context\r\n     * @param property\r\n     * @param array\r\n     * @param ids\r\n     */\r\n    private _getLODs<T>(context: string, property: T, array: ArrayLike<T> | undefined, ids: number[]): T[] {\r\n        if (this.maxLODsToLoad <= 0) {\r\n            throw new Error(\"maxLODsToLoad must be greater than zero\");\r\n        }\r\n\r\n        const properties: T[] = [];\r\n\r\n        for (let i = ids.length - 1; i >= 0; i--) {\r\n            properties.push(ArrayItem.Get(`${context}/ids/${ids[i]}`, array, ids[i]));\r\n            if (properties.length === this.maxLODsToLoad) {\r\n                return properties;\r\n            }\r\n        }\r\n\r\n        properties.push(property);\r\n        return properties;\r\n    }\r\n\r\n    private _disposeTransformNode(babylonTransformNode: TransformNode): void {\r\n        const babylonMaterials: Material[] = [];\r\n        const babylonMaterial = (babylonTransformNode as Mesh).material;\r\n        if (babylonMaterial) {\r\n            babylonMaterials.push(babylonMaterial);\r\n        }\r\n        for (const babylonMesh of babylonTransformNode.getChildMeshes()) {\r\n            if (babylonMesh.material) {\r\n                babylonMaterials.push(babylonMesh.material);\r\n            }\r\n        }\r\n\r\n        babylonTransformNode.dispose();\r\n\r\n        const babylonMaterialsToDispose = babylonMaterials.filter((babylonMaterial) => this._loader.babylonScene.meshes.every((mesh) => mesh.material != babylonMaterial));\r\n        this._disposeMaterials(babylonMaterialsToDispose);\r\n    }\r\n\r\n    private _disposeMaterials(babylonMaterials: Material[]): void {\r\n        const babylonTextures: { [uniqueId: number]: BaseTexture } = {};\r\n\r\n        for (const babylonMaterial of babylonMaterials) {\r\n            for (const babylonTexture of babylonMaterial.getActiveTextures()) {\r\n                babylonTextures[babylonTexture.uniqueId] = babylonTexture;\r\n            }\r\n\r\n            babylonMaterial.dispose();\r\n        }\r\n\r\n        for (const uniqueId in babylonTextures) {\r\n            for (const babylonMaterial of this._loader.babylonScene.materials) {\r\n                if (babylonMaterial.hasTexture(babylonTextures[uniqueId])) {\r\n                    delete babylonTextures[uniqueId];\r\n                }\r\n            }\r\n        }\r\n\r\n        for (const uniqueId in babylonTextures) {\r\n            babylonTextures[uniqueId].dispose();\r\n        }\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new MSFT_lod(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport type { Material } from \"core/Materials/material\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\n\r\nimport type { IMaterial } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"MSFT_minecraftMesh\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the MSFT_minecraftMesh extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"MSFT_minecraftMesh\"]: {};\r\n    }\r\n}\r\n\r\n/** @internal */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class MSFT_minecraftMesh implements IGLTFLoaderExtension {\r\n    /** @internal */\r\n    public readonly name = NAME;\r\n\r\n    /** @internal */\r\n    public enabled: boolean;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /** @internal */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /** @internal */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtraAsync<boolean>(context, material, this.name, async (extraContext, extra) => {\r\n            if (extra) {\r\n                if (!(babylonMaterial instanceof PBRMaterial)) {\r\n                    throw new Error(`${extraContext}: Material type not supported`);\r\n                }\r\n\r\n                const promise = this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial);\r\n\r\n                if (babylonMaterial.needAlphaBlending()) {\r\n                    babylonMaterial.forceDepthWrite = true;\r\n                    babylonMaterial.separateCullingPass = true;\r\n                }\r\n\r\n                babylonMaterial.backFaceCulling = babylonMaterial.forceDepthWrite;\r\n                babylonMaterial.twoSidedLighting = true;\r\n\r\n                return await promise;\r\n            }\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new MSFT_minecraftMesh(loader));\r\n","import type { Nullable } from \"core/types\";\r\nimport type { Material } from \"core/Materials/material\";\r\nimport { PBRMaterial } from \"core/Materials/PBR/pbrMaterial\";\r\n\r\nimport type { IMaterial } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { GLTFLoader } from \"../glTFLoader\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"MSFT_sRGBFactors\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the MSFT_sRGBFactors extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"MSFT_sRGBFactors\"]: {};\r\n    }\r\n}\r\n\r\n/** @internal */\r\n// eslint-disable-next-line @typescript-eslint/naming-convention\r\nexport class MSFT_sRGBFactors implements IGLTFLoaderExtension {\r\n    /** @internal */\r\n    public readonly name = NAME;\r\n\r\n    /** @internal */\r\n    public enabled: boolean;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    /** @internal */\r\n    constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /** @internal*/\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>> {\r\n        return GLTFLoader.LoadExtraAsync<boolean>(context, material, this.name, async (extraContext, extra) => {\r\n            if (extra) {\r\n                if (!(babylonMaterial instanceof PBRMaterial)) {\r\n                    throw new Error(`${extraContext}: Material type not supported`);\r\n                }\r\n\r\n                const promise = this._loader.loadMaterialPropertiesAsync(context, material, babylonMaterial);\r\n\r\n                const useExactSrgbConversions = babylonMaterial.getScene().getEngine().useExactSrgbConversions;\r\n                if (!babylonMaterial.albedoTexture) {\r\n                    babylonMaterial.albedoColor.toLinearSpaceToRef(babylonMaterial.albedoColor, useExactSrgbConversions);\r\n                }\r\n\r\n                if (!babylonMaterial.reflectivityTexture) {\r\n                    babylonMaterial.reflectivityColor.toLinearSpaceToRef(babylonMaterial.reflectivityColor, useExactSrgbConversions);\r\n                }\r\n\r\n                return await promise;\r\n            }\r\n        });\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new MSFT_sRGBFactors(loader));\r\n","/* eslint-disable @typescript-eslint/naming-convention */\nimport type { IKHRInteractivity_Declaration, IKHRInteractivity_Graph, IKHRInteractivity_Node } from \"babylonjs-gltf2interface\";\nimport { FlowGraphBlockNames } from \"core/FlowGraph/Blocks/flowGraphBlockNames\";\nimport { Logger } from \"core/Misc/logger\";\nimport type { ISerializedFlowGraphBlock, ISerializedFlowGraphContext } from \"core/FlowGraph/typeDefinitions\";\nimport type { InteractivityEvent, InteractivityGraphToFlowGraphParser } from \"./interactivityGraphParser\";\nimport type { IGLTF } from \"../../glTFLoaderInterfaces\";\nimport { FlowGraphTypes, getAnimationTypeByFlowGraphType } from \"core/FlowGraph/flowGraphRichTypes\";\n\ninterface IGLTFToFlowGraphMappingObject<I = any, O = any> {\n    /**\n     * The name of the property in the FlowGraph block.\n     */\n    name: string;\n    /**\n     * The type of the property in the glTF specs.\n     * If not provided will be inferred.\n     */\n    gltfType?: string;\n    /**\n     * The type of the property in the FlowGraph block.\n     * If not defined it equals the glTF type.\n     */\n    flowGraphType?: string;\n    /**\n     * A function that transforms the data from the glTF to the FlowGraph block.\n     */\n    dataTransformer?: (data: I[], parser: InteractivityGraphToFlowGraphParser) => O[];\n    /**\n     * If the property is in the options passed to the constructor of the block.\n     */\n    inOptions?: boolean;\n\n    /**\n     * If the property is a pointer to a value.\n     * This will add an extra JsonPointerParser block to the graph.\n     */\n    isPointer?: boolean;\n\n    /**\n     * If the property is an index to a value.\n     * if defined this will be the name of the array to find the object in.\n     */\n    isVariable?: boolean;\n\n    /**\n     * the name of the class type this value will be mapped to.\n     * This is used if we generate more than one block for a single glTF node.\n     * Defaults to the first block in the mapping.\n     */\n    toBlock?: FlowGraphBlockNames;\n\n    /**\n     * Used in configuration values. If defined, this will be the default value, if no value is provided.\n     */\n    defaultValue?: O;\n}\n\nexport interface IGLTFToFlowGraphMapping {\n    /**\n     * The type of the FlowGraph block(s).\n     * Typically will be a single element in an array.\n     * When adding blocks defined in this module use the KHR_interactivity prefix.\n     */\n    blocks: (FlowGraphBlockNames | string)[];\n    /**\n     * The inputs of the glTF node mapped to the FlowGraph block.\n     */\n    inputs?: {\n        /**\n         * The value inputs of the glTF node mapped to the FlowGraph block.\n         */\n        values?: { [originName: string]: IGLTFToFlowGraphMappingObject };\n        /**\n         * The flow inputs of the glTF node mapped to the FlowGraph block.\n         */\n        flows?: { [originName: string]: IGLTFToFlowGraphMappingObject };\n    };\n    /**\n     * The outputs of the glTF node mapped to the FlowGraph block.\n     */\n    outputs?: {\n        /**\n         * The value outputs of the glTF node mapped to the FlowGraph block.\n         */\n        values?: { [originName: string]: IGLTFToFlowGraphMappingObject };\n        /**\n         * The flow outputs of the glTF node mapped to the FlowGraph block.\n         */\n        flows?: { [originName: string]: IGLTFToFlowGraphMappingObject };\n    };\n    /**\n     * The configuration of the glTF node mapped to the FlowGraph block.\n     * This information is usually passed to the constructor of the block.\n     */\n    configuration?: { [originName: string]: IGLTFToFlowGraphMappingObject };\n\n    /**\n     * If we generate more than one block for a single glTF node, this mapping will be used to map\n     * between the flowGraph classes.\n     */\n    typeToTypeMapping?: { [originName: string]: IGLTFToFlowGraphMappingObject };\n\n    /**\n     * The connections between two or more blocks.\n     * This is used to connect the blocks in the graph\n     */\n    interBlockConnectors?: {\n        /**\n         * The name of the input connection in the first block.\n         */\n        input: string;\n        /**\n         * The name of the output connection in the second block.\n         */\n        output: string;\n\n        /**\n         * The index of the block in the array of blocks that corresponds to the input.\n         */\n        inputBlockIndex: number;\n        /**\n         * The index of the block in the array of blocks that corresponds to the output.\n         */\n        outputBlockIndex: number;\n        /**\n         * If the connection is a variable connection or a flow connection.\n         */\n        isVariable?: boolean;\n    }[];\n\n    /**\n     * This optional function will allow to validate the node, according to the glTF specs.\n     * For example, if a node has a configuration object, it must be present and correct.\n     * This is a basic node-based validation.\n     * This function is expected to return false and log the error if the node is not valid.\n     * Note that this function can also modify the node, if needed.\n     *\n     * @param gltfBlock the glTF node to validate\n     * @param glTFObject the glTF object\n     * @returns true if validated, false if not.\n     */\n    validation?: (gltfBlock: IKHRInteractivity_Node, interactivityGraph: IKHRInteractivity_Graph, glTFObject?: IGLTF) => { valid: boolean; error?: string };\n\n    /**\n     * This is used if we need extra information for the constructor/options that is not provided directly by the glTF node.\n     * This function can return more than one node, if extra nodes are needed for this block to function correctly.\n     * Returning more than one block will usually happen when a json pointer was provided.\n     *\n     * @param gltfBlock the glTF node\n     * @param mapping the mapping object\n     * @param arrays the arrays of the interactivity object\n     * @param serializedObjects the serialized object\n     * @returns an array of serialized nodes that will be added to the graph.\n     */\n    extraProcessor?: (\n        gltfBlock: IKHRInteractivity_Node,\n        declaration: IKHRInteractivity_Declaration,\n        mapping: IGLTFToFlowGraphMapping,\n        parser: InteractivityGraphToFlowGraphParser,\n        serializedObjects: ISerializedFlowGraphBlock[],\n        context: ISerializedFlowGraphContext,\n        globalGLTF?: IGLTF\n    ) => ISerializedFlowGraphBlock[];\n}\n\nexport function getMappingForFullOperationName(fullOperationName: string) {\n    const [op, extension] = fullOperationName.split(\":\");\n    return getMappingForDeclaration({ op, extension });\n}\n\nexport function getMappingForDeclaration(declaration: IKHRInteractivity_Declaration, returnNoOpIfNotAvailable: boolean = true): IGLTFToFlowGraphMapping | undefined {\n    const mapping = declaration.extension ? gltfExtensionsToFlowGraphMapping[declaration.extension]?.[declaration.op] : gltfToFlowGraphMapping[declaration.op];\n    if (!mapping) {\n        Logger.Warn(`No mapping found for operation ${declaration.op} and extension ${declaration.extension || \"KHR_interactivity\"}`);\n        if (returnNoOpIfNotAvailable) {\n            const inputs: IGLTFToFlowGraphMapping[\"inputs\"] = {};\n            const outputs: IGLTFToFlowGraphMapping[\"outputs\"] = {\n                flows: {},\n            };\n            if (declaration.inputValueSockets) {\n                inputs.values = {};\n                for (const key in declaration.inputValueSockets) {\n                    inputs.values[key] = {\n                        name: key,\n                    };\n                }\n            }\n            if (declaration.outputValueSockets) {\n                outputs.values = {};\n                Object.keys(declaration.outputValueSockets).forEach((key) => {\n                    outputs.values![key] = {\n                        name: key,\n                    };\n                });\n            }\n            return {\n                blocks: [], // no blocks, just mapping\n                inputs,\n                outputs,\n            };\n        }\n    }\n    return mapping;\n}\n\n/**\n * This function will add new mapping to glTF interactivity.\n * Other extensions can define new types of blocks, this is the way to let interactivity know how to parse them.\n * @param key the type of node, i.e. \"variable/get\"\n * @param extension the extension of the interactivity operation, i.e. \"KHR_selectability\"\n * @param mapping The mapping object. See documentation or examples below.\n */\nexport function addNewInteractivityFlowGraphMapping(key: string, extension: string, mapping: IGLTFToFlowGraphMapping) {\n    gltfExtensionsToFlowGraphMapping[extension] ||= {};\n    gltfExtensionsToFlowGraphMapping[extension][key] = mapping;\n}\n\nconst gltfExtensionsToFlowGraphMapping: { [extension: string]: { [key: string]: IGLTFToFlowGraphMapping } } = {\n    /**\n     * This is the BABYLON extension for glTF interactivity.\n     * It defines babylon-specific blocks and operations.\n     */\n    BABYLON: {\n        /**\n         * flow/log is a flow node that logs input to the console.\n         * It has \"in\" and \"out\" flows, and takes a message as input.\n         * The message can be any type of value.\n         * The message is logged to the console when the \"in\" flow is triggered.\n         * The \"out\" flow is triggered when the message is logged.\n         */\n        \"flow/log\": {\n            blocks: [FlowGraphBlockNames.ConsoleLog],\n            inputs: {\n                values: {\n                    message: { name: \"message\" },\n                },\n            },\n        },\n    },\n};\n\n// this mapper is just a way to convert the glTF nodes to FlowGraph nodes in terms of input/output connection names and values.\nconst gltfToFlowGraphMapping: { [key: string]: IGLTFToFlowGraphMapping } = {\n    \"event/onStart\": {\n        blocks: [FlowGraphBlockNames.SceneReadyEvent],\n        outputs: {\n            flows: {\n                out: { name: \"done\" },\n            },\n        },\n    },\n    \"event/onTick\": {\n        blocks: [FlowGraphBlockNames.SceneTickEvent],\n        inputs: {},\n        outputs: {\n            values: {\n                timeSinceLastTick: { name: \"deltaTime\", gltfType: \"number\" /*, dataTransformer: (time: number) => time / 1000*/ },\n            },\n            flows: {\n                out: { name: \"done\" },\n            },\n        },\n    },\n    \"event/send\": {\n        blocks: [FlowGraphBlockNames.SendCustomEvent],\n        extraProcessor(gltfBlock, declaration, _mapping, parser, serializedObjects) {\n            // set eventId and eventData. The configuration object of the glTF should have a single object.\n            // validate that we are running it on the right block.\n            if (declaration.op !== \"event/send\" || !gltfBlock.configuration || Object.keys(gltfBlock.configuration).length !== 1) {\n                throw new Error(\"Receive event should have a single configuration object, the event itself\");\n            }\n            const eventConfiguration = gltfBlock.configuration[\"event\"];\n            const eventId = eventConfiguration.value[0];\n            if (typeof eventId !== \"number\") {\n                throw new Error(\"Event id should be a number\");\n            }\n            const event: InteractivityEvent = parser.arrays.events[eventId];\n            const serializedObject = serializedObjects[0];\n            serializedObject.config ||= {};\n            serializedObject.config.eventId = event.eventId;\n            serializedObject.config.eventData = event.eventData;\n            return serializedObjects;\n        },\n    },\n    \"event/receive\": {\n        blocks: [FlowGraphBlockNames.ReceiveCustomEvent],\n        outputs: {\n            flows: {\n                out: { name: \"done\" },\n            },\n        },\n        validation(gltfBlock, interactivityGraph) {\n            if (!gltfBlock.configuration) {\n                Logger.Error(\"Receive event should have a configuration object\");\n                return { valid: false, error: \"Receive event should have a configuration object\" };\n            }\n            const eventConfiguration = gltfBlock.configuration[\"event\"];\n            if (!eventConfiguration) {\n                Logger.Error(\"Receive event should have a single configuration object, the event itself\");\n                return { valid: false, error: \"Receive event should have a single configuration object, the event itself\" };\n            }\n            const eventId = eventConfiguration.value[0];\n            if (typeof eventId !== \"number\") {\n                Logger.Error(\"Event id should be a number\");\n                return { valid: false, error: \"Event id should be a number\" };\n            }\n            const event = interactivityGraph.events?.[eventId];\n            if (!event) {\n                Logger.Error(`Event with id ${eventId} not found`);\n                return { valid: false, error: `Event with id ${eventId} not found` };\n            }\n            return { valid: true };\n        },\n        extraProcessor(gltfBlock, declaration, _mapping, parser, serializedObjects) {\n            // set eventId and eventData. The configuration object of the glTF should have a single object.\n            // validate that we are running it on the right block.\n            if (declaration.op !== \"event/receive\" || !gltfBlock.configuration || Object.keys(gltfBlock.configuration).length !== 1) {\n                throw new Error(\"Receive event should have a single configuration object, the event itself\");\n            }\n            const eventConfiguration = gltfBlock.configuration[\"event\"];\n            const eventId = eventConfiguration.value[0];\n            if (typeof eventId !== \"number\") {\n                throw new Error(\"Event id should be a number\");\n            }\n            const event: InteractivityEvent = parser.arrays.events[eventId];\n            const serializedObject = serializedObjects[0];\n            serializedObject.config ||= {};\n            serializedObject.config.eventId = event.eventId;\n            serializedObject.config.eventData = event.eventData;\n            return serializedObjects;\n        },\n    },\n    \"math/E\": getSimpleInputMapping(FlowGraphBlockNames.E),\n    \"math/Pi\": getSimpleInputMapping(FlowGraphBlockNames.PI),\n    \"math/Inf\": getSimpleInputMapping(FlowGraphBlockNames.Inf),\n    \"math/NaN\": getSimpleInputMapping(FlowGraphBlockNames.NaN),\n    \"math/abs\": getSimpleInputMapping(FlowGraphBlockNames.Abs),\n    \"math/sign\": getSimpleInputMapping(FlowGraphBlockNames.Sign),\n    \"math/trunc\": getSimpleInputMapping(FlowGraphBlockNames.Trunc),\n    \"math/floor\": getSimpleInputMapping(FlowGraphBlockNames.Floor),\n    \"math/ceil\": getSimpleInputMapping(FlowGraphBlockNames.Ceil),\n    \"math/round\": {\n        blocks: [FlowGraphBlockNames.Round],\n        configuration: {},\n        inputs: {\n            values: {\n                a: { name: \"a\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n        extraProcessor(gltfBlock, declaration, _mapping, parser, serializedObjects) {\n            // configure it to work the way glTF specifies\n            serializedObjects[0].config ||= {};\n            serializedObjects[0].config.roundHalfAwayFromZero = true;\n            return serializedObjects;\n        },\n    },\n    \"math/fract\": getSimpleInputMapping(FlowGraphBlockNames.Fraction),\n    \"math/neg\": getSimpleInputMapping(FlowGraphBlockNames.Negation),\n    \"math/add\": getSimpleInputMapping(FlowGraphBlockNames.Add, [\"a\", \"b\"], true),\n    \"math/sub\": getSimpleInputMapping(FlowGraphBlockNames.Subtract, [\"a\", \"b\"], true),\n    \"math/mul\": {\n        blocks: [FlowGraphBlockNames.Multiply],\n        extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects) {\n            // configure it to work the way glTF specifies\n            serializedObjects[0].config ||= {};\n            serializedObjects[0].config.useMatrixPerComponent = true;\n            serializedObjects[0].config.preventIntegerFloatArithmetic = true;\n            // try to infer the type or fallback to Integer\n            // check the gltf block for the inputs, see if they have a type\n            let type = -1;\n            Object.keys(_gltfBlock.values || {}).find((value) => {\n                if (_gltfBlock.values?.[value].type !== undefined) {\n                    type = _gltfBlock.values[value].type;\n                    return true;\n                }\n                return false;\n            });\n            if (type !== -1) {\n                serializedObjects[0].config.type = _parser.arrays.types[type].flowGraphType;\n            }\n            return serializedObjects;\n        },\n        validation(gltfBlock) {\n            if (gltfBlock.values) {\n                // make sure types are the same\n                return ValidateTypes(gltfBlock);\n            }\n            return { valid: true };\n        },\n    },\n    \"math/div\": getSimpleInputMapping(FlowGraphBlockNames.Divide, [\"a\", \"b\"], true),\n    \"math/rem\": getSimpleInputMapping(FlowGraphBlockNames.Modulo, [\"a\", \"b\"]),\n    \"math/min\": getSimpleInputMapping(FlowGraphBlockNames.Min, [\"a\", \"b\"]),\n    \"math/max\": getSimpleInputMapping(FlowGraphBlockNames.Max, [\"a\", \"b\"]),\n    \"math/clamp\": getSimpleInputMapping(FlowGraphBlockNames.Clamp, [\"a\", \"b\", \"c\"]),\n    \"math/saturate\": getSimpleInputMapping(FlowGraphBlockNames.Saturate),\n    \"math/mix\": getSimpleInputMapping(FlowGraphBlockNames.MathInterpolation, [\"a\", \"b\", \"c\"]),\n    \"math/eq\": getSimpleInputMapping(FlowGraphBlockNames.Equality, [\"a\", \"b\"]),\n    \"math/lt\": getSimpleInputMapping(FlowGraphBlockNames.LessThan, [\"a\", \"b\"]),\n    \"math/le\": getSimpleInputMapping(FlowGraphBlockNames.LessThanOrEqual, [\"a\", \"b\"]),\n    \"math/gt\": getSimpleInputMapping(FlowGraphBlockNames.GreaterThan, [\"a\", \"b\"]),\n    \"math/ge\": getSimpleInputMapping(FlowGraphBlockNames.GreaterThanOrEqual, [\"a\", \"b\"]),\n    \"math/isNaN\": getSimpleInputMapping(FlowGraphBlockNames.IsNaN),\n    \"math/isInf\": getSimpleInputMapping(FlowGraphBlockNames.IsInfinity),\n    \"math/select\": {\n        blocks: [FlowGraphBlockNames.Conditional],\n        inputs: {\n            values: {\n                condition: { name: \"condition\" },\n                // Should we validate those have the same type here, or assume it is already validated?\n                a: { name: \"onTrue\" },\n                b: { name: \"onFalse\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"output\" },\n            },\n        },\n    },\n    \"math/random\": {\n        blocks: [FlowGraphBlockNames.Random],\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n    },\n    \"math/sin\": getSimpleInputMapping(FlowGraphBlockNames.Sin),\n    \"math/cos\": getSimpleInputMapping(FlowGraphBlockNames.Cos),\n    \"math/tan\": getSimpleInputMapping(FlowGraphBlockNames.Tan),\n    \"math/asin\": getSimpleInputMapping(FlowGraphBlockNames.Asin),\n    \"math/acos\": getSimpleInputMapping(FlowGraphBlockNames.Acos),\n    \"math/atan\": getSimpleInputMapping(FlowGraphBlockNames.Atan),\n    \"math/atan2\": getSimpleInputMapping(FlowGraphBlockNames.Atan2, [\"a\", \"b\"]),\n    \"math/sinh\": getSimpleInputMapping(FlowGraphBlockNames.Sinh),\n    \"math/cosh\": getSimpleInputMapping(FlowGraphBlockNames.Cosh),\n    \"math/tanh\": getSimpleInputMapping(FlowGraphBlockNames.Tanh),\n    \"math/asinh\": getSimpleInputMapping(FlowGraphBlockNames.Asinh),\n    \"math/acosh\": getSimpleInputMapping(FlowGraphBlockNames.Acosh),\n    \"math/atanh\": getSimpleInputMapping(FlowGraphBlockNames.Atanh),\n    \"math/exp\": getSimpleInputMapping(FlowGraphBlockNames.Exponential),\n    \"math/log\": getSimpleInputMapping(FlowGraphBlockNames.Log),\n    \"math/log2\": getSimpleInputMapping(FlowGraphBlockNames.Log2),\n    \"math/log10\": getSimpleInputMapping(FlowGraphBlockNames.Log10),\n    \"math/sqrt\": getSimpleInputMapping(FlowGraphBlockNames.SquareRoot),\n    \"math/cbrt\": getSimpleInputMapping(FlowGraphBlockNames.CubeRoot),\n    \"math/pow\": getSimpleInputMapping(FlowGraphBlockNames.Power, [\"a\", \"b\"]),\n    \"math/length\": getSimpleInputMapping(FlowGraphBlockNames.Length),\n    \"math/normalize\": getSimpleInputMapping(FlowGraphBlockNames.Normalize),\n    \"math/dot\": getSimpleInputMapping(FlowGraphBlockNames.Dot, [\"a\", \"b\"]),\n    \"math/cross\": getSimpleInputMapping(FlowGraphBlockNames.Cross, [\"a\", \"b\"]),\n    \"math/rotate2D\": {\n        blocks: [FlowGraphBlockNames.Rotate2D],\n        inputs: {\n            values: {\n                a: { name: \"a\" },\n                angle: { name: \"b\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n    },\n    \"math/rotate3D\": {\n        blocks: [FlowGraphBlockNames.Rotate3D],\n        inputs: {\n            values: {\n                a: { name: \"a\" },\n                rotation: { name: \"b\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n    },\n    \"math/transform\": {\n        // glTF transform is vectorN with matrixN\n        blocks: [FlowGraphBlockNames.TransformVector],\n        inputs: {\n            values: {\n                a: { name: \"a\" },\n                b: { name: \"b\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n    },\n    \"math/combine2\": {\n        blocks: [FlowGraphBlockNames.CombineVector2],\n        inputs: {\n            values: {\n                a: { name: \"input_0\", gltfType: \"number\" },\n                b: { name: \"input_1\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n    },\n    \"math/combine3\": {\n        blocks: [FlowGraphBlockNames.CombineVector3],\n        inputs: {\n            values: {\n                a: { name: \"input_0\", gltfType: \"number\" },\n                b: { name: \"input_1\", gltfType: \"number\" },\n                c: { name: \"input_2\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n    },\n    \"math/combine4\": {\n        blocks: [FlowGraphBlockNames.CombineVector4],\n        inputs: {\n            values: {\n                a: { name: \"input_0\", gltfType: \"number\" },\n                b: { name: \"input_1\", gltfType: \"number\" },\n                c: { name: \"input_2\", gltfType: \"number\" },\n                d: { name: \"input_3\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n    },\n    // one input, N outputs! outputs named using numbers.\n    \"math/extract2\": {\n        blocks: [FlowGraphBlockNames.ExtractVector2],\n        inputs: {\n            values: {\n                a: { name: \"input\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                \"0\": { name: \"output_0\" },\n                \"1\": { name: \"output_1\" },\n            },\n        },\n    },\n    \"math/extract3\": {\n        blocks: [FlowGraphBlockNames.ExtractVector3],\n        inputs: {\n            values: {\n                a: { name: \"input\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                \"0\": { name: \"output_0\" },\n                \"1\": { name: \"output_1\" },\n                \"2\": { name: \"output_2\" },\n            },\n        },\n    },\n    \"math/extract4\": {\n        blocks: [FlowGraphBlockNames.ExtractVector4],\n        inputs: {\n            values: {\n                a: { name: \"input\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                \"0\": { name: \"output_0\" },\n                \"1\": { name: \"output_1\" },\n                \"2\": { name: \"output_2\" },\n                \"3\": { name: \"output_3\" },\n            },\n        },\n    },\n    \"math/transpose\": getSimpleInputMapping(FlowGraphBlockNames.Transpose),\n    \"math/determinant\": getSimpleInputMapping(FlowGraphBlockNames.Determinant),\n    \"math/inverse\": getSimpleInputMapping(FlowGraphBlockNames.InvertMatrix),\n    \"math/matMul\": getSimpleInputMapping(FlowGraphBlockNames.MatrixMultiplication, [\"a\", \"b\"]),\n    \"math/matCompose\": {\n        blocks: [FlowGraphBlockNames.MatrixCompose],\n        inputs: {\n            values: {\n                translation: { name: \"position\", gltfType: \"float3\" },\n                rotation: { name: \"rotationQuaternion\", gltfType: \"float4\" },\n                scale: { name: \"scaling\", gltfType: \"float3\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n        extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects, context) {\n            // configure it to work the way glTF specifies\n            const d = serializedObjects[0].dataInputs.find((input) => input.name === \"rotationQuaternion\");\n            if (!d) {\n                throw new Error(\"Rotation quaternion input not found\");\n            }\n            // if value is defined, set the type to quaternion\n            if (context._connectionValues[d.uniqueId]) {\n                context._connectionValues[d.uniqueId].type = FlowGraphTypes.Quaternion;\n            }\n            return serializedObjects;\n        },\n    },\n    \"math/matDecompose\": {\n        blocks: [FlowGraphBlockNames.MatrixDecompose],\n        inputs: {\n            values: {\n                a: { name: \"input\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                translation: { name: \"position\" },\n                rotation: { name: \"rotationQuaternion\" },\n                scale: { name: \"scaling\" },\n            },\n        },\n    },\n    \"math/quatConjugate\": getSimpleInputMapping(FlowGraphBlockNames.Conjugate, [\"a\"]),\n    \"math/quatMul\": {\n        blocks: [FlowGraphBlockNames.Multiply],\n        inputs: {\n            values: {\n                a: { name: \"a\", gltfType: \"vector4\" },\n                b: { name: \"b\", gltfType: \"vector4\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n        extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects) {\n            serializedObjects[0].config ||= {};\n            serializedObjects[0].config.type = FlowGraphTypes.Quaternion;\n            return serializedObjects;\n        },\n    },\n    \"math/quatAngleBetween\": getSimpleInputMapping(FlowGraphBlockNames.AngleBetween, [\"a\", \"b\"]),\n    \"math/quatFromAxisAngle\": {\n        blocks: [FlowGraphBlockNames.QuaternionFromAxisAngle],\n        inputs: {\n            values: {\n                axis: { name: \"a\", gltfType: \"float3\" },\n                angle: { name: \"b\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n    },\n    \"math/quatToAxisAngle\": getSimpleInputMapping(FlowGraphBlockNames.AxisAngleFromQuaternion, [\"a\"]),\n    \"math/quatFromDirections\": getSimpleInputMapping(FlowGraphBlockNames.QuaternionFromDirections, [\"a\", \"b\"]),\n    \"math/combine2x2\": {\n        blocks: [FlowGraphBlockNames.CombineMatrix2D],\n        inputs: {\n            values: {\n                a: { name: \"input_0\", gltfType: \"number\" },\n                b: { name: \"input_1\", gltfType: \"number\" },\n                c: { name: \"input_2\", gltfType: \"number\" },\n                d: { name: \"input_3\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n        extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects) {\n            // configure it to work the way glTF specifies\n            serializedObjects[0].config ||= {};\n            serializedObjects[0].config.inputIsColumnMajor = true;\n            return serializedObjects;\n        },\n    },\n    \"math/extract2x2\": {\n        blocks: [FlowGraphBlockNames.ExtractMatrix2D],\n        inputs: {\n            values: {\n                a: { name: \"input\", gltfType: \"float2x2\" },\n            },\n        },\n        outputs: {\n            values: {\n                \"0\": { name: \"output_0\" },\n                \"1\": { name: \"output_1\" },\n                \"2\": { name: \"output_2\" },\n                \"3\": { name: \"output_3\" },\n            },\n        },\n    },\n    \"math/combine3x3\": {\n        blocks: [FlowGraphBlockNames.CombineMatrix3D],\n        inputs: {\n            values: {\n                a: { name: \"input_0\", gltfType: \"number\" },\n                b: { name: \"input_1\", gltfType: \"number\" },\n                c: { name: \"input_2\", gltfType: \"number\" },\n                d: { name: \"input_3\", gltfType: \"number\" },\n                e: { name: \"input_4\", gltfType: \"number\" },\n                f: { name: \"input_5\", gltfType: \"number\" },\n                g: { name: \"input_6\", gltfType: \"number\" },\n                h: { name: \"input_7\", gltfType: \"number\" },\n                i: { name: \"input_8\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n        extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects) {\n            // configure it to work the way glTF specifies\n            serializedObjects[0].config ||= {};\n            serializedObjects[0].config.inputIsColumnMajor = true;\n            return serializedObjects;\n        },\n    },\n    \"math/extract3x3\": {\n        blocks: [FlowGraphBlockNames.ExtractMatrix3D],\n        inputs: {\n            values: {\n                a: { name: \"input\", gltfType: \"float3x3\" },\n            },\n        },\n        outputs: {\n            values: {\n                \"0\": { name: \"output_0\" },\n                \"1\": { name: \"output_1\" },\n                \"2\": { name: \"output_2\" },\n                \"3\": { name: \"output_3\" },\n                \"4\": { name: \"output_4\" },\n                \"5\": { name: \"output_5\" },\n                \"6\": { name: \"output_6\" },\n                \"7\": { name: \"output_7\" },\n                \"8\": { name: \"output_8\" },\n            },\n        },\n    },\n    \"math/combine4x4\": {\n        blocks: [FlowGraphBlockNames.CombineMatrix],\n        inputs: {\n            values: {\n                a: { name: \"input_0\", gltfType: \"number\" },\n                b: { name: \"input_1\", gltfType: \"number\" },\n                c: { name: \"input_2\", gltfType: \"number\" },\n                d: { name: \"input_3\", gltfType: \"number\" },\n                e: { name: \"input_4\", gltfType: \"number\" },\n                f: { name: \"input_5\", gltfType: \"number\" },\n                g: { name: \"input_6\", gltfType: \"number\" },\n                h: { name: \"input_7\", gltfType: \"number\" },\n                i: { name: \"input_8\", gltfType: \"number\" },\n                j: { name: \"input_9\", gltfType: \"number\" },\n                k: { name: \"input_10\", gltfType: \"number\" },\n                l: { name: \"input_11\", gltfType: \"number\" },\n                m: { name: \"input_12\", gltfType: \"number\" },\n                n: { name: \"input_13\", gltfType: \"number\" },\n                o: { name: \"input_14\", gltfType: \"number\" },\n                p: { name: \"input_15\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n        extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects) {\n            // configure it to work the way glTF specifies\n            serializedObjects[0].config ||= {};\n            serializedObjects[0].config.inputIsColumnMajor = true;\n            return serializedObjects;\n        },\n    },\n    \"math/extract4x4\": {\n        blocks: [FlowGraphBlockNames.ExtractMatrix],\n        configuration: {},\n        inputs: {\n            values: {\n                a: { name: \"input\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                \"0\": { name: \"output_0\" },\n                \"1\": { name: \"output_1\" },\n                \"2\": { name: \"output_2\" },\n                \"3\": { name: \"output_3\" },\n                \"4\": { name: \"output_4\" },\n                \"5\": { name: \"output_5\" },\n                \"6\": { name: \"output_6\" },\n                \"7\": { name: \"output_7\" },\n                \"8\": { name: \"output_8\" },\n                \"9\": { name: \"output_9\" },\n                \"10\": { name: \"output_10\" },\n                \"11\": { name: \"output_11\" },\n                \"12\": { name: \"output_12\" },\n                \"13\": { name: \"output_13\" },\n                \"14\": { name: \"output_14\" },\n                \"15\": { name: \"output_15\" },\n            },\n        },\n    },\n    \"math/not\": {\n        blocks: [FlowGraphBlockNames.BitwiseNot],\n        inputs: {\n            values: {\n                a: { name: \"a\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n        extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects, context) {\n            // configure it to work the way glTF specifies\n            serializedObjects[0].config ||= {};\n            // try to infer the type or fallback to Integer\n            const socketIn = serializedObjects[0].dataInputs[0];\n            serializedObjects[0].config.valueType = context._connectionValues[socketIn.uniqueId]?.type ?? FlowGraphTypes.Integer;\n            return serializedObjects;\n        },\n    },\n    \"math/and\": {\n        blocks: [FlowGraphBlockNames.BitwiseAnd],\n        inputs: {\n            values: {\n                a: { name: \"a\" },\n                b: { name: \"b\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n        extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects, context) {\n            // configure it to work the way glTF specifies\n            serializedObjects[0].config ||= {};\n            // try to infer the type or fallback to Integer\n            const socketInA = serializedObjects[0].dataInputs[0];\n            const socketInB = serializedObjects[0].dataInputs[1];\n            serializedObjects[0].config.valueType =\n                context._connectionValues[socketInA.uniqueId]?.type ?? context._connectionValues[socketInB.uniqueId]?.type ?? FlowGraphTypes.Integer;\n            return serializedObjects;\n        },\n    },\n    \"math/or\": {\n        blocks: [FlowGraphBlockNames.BitwiseOr],\n        inputs: {\n            values: {\n                a: { name: \"a\" },\n                b: { name: \"b\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n        extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects, context) {\n            // configure it to work the way glTF specifies\n            serializedObjects[0].config ||= {};\n            // try to infer the type or fallback to Integer\n            const socketInA = serializedObjects[0].dataInputs[0];\n            const socketInB = serializedObjects[0].dataInputs[1];\n            serializedObjects[0].config.valueType =\n                context._connectionValues[socketInA.uniqueId]?.type ?? context._connectionValues[socketInB.uniqueId]?.type ?? FlowGraphTypes.Integer;\n            return serializedObjects;\n        },\n    },\n    \"math/xor\": {\n        blocks: [FlowGraphBlockNames.BitwiseXor],\n        inputs: {\n            values: {\n                a: { name: \"a\" },\n                b: { name: \"b\" },\n            },\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n        extraProcessor(_gltfBlock, _declaration, _mapping, _parser, serializedObjects, context) {\n            // configure it to work the way glTF specifies\n            serializedObjects[0].config ||= {};\n            // try to infer the type or fallback to Integer\n            const socketInA = serializedObjects[0].dataInputs[0];\n            const socketInB = serializedObjects[0].dataInputs[1];\n            serializedObjects[0].config.valueType =\n                context._connectionValues[socketInA.uniqueId]?.type ?? context._connectionValues[socketInB.uniqueId]?.type ?? FlowGraphTypes.Integer;\n            return serializedObjects;\n        },\n    },\n    \"math/asr\": getSimpleInputMapping(FlowGraphBlockNames.BitwiseRightShift, [\"a\", \"b\"]),\n    \"math/lsl\": getSimpleInputMapping(FlowGraphBlockNames.BitwiseLeftShift, [\"a\", \"b\"]),\n    \"math/clz\": getSimpleInputMapping(FlowGraphBlockNames.LeadingZeros),\n    \"math/ctz\": getSimpleInputMapping(FlowGraphBlockNames.TrailingZeros),\n    \"math/popcnt\": getSimpleInputMapping(FlowGraphBlockNames.OneBitsCounter),\n    \"math/rad\": getSimpleInputMapping(FlowGraphBlockNames.DegToRad),\n    \"math/deg\": getSimpleInputMapping(FlowGraphBlockNames.RadToDeg),\n    \"type/boolToInt\": getSimpleInputMapping(FlowGraphBlockNames.BooleanToInt),\n    \"type/boolToFloat\": getSimpleInputMapping(FlowGraphBlockNames.BooleanToFloat),\n    \"type/intToBool\": getSimpleInputMapping(FlowGraphBlockNames.IntToBoolean),\n    \"type/intToFloat\": getSimpleInputMapping(FlowGraphBlockNames.IntToFloat),\n    \"type/floatToInt\": getSimpleInputMapping(FlowGraphBlockNames.FloatToInt),\n    \"type/floatToBool\": getSimpleInputMapping(FlowGraphBlockNames.FloatToBoolean),\n\n    // flows\n    \"flow/sequence\": {\n        blocks: [FlowGraphBlockNames.Sequence],\n        extraProcessor(gltfBlock, _declaration, _mapping, _arrays, serializedObjects) {\n            const serializedObject = serializedObjects[0];\n            serializedObject.config ||= {};\n            serializedObject.config.outputSignalCount = Object.keys(gltfBlock.flows || []).length;\n            serializedObject.signalOutputs.forEach((output, index) => {\n                output.name = \"out_\" + index;\n            });\n            return serializedObjects;\n        },\n    },\n    \"flow/branch\": {\n        blocks: [FlowGraphBlockNames.Branch],\n        outputs: {\n            flows: {\n                true: { name: \"onTrue\" },\n                false: { name: \"onFalse\" },\n            },\n        },\n    },\n    \"flow/switch\": {\n        blocks: [FlowGraphBlockNames.Switch],\n        configuration: {\n            cases: { name: \"cases\", inOptions: true, defaultValue: [] },\n        },\n        inputs: {\n            values: {\n                selection: { name: \"case\" },\n                default: { name: \"default\" },\n            },\n        },\n        validation(gltfBlock) {\n            if (gltfBlock.configuration && gltfBlock.configuration.cases) {\n                const cases = gltfBlock.configuration.cases.value;\n                const onlyIntegers = cases.every((caseValue) => {\n                    // case value should be an integer. Since Number.isInteger(1.0) is true, we need to check if toString has only digits.\n                    return typeof caseValue === \"number\" && /^-?\\d+$/.test(caseValue.toString());\n                });\n                if (!onlyIntegers) {\n                    Logger.Warn(\"Switch cases should be integers. Using empty array instead.\");\n                    gltfBlock.configuration.cases.value = [] as number[];\n                    return { valid: true };\n                }\n                // check for duplicates\n                const uniqueCases = new Set(cases);\n                gltfBlock.configuration.cases.value = Array.from(uniqueCases) as number[];\n            }\n            return { valid: true };\n        },\n        extraProcessor(gltfBlock, declaration, _mapping, _arrays, serializedObjects) {\n            // convert all names of output flow to out_$1 apart from \"default\"\n            if (declaration.op !== \"flow/switch\" || !gltfBlock.flows || Object.keys(gltfBlock.flows).length === 0) {\n                throw new Error(\"Switch should have a single configuration object, the cases array\");\n            }\n            const serializedObject = serializedObjects[0];\n            serializedObject.signalOutputs.forEach((output) => {\n                if (output.name !== \"default\") {\n                    output.name = \"out_\" + output.name;\n                }\n            });\n            return serializedObjects;\n        },\n    },\n    \"flow/while\": {\n        blocks: [FlowGraphBlockNames.WhileLoop],\n        outputs: {\n            flows: {\n                loopBody: { name: \"executionFlow\" },\n            },\n        },\n    },\n    \"flow/for\": {\n        blocks: [FlowGraphBlockNames.ForLoop],\n        configuration: {\n            initialIndex: { name: \"initialIndex\", gltfType: \"number\", inOptions: true, defaultValue: 0 },\n        },\n        inputs: {\n            values: {\n                startIndex: { name: \"startIndex\", gltfType: \"number\" },\n                endIndex: { name: \"endIndex\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                index: { name: \"index\" },\n            },\n            flows: {\n                loopBody: { name: \"executionFlow\" },\n            },\n        },\n        extraProcessor(_gltfBlock, _declaration, _mapping, _arrays, serializedObjects) {\n            const serializedObject = serializedObjects[0];\n            serializedObject.config ||= {};\n            serializedObject.config.incrementIndexWhenLoopDone = true;\n            return serializedObjects;\n        },\n    },\n    \"flow/doN\": {\n        blocks: [FlowGraphBlockNames.DoN],\n        configuration: {},\n        inputs: {\n            values: {\n                n: { name: \"maxExecutions\", gltfType: \"number\" },\n            },\n        },\n        outputs: {\n            values: {\n                currentCount: { name: \"executionCount\" },\n            },\n        },\n    },\n    \"flow/multiGate\": {\n        blocks: [FlowGraphBlockNames.MultiGate],\n        configuration: {\n            isRandom: { name: \"isRandom\", gltfType: \"boolean\", inOptions: true, defaultValue: false },\n            isLoop: { name: \"isLoop\", gltfType: \"boolean\", inOptions: true, defaultValue: false },\n        },\n        extraProcessor(gltfBlock, declaration, _mapping, _arrays, serializedObjects) {\n            if (declaration.op !== \"flow/multiGate\" || !gltfBlock.flows || Object.keys(gltfBlock.flows).length === 0) {\n                throw new Error(\"MultiGate should have a single configuration object, the number of output flows\");\n            }\n            const serializedObject = serializedObjects[0];\n            serializedObject.config ||= {};\n            serializedObject.config.outputSignalCount = Object.keys(gltfBlock.flows).length;\n            serializedObject.signalOutputs.forEach((output, index) => {\n                output.name = \"out_\" + index;\n            });\n            return serializedObjects;\n        },\n    },\n    \"flow/waitAll\": {\n        blocks: [FlowGraphBlockNames.WaitAll],\n        configuration: {\n            inputFlows: { name: \"inputSignalCount\", gltfType: \"number\", inOptions: true, defaultValue: 0 },\n        },\n        inputs: {\n            flows: {\n                reset: { name: \"reset\" },\n                \"[segment]\": { name: \"in_$1\" },\n            },\n        },\n        validation(gltfBlock) {\n            // check that the configuration value is an integer\n            if (typeof gltfBlock.configuration?.inputFlows?.value[0] !== \"number\") {\n                gltfBlock.configuration = gltfBlock.configuration || {\n                    inputFlows: { value: [0] },\n                };\n                gltfBlock.configuration.inputFlows.value = [0];\n            }\n            return { valid: true };\n        },\n    },\n    \"flow/throttle\": {\n        blocks: [FlowGraphBlockNames.Throttle],\n        outputs: {\n            flows: {\n                err: { name: \"error\" },\n            },\n        },\n    },\n    \"flow/setDelay\": {\n        blocks: [FlowGraphBlockNames.SetDelay],\n        outputs: {\n            flows: {\n                err: { name: \"error\" },\n            },\n        },\n    },\n    \"flow/cancelDelay\": {\n        blocks: [FlowGraphBlockNames.CancelDelay],\n    },\n    \"variable/get\": {\n        blocks: [FlowGraphBlockNames.GetVariable],\n        validation(gltfBlock) {\n            if (!gltfBlock.configuration?.variable?.value) {\n                Logger.Error(\"Variable get block should have a variable configuration\");\n                return { valid: false, error: \"Variable get block should have a variable configuration\" };\n            }\n            return { valid: true };\n        },\n        configuration: {\n            variable: {\n                name: \"variable\",\n                gltfType: \"number\",\n                flowGraphType: \"string\",\n                inOptions: true,\n                isVariable: true,\n                dataTransformer(index, parser) {\n                    return [parser.getVariableName(index[0])];\n                },\n            },\n        },\n    },\n    \"variable/set\": {\n        blocks: [FlowGraphBlockNames.SetVariable],\n        configuration: {\n            variable: {\n                name: \"variable\",\n                gltfType: \"number\",\n                flowGraphType: \"string\",\n                inOptions: true,\n                isVariable: true,\n                dataTransformer(index: number[], parser): string[] {\n                    return [parser.getVariableName(index[0])];\n                },\n            },\n        },\n    },\n    \"variable/setMultiple\": {\n        blocks: [FlowGraphBlockNames.SetVariable],\n        configuration: {\n            variables: {\n                name: \"variables\",\n                gltfType: \"number\",\n                flowGraphType: \"string\",\n                inOptions: true,\n                dataTransformer(index: number[][], parser): string[][] {\n                    return [index[0].map((i) => parser.getVariableName(i))];\n                },\n            },\n        },\n        extraProcessor(_gltfBlock, _declaration, _mapping, parser, serializedObjects) {\n            // variable/get configuration\n            const serializedGetVariable = serializedObjects[0];\n            serializedGetVariable.dataInputs.forEach((input) => {\n                input.name = parser.getVariableName(+input.name);\n            });\n\n            return serializedObjects;\n        },\n    },\n    \"variable/interpolate\": {\n        blocks: [\n            FlowGraphBlockNames.ValueInterpolation,\n            FlowGraphBlockNames.Context,\n            FlowGraphBlockNames.PlayAnimation,\n            FlowGraphBlockNames.BezierCurveEasing,\n            FlowGraphBlockNames.GetVariable,\n        ],\n        configuration: {\n            variable: {\n                name: \"propertyName\",\n                inOptions: true,\n                isVariable: true,\n                dataTransformer(index, parser) {\n                    return [parser.getVariableName(index[0])];\n                },\n            },\n            useSlerp: {\n                name: \"animationType\",\n                inOptions: true,\n                defaultValue: false,\n                dataTransformer: (value) => {\n                    if (value[0] === true) {\n                        return [FlowGraphTypes.Quaternion];\n                    } else {\n                        return [undefined];\n                    }\n                },\n            },\n        },\n        inputs: {\n            values: {\n                value: { name: \"value_1\" },\n                duration: { name: \"duration_1\", gltfType: \"number\" },\n                p1: { name: \"controlPoint1\", toBlock: FlowGraphBlockNames.BezierCurveEasing },\n                p2: { name: \"controlPoint2\", toBlock: FlowGraphBlockNames.BezierCurveEasing },\n            },\n            flows: {\n                in: { name: \"in\", toBlock: FlowGraphBlockNames.PlayAnimation },\n            },\n        },\n        outputs: {\n            flows: {\n                err: { name: \"error\", toBlock: FlowGraphBlockNames.PlayAnimation },\n                out: { name: \"out\", toBlock: FlowGraphBlockNames.PlayAnimation },\n                done: { name: \"done\", toBlock: FlowGraphBlockNames.PlayAnimation },\n            },\n        },\n        interBlockConnectors: [\n            {\n                input: \"object\",\n                output: \"userVariables\",\n                inputBlockIndex: 2,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n            {\n                input: \"animation\",\n                output: \"animation\",\n                inputBlockIndex: 2,\n                outputBlockIndex: 0,\n                isVariable: true,\n            },\n            {\n                input: \"easingFunction\",\n                output: \"easingFunction\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 3,\n                isVariable: true,\n            },\n            {\n                input: \"value_0\",\n                output: \"value\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 4,\n                isVariable: true,\n            },\n        ],\n        extraProcessor(gltfBlock, _declaration, _mapping, parser, serializedObjects) {\n            // is useSlerp is used, animationType should be set to be quaternion!\n            const serializedValueInterpolation = serializedObjects[0];\n            const propertyIndex = gltfBlock.configuration?.variable.value[0];\n            if (typeof propertyIndex !== \"number\") {\n                Logger.Error(\"Variable index is not defined for variable interpolation block\");\n                throw new Error(\"Variable index is not defined for variable interpolation block\");\n            }\n            const variable = parser.arrays.staticVariables[propertyIndex];\n            // if not set by useSlerp\n            if (typeof serializedValueInterpolation.config.animationType.value === \"undefined\") {\n                // get the value type\n                parser.arrays.staticVariables;\n                serializedValueInterpolation.config.animationType.value = getAnimationTypeByFlowGraphType(variable.type);\n            }\n\n            // variable/get configuration\n            const serializedGetVariable = serializedObjects[4];\n            serializedGetVariable.config ||= {};\n            serializedGetVariable.config.variable ||= {};\n            serializedGetVariable.config.variable.value = parser.getVariableName(propertyIndex);\n\n            // get the control points from the easing block\n            serializedObjects[3].config ||= {};\n\n            return serializedObjects;\n        },\n    },\n    \"pointer/get\": {\n        blocks: [FlowGraphBlockNames.GetProperty, FlowGraphBlockNames.JsonPointerParser],\n        configuration: {\n            pointer: { name: \"jsonPointer\", toBlock: FlowGraphBlockNames.JsonPointerParser },\n        },\n        inputs: {\n            values: {\n                \"[segment]\": { name: \"$1\", toBlock: FlowGraphBlockNames.JsonPointerParser },\n            },\n        },\n        interBlockConnectors: [\n            {\n                input: \"object\",\n                output: \"object\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n            {\n                input: \"propertyName\",\n                output: \"propertyName\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n            {\n                input: \"customGetFunction\",\n                output: \"getFunction\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n        ],\n        extraProcessor(gltfBlock, _declaration, _mapping, parser, serializedObjects) {\n            serializedObjects.forEach((serializedObject) => {\n                // check if it is the json pointer block\n                if (serializedObject.className === FlowGraphBlockNames.JsonPointerParser) {\n                    serializedObject.config ||= {};\n                    serializedObject.config.outputValue = true;\n                }\n            });\n            return serializedObjects;\n        },\n    },\n    \"pointer/set\": {\n        blocks: [FlowGraphBlockNames.SetProperty, FlowGraphBlockNames.JsonPointerParser],\n        configuration: {\n            pointer: { name: \"jsonPointer\", toBlock: FlowGraphBlockNames.JsonPointerParser },\n        },\n        inputs: {\n            values: {\n                // must be defined due to the array taking over\n                value: { name: \"value\" },\n                \"[segment]\": { name: \"$1\", toBlock: FlowGraphBlockNames.JsonPointerParser },\n            },\n        },\n        outputs: {\n            flows: {\n                err: { name: \"error\" },\n            },\n        },\n        interBlockConnectors: [\n            {\n                input: \"object\",\n                output: \"object\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n            {\n                input: \"propertyName\",\n                output: \"propertyName\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n            {\n                input: \"customSetFunction\",\n                output: \"setFunction\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n        ],\n        extraProcessor(gltfBlock, _declaration, _mapping, parser, serializedObjects) {\n            serializedObjects.forEach((serializedObject) => {\n                // check if it is the json pointer block\n                if (serializedObject.className === FlowGraphBlockNames.JsonPointerParser) {\n                    serializedObject.config ||= {};\n                    serializedObject.config.outputValue = true;\n                }\n            });\n            return serializedObjects;\n        },\n    },\n    \"pointer/interpolate\": {\n        // interpolate, parse the pointer and play the animation generated. 3 blocks!\n        blocks: [FlowGraphBlockNames.ValueInterpolation, FlowGraphBlockNames.JsonPointerParser, FlowGraphBlockNames.PlayAnimation, FlowGraphBlockNames.BezierCurveEasing],\n        configuration: {\n            pointer: { name: \"jsonPointer\", toBlock: FlowGraphBlockNames.JsonPointerParser },\n        },\n        inputs: {\n            values: {\n                value: { name: \"value_1\" },\n                \"[segment]\": { name: \"$1\", toBlock: FlowGraphBlockNames.JsonPointerParser },\n                duration: { name: \"duration_1\", gltfType: \"number\" /*, inOptions: true */ },\n                p1: { name: \"controlPoint1\", toBlock: FlowGraphBlockNames.BezierCurveEasing },\n                p2: { name: \"controlPoint2\", toBlock: FlowGraphBlockNames.BezierCurveEasing },\n            },\n            flows: {\n                in: { name: \"in\", toBlock: FlowGraphBlockNames.PlayAnimation },\n            },\n        },\n        outputs: {\n            flows: {\n                err: { name: \"error\", toBlock: FlowGraphBlockNames.PlayAnimation },\n                out: { name: \"out\", toBlock: FlowGraphBlockNames.PlayAnimation },\n                done: { name: \"done\", toBlock: FlowGraphBlockNames.PlayAnimation },\n            },\n        },\n        interBlockConnectors: [\n            {\n                input: \"object\",\n                output: \"object\",\n                inputBlockIndex: 2,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n            {\n                input: \"propertyName\",\n                output: \"propertyName\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n            {\n                input: \"customBuildAnimation\",\n                output: \"generateAnimationsFunction\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n            {\n                input: \"animation\",\n                output: \"animation\",\n                inputBlockIndex: 2,\n                outputBlockIndex: 0,\n                isVariable: true,\n            },\n            {\n                input: \"easingFunction\",\n                output: \"easingFunction\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 3,\n                isVariable: true,\n            },\n            {\n                input: \"value_0\",\n                output: \"value\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n        ],\n        extraProcessor(gltfBlock, _declaration, _mapping, parser, serializedObjects) {\n            serializedObjects.forEach((serializedObject) => {\n                // check if it is the json pointer block\n                if (serializedObject.className === FlowGraphBlockNames.JsonPointerParser) {\n                    serializedObject.config ||= {};\n                    serializedObject.config.outputValue = true;\n                } else if (serializedObject.className === FlowGraphBlockNames.ValueInterpolation) {\n                    serializedObject.config ||= {};\n                    Object.keys(gltfBlock.values || []).forEach((key) => {\n                        const value = gltfBlock.values?.[key];\n                        if (key === \"value\" && value) {\n                            // get the type of the value\n                            const type = value.type;\n                            if (type !== undefined) {\n                                serializedObject.config.animationType = parser.arrays.types[type].flowGraphType;\n                            }\n                        }\n                    });\n                }\n            });\n            return serializedObjects;\n        },\n    },\n    \"animation/start\": {\n        blocks: [FlowGraphBlockNames.PlayAnimation, FlowGraphBlockNames.ArrayIndex, \"KHR_interactivity/FlowGraphGLTFDataProvider\"],\n        inputs: {\n            values: {\n                animation: { name: \"index\", gltfType: \"number\", toBlock: FlowGraphBlockNames.ArrayIndex },\n                speed: { name: \"speed\", gltfType: \"number\" },\n                startTime: { name: \"from\", gltfType: \"number\", dataTransformer: (time: number[], parser) => [time[0] * parser._animationTargetFps] },\n                endTime: { name: \"to\", gltfType: \"number\", dataTransformer: (time: number[], parser) => [time[0] * parser._animationTargetFps] },\n            },\n        },\n        outputs: {\n            flows: {\n                err: { name: \"error\" },\n            },\n        },\n        interBlockConnectors: [\n            {\n                input: \"animationGroup\",\n                output: \"value\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n            {\n                input: \"array\",\n                output: \"animationGroups\",\n                inputBlockIndex: 1,\n                outputBlockIndex: 2,\n                isVariable: true,\n            },\n        ],\n        extraProcessor(_gltfBlock, _declaration, _mapping, _arrays, serializedObjects, _context, globalGLTF) {\n            // add the glTF to the configuration of the last serialized object\n            const serializedObject = serializedObjects[serializedObjects.length - 1];\n            serializedObject.config ||= {};\n            serializedObject.config.glTF = globalGLTF;\n            return serializedObjects;\n        },\n    },\n    \"animation/stop\": {\n        blocks: [FlowGraphBlockNames.StopAnimation, FlowGraphBlockNames.ArrayIndex, \"KHR_interactivity/FlowGraphGLTFDataProvider\"],\n        inputs: {\n            values: {\n                animation: { name: \"index\", gltfType: \"number\", toBlock: FlowGraphBlockNames.ArrayIndex },\n            },\n        },\n        outputs: {\n            flows: {\n                err: { name: \"error\" },\n            },\n        },\n        interBlockConnectors: [\n            {\n                input: \"animationGroup\",\n                output: \"value\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n            {\n                input: \"array\",\n                output: \"animationGroups\",\n                inputBlockIndex: 1,\n                outputBlockIndex: 2,\n                isVariable: true,\n            },\n        ],\n        extraProcessor(_gltfBlock, _declaration, _mapping, _arrays, serializedObjects, _context, globalGLTF) {\n            // add the glTF to the configuration of the last serialized object\n            const serializedObject = serializedObjects[serializedObjects.length - 1];\n            serializedObject.config ||= {};\n            serializedObject.config.glTF = globalGLTF;\n            return serializedObjects;\n        },\n    },\n    \"animation/stopAt\": {\n        blocks: [FlowGraphBlockNames.StopAnimation, FlowGraphBlockNames.ArrayIndex, \"KHR_interactivity/FlowGraphGLTFDataProvider\"],\n        configuration: {},\n        inputs: {\n            values: {\n                animation: { name: \"index\", gltfType: \"number\", toBlock: FlowGraphBlockNames.ArrayIndex },\n                stopTime: { name: \"stopAtFrame\", gltfType: \"number\", dataTransformer: (time: number[], parser) => [time[0] * parser._animationTargetFps] },\n            },\n        },\n        outputs: {\n            flows: {\n                err: { name: \"error\" },\n            },\n        },\n        interBlockConnectors: [\n            {\n                input: \"animationGroup\",\n                output: \"value\",\n                inputBlockIndex: 0,\n                outputBlockIndex: 1,\n                isVariable: true,\n            },\n            {\n                input: \"array\",\n                output: \"animationGroups\",\n                inputBlockIndex: 1,\n                outputBlockIndex: 2,\n                isVariable: true,\n            },\n        ],\n        extraProcessor(_gltfBlock, _declaration, _mapping, _arrays, serializedObjects, _context, globalGLTF) {\n            // add the glTF to the configuration of the last serialized object\n            const serializedObject = serializedObjects[serializedObjects.length - 1];\n            serializedObject.config ||= {};\n            serializedObject.config.glTF = globalGLTF;\n            return serializedObjects;\n        },\n    },\n    \"math/switch\": {\n        blocks: [FlowGraphBlockNames.DataSwitch],\n        configuration: {\n            cases: { name: \"cases\", inOptions: true, defaultValue: [] },\n        },\n        inputs: {\n            values: {\n                selection: { name: \"case\" },\n            },\n        },\n        validation(gltfBlock) {\n            if (gltfBlock.configuration && gltfBlock.configuration.cases) {\n                const cases = gltfBlock.configuration.cases.value;\n                const onlyIntegers = cases.every((caseValue) => {\n                    // case value should be an integer. Since Number.isInteger(1.0) is true, we need to check if toString has only digits.\n                    return typeof caseValue === \"number\" && /^-?\\d+$/.test(caseValue.toString());\n                });\n                if (!onlyIntegers) {\n                    Logger.Warn(\"Switch cases should be integers. Using empty array instead.\");\n                    gltfBlock.configuration.cases.value = [] as number[];\n                    return { valid: true };\n                }\n                // check for duplicates\n                const uniqueCases = new Set(cases);\n                gltfBlock.configuration.cases.value = Array.from(uniqueCases) as number[];\n            }\n            return { valid: true };\n        },\n        extraProcessor(_gltfBlock, _declaration, _mapping, _arrays, serializedObjects) {\n            const serializedObject = serializedObjects[0];\n            serializedObject.dataInputs.forEach((input) => {\n                if (input.name !== \"default\" && input.name !== \"case\") {\n                    input.name = \"in_\" + input.name;\n                }\n            });\n            serializedObject.config ||= {};\n            serializedObject.config.treatCasesAsIntegers = true;\n            return serializedObjects;\n        },\n    },\n    \"debug/log\": {\n        blocks: [FlowGraphBlockNames.ConsoleLog],\n        configuration: {\n            message: { name: \"messageTemplate\", inOptions: true },\n        },\n    },\n};\n\nfunction getSimpleInputMapping(type: FlowGraphBlockNames, inputs: string[] = [\"a\"], inferType?: boolean): IGLTFToFlowGraphMapping {\n    return {\n        blocks: [type],\n        inputs: {\n            values: inputs.reduce(\n                (acc, input) => {\n                    acc[input] = { name: input };\n                    return acc;\n                },\n                {} as { [key: string]: { name: string } }\n            ),\n        },\n        outputs: {\n            values: {\n                value: { name: \"value\" },\n            },\n        },\n        extraProcessor(gltfBlock, _declaration, _mapping, _parser, serializedObjects) {\n            if (inferType) {\n                // configure it to work the way glTF specifies\n                serializedObjects[0].config ||= {};\n                serializedObjects[0].config.preventIntegerFloatArithmetic = true;\n                // try to infer the type or fallback to Integer\n                // check the gltf block for the inputs, see if they have a type\n                let type = -1;\n                Object.keys(gltfBlock.values || {}).find((value) => {\n                    if (gltfBlock.values?.[value].type !== undefined) {\n                        type = gltfBlock.values[value].type;\n                        return true;\n                    }\n                    return false;\n                });\n                if (type !== -1) {\n                    serializedObjects[0].config.type = _parser.arrays.types[type].flowGraphType;\n                }\n            }\n            return serializedObjects;\n        },\n        validation(gltfBlock) {\n            if (inferType) {\n                // make sure types are the same\n                return ValidateTypes(gltfBlock);\n            }\n            return { valid: true };\n        },\n    };\n}\n\nfunction ValidateTypes(gltfBlock: IKHRInteractivity_Node): { valid: boolean; error?: string } {\n    if (gltfBlock.values) {\n        const types = Object.keys(gltfBlock.values)\n            .map((key) => gltfBlock.values![key].type)\n            .filter((type) => type !== undefined);\n        const allSameType = types.every((type) => type === types[0]);\n        if (!allSameType) {\n            return { valid: false, error: \"All inputs must be of the same type\" };\n        }\n    }\n    return { valid: true };\n}\n\nexport function getAllSupportedNativeNodeTypes(): string[] {\n    return Object.keys(gltfToFlowGraphMapping);\n}\n\n/**\n * \n * These are the nodes from the specs:\n\n### Math Nodes\n1. **Constants**\n   - E (`math/E`) FlowGraphBlockNames.E\n   - Pi (`math/Pi`) FlowGraphBlockNames.PI\n   - Infinity (`math/Inf`) FlowGraphBlockNames.Inf\n   - Not a Number (`math/NaN`) FlowGraphBlockNames.NaN\n2. **Arithmetic Nodes**\n   - Absolute Value (`math/abs`) FlowGraphBlockNames.Abs\n   - Sign (`math/sign`) FlowGraphBlockNames.Sign\n   - Truncate (`math/trunc`) FlowGraphBlockNames.Trunc\n   - Floor (`math/floor`) FlowGraphBlockNames.Floor\n   - Ceil (`math/ceil`) FlowGraphBlockNames.Ceil\n   - Round (`math/round`)  FlowGraphBlockNames.Round\n   - Fraction (`math/fract`) FlowGraphBlockNames.Fract\n   - Negation (`math/neg`) FlowGraphBlockNames.Negation\n   - Addition (`math/add`) FlowGraphBlockNames.Add\n   - Subtraction (`math/sub`) FlowGraphBlockNames.Subtract\n   - Multiplication (`math/mul`) FlowGraphBlockNames.Multiply\n   - Division (`math/div`) FlowGraphBlockNames.Divide\n   - Remainder (`math/rem`) FlowGraphBlockNames.Modulo\n   - Minimum (`math/min`) FlowGraphBlockNames.Min\n   - Maximum (`math/max`) FlowGraphBlockNames.Max\n   - Clamp (`math/clamp`) FlowGraphBlockNames.Clamp\n   - Saturate (`math/saturate`) FlowGraphBlockNames.Saturate\n   - Interpolate (`math/mix`) FlowGraphBlockNames.MathInterpolation\n3. **Comparison Nodes**\n   - Equality (`math/eq`) FlowGraphBlockNames.Equality\n   - Less Than (`math/lt`) FlowGraphBlockNames.LessThan\n   - Less Than Or Equal To (`math/le`) FlowGraphBlockNames.LessThanOrEqual\n   - Greater Than (`math/gt`) FlowGraphBlockNames.GreaterThan\n   - Greater Than Or Equal To (`math/ge`) FlowGraphBlockNames.GreaterThanOrEqual\n4. **Special Nodes**\n   - Is Not a Number (`math/isNaN`) FlowGraphBlockNames.IsNaN\n   - Is Infinity (`math/isInf`) FlowGraphBlockNames.IsInfinity\n   - Select (`math/select`) FlowGraphBlockNames.Conditional\n   - Switch (`math/switch`) FlowGraphBlockNames.DataSwitch\n   - Random (`math/random`) FlowGraphBlockNames.Random\n5. **Angle and Trigonometry Nodes**\n   - Degrees-To-Radians (`math/rad`) FlowGraphBlockNames.DegToRad\n   - Radians-To-Degrees (`math/deg`) FlowGraphBlockNames.RadToDeg\n   - Sine (`math/sin`)  FlowGraphBlockNames.Sin\n   - Cosine (`math/cos`) FlowGraphBlockNames.Cos\n   - Tangent (`math/tan`) FlowGraphBlockNames.Tan\n   - Arcsine (`math/asin`) FlowGraphBlockNames.Asin\n   - Arccosine (`math/acos`) FlowGraphBlockNames.Acos\n   - Arctangent (`math/atan`) FlowGraphBlockNames.Atan\n   - Arctangent 2 (`math/atan2`) FlowGraphBlockNames.Atan2\n6. **Hyperbolic Nodes**\n   - Hyperbolic Sine (`math/sinh`) FlowGraphBlockNames.Sinh\n   - Hyperbolic Cosine (`math/cosh`) FlowGraphBlockNames.Cosh\n   - Hyperbolic Tangent (`math/tanh`) FlowGraphBlockNames.Tanh\n   - Inverse Hyperbolic Sine (`math/asinh`) FlowGraphBlockNames.Asinh\n   - Inverse Hyperbolic Cosine (`math/acosh`) FlowGraphBlockNames.Acosh\n   - Inverse Hyperbolic Tangent (`math/atanh`) FlowGraphBlockNames.Atanh\n7. **Exponential Nodes**\n   - Exponent (`math/exp`) FlowGraphBlockNames.Exponential\n   - Natural Logarithm (`math/log`) FlowGraphBlockNames.Log\n   - Base-2 Logarithm (`math/log2`) FlowGraphBlockNames.Log2\n   - Base-10 Logarithm (`math/log10`) FlowGraphBlockNames.Log10\n   - Square Root (`math/sqrt`) FlowGraphBlockNames.SquareRoot\n   - Cube Root (`math/cbrt`) FlowGraphBlockNames.CubeRoot\n   - Power (`math/pow`) FlowGraphBlockNames.Power\n8. **Vector Nodes**\n   - Length (`math/length`) FlowGraphBlockNames.Length\n   - Normalize (`math/normalize`) FlowGraphBlockNames.Normalize\n   - Dot Product (`math/dot`) FlowGraphBlockNames.Dot\n   - Cross Product (`math/cross`) FlowGraphBlockNames.Cross\n   - Rotate 2D (`math/rotate2D`) FlowGraphBlockNames.Rotate2D\n   - Rotate 3D (`math/rotate3D`) FlowGraphBlockNames.Rotate3D\n   - Transform (`math/transform`) FlowGraphBlockNames.TransformVector\n9. **Matrix Nodes**\n   - Transpose (`math/transpose`) FlowGraphBlockNames.Transpose\n   - Determinant (`math/determinant`) FlowGraphBlockNames.Determinant\n   - Inverse (`math/inverse`) FlowGraphBlockNames.InvertMatrix\n   - Multiplication (`math/matMul`) FlowGraphBlockNames.MatrixMultiplication\n   - Compose (`math/matCompose`) FlowGraphBlockNames.MatrixCompose\n   - Decompose (`math/matDecompose`) FlowGraphBlockNames.MatrixDecompose\n10. **Quaternion Nodes**\n    - Conjugate (`math/quatConjugate`) FlowGraphBlockNames.Conjugate\n    - Multiplication (`math/quatMul`) FlowGraphBlockNames.Multiply\n    - Angle Between Quaternions (`math/quatAngleBetween`) FlowGraphBlockNames.AngleBetween\n    - Quaternion From Axis Angle (`math/quatFromAxisAngle`) FlowGraphBlockNames.QuaternionFromAxisAngle\n    - Quaternion To Axis Angle (`math/quatToAxisAngle`) FlowGraphBlockNames.QuaternionToAxisAngle\n    - Quaternion From Two Directional Vectors (`math/quatFromDirections`) FlowGraphBlockNames.QuaternionFromDirections\n11. **Swizzle Nodes**\n    - Combine (`math/combine2`, `math/combine3`, `math/combine4`, `math/combine2x2`, `math/combine3x3`, `math/combine4x4`)\n        FlowGraphBlockNames.CombineVector2, FlowGraphBlockNames.CombineVector3, FlowGraphBlockNames.CombineVector4\n        FlowGraphBlockNames.CombineMatrix2D, FlowGraphBlockNames.CombineMatrix3D, FlowGraphBlockNames.CombineMatrix\n    - Extract (`math/extract2`, `math/extract3`, `math/extract4`, `math/extract2x2`, `math/extract3x3`, `math/extract4x4`)\n        FlowGraphBlockNames.ExtractVector2, FlowGraphBlockNames.ExtractVector3, FlowGraphBlockNames.ExtractVector4\n        FlowGraphBlockNames.ExtractMatrix2D, FlowGraphBlockNames.ExtractMatrix3D, FlowGraphBlockNames.ExtractMatrix\n12. **Integer Arithmetic Nodes**\n    - Absolute Value (`math/abs`) FlowGraphBlockNames.Abs\n    - Sign (`math/sign`) FlowGraphBlockNames.Sign\n    - Negation (`math/neg`) FlowGraphBlockNames.Negation\n    - Addition (`math/add`) FlowGraphBlockNames.Add\n    - Subtraction (`math/sub`) FlowGraphBlockNames.Subtract\n    - Multiplication (`math/mul`) FlowGraphBlockNames.Multiply\n    - Division (`math/div`) FlowGraphBlockNames.Divide\n    - Remainder (`math/rem`) FlowGraphBlockNames.Modulo\n    - Minimum (`math/min`) FlowGraphBlockNames.Min\n    - Maximum (`math/max`) FlowGraphBlockNames.Max\n    - Clamp (`math/clamp`) FlowGraphBlockNames.Clamp\n13. **Integer Comparison Nodes**\n    - Equality (`math/eq`) FlowGraphBlockNames.Equality\n    - Less Than (`math/lt`) FlowGraphBlockNames.LessThan\n    - Less Than Or Equal To (`math/le`) FlowGraphBlockNames.LessThanOrEqual\n    - Greater Than (`math/gt`) FlowGraphBlockNames.GreaterThan\n    - Greater Than Or Equal To (`math/ge`) FlowGraphBlockNames.GreaterThanOrEqual\n14. **Integer Bitwise Nodes**\n    - Bitwise NOT (`math/not`) FlowGraphBlockNames.BitwiseNot\n    - Bitwise AND (`math/and`) FlowGraphBlockNames.BitwiseAnd\n    - Bitwise OR (`math/or`) FlowGraphBlockNames.BitwiseOr\n    - Bitwise XOR (`math/xor`) FlowGraphBlockNames.BitwiseXor\n    - Right Shift (`math/asr`) FlowGraphBlockNames.BitwiseRightShift\n    - Left Shift (`math/lsl`) FlowGraphBlockNames.BitwiseLeftShift\n    - Count Leading Zeros (`math/clz`) FlowGraphBlockNames.LeadingZeros\n    - Count Trailing Zeros (`math/ctz`) FlowGraphBlockNames.TrailingZeros\n    - Count One Bits (`math/popcnt`) FlowGraphBlockNames.OneBitsCounter\n15. **Boolean Arithmetic Nodes**\n    - Equality (`math/eq`) FlowGraphBlockNames.Equality\n    - Boolean NOT (`math/not`) FlowGraphBlockNames.BitwiseNot\n    - Boolean AND (`math/and`) FlowGraphBlockNames.BitwiseAnd\n    - Boolean OR (`math/or`) FlowGraphBlockNames.BitwiseOr\n    - Boolean XOR (`math/xor`) FlowGraphBlockNames.BitwiseXor\n\n### Type Conversion Nodes\n1. **Boolean Conversion Nodes**\n   - Boolean to Integer (`type/boolToInt`) FlowGraphBlockNames.BooleanToInt\n   - Boolean to Float (`type/boolToFloat`) FlowGraphBlockNames.BooleanToFloat\n2. **Integer Conversion Nodes**\n   - Integer to Boolean (`type/intToBool`) FlowGraphBlockNames.IntToBoolean\n   - Integer to Float (`type/intToFloat`) FlowGraphBlockNames.IntToFloat\n3. **Float Conversion Nodes**\n   - Float to Boolean (`type/floatToBool`) FlowGraphBlockNames.FloatToBoolean\n   - Float to Integer (`type/floatToInt`) FlowGraphBlockNames.FloatToInt\n\n### Control Flow Nodes\n1. **Sync Nodes**\n   - Sequence (`flow/sequence`) FlowGraphBlockNames.Sequence\n   - Branch (`flow/branch`) FlowGraphBlockNames.Branch\n   - Switch (`flow/switch`) FlowGraphBlockNames.Switch\n   - While Loop (`flow/while`) FlowGraphBlockNames.WhileLoop\n   - For Loop (`flow/for`) FlowGraphBlockNames.ForLoop\n   - Do N (`flow/doN`) FlowGraphBlockNames.DoN\n   - Multi Gate (`flow/multiGate`) FlowGraphBlockNames.MultiGate\n   - Wait All (`flow/waitAll`) FlowGraphBlockNames.WaitAll\n   - Throttle (`flow/throttle`) FlowGraphBlockNames.Throttle\n2. **Delay Nodes**\n   - Set Delay (`flow/setDelay`) FlowGraphBlockNames.SetDelay\n   - Cancel Delay (`flow/cancelDelay`) FlowGraphBlockNames.CancelDelay\n\n### State Manipulation Nodes\n1. **Custom Variable Access**\n   - Variable Get (`variable/get`) FlowGraphBlockNames.GetVariable\n   - Variable Set (`variable/set`) FlowGraphBlockNames.SetVariable\n   - Variable Interpolate (`variable/interpolate`)\n2. **Object Model Access** // TODO fully test this!!!\n   - JSON Pointer Template Parsing (`pointer/get`) [FlowGraphBlockNames.GetProperty, FlowGraphBlockNames.JsonPointerParser]\n   - Effective JSON Pointer Generation (`pointer/set`) [FlowGraphBlockNames.SetProperty, FlowGraphBlockNames.JsonPointerParser]\n   - Pointer Get (`pointer/get`) [FlowGraphBlockNames.GetProperty, FlowGraphBlockNames.JsonPointerParser]\n   - Pointer Set (`pointer/set`) [FlowGraphBlockNames.SetProperty, FlowGraphBlockNames.JsonPointerParser]\n   - Pointer Interpolate (`pointer/interpolate`) [FlowGraphBlockNames.ValueInterpolation, FlowGraphBlockNames.JsonPointerParser, FlowGraphBlockNames.PlayAnimation, FlowGraphBlockNames.Easing]\n\n### Animation Control Nodes\n1. **Animation Play** (`animation/start`) FlowGraphBlockNames.PlayAnimation\n2. **Animation Stop** (`animation/stop`) FlowGraphBlockNames.StopAnimation \n3. **Animation Stop At** (`animation/stopAt`) FlowGraphBlockNames.StopAnimation \n\n### Event Nodes\n1. **Lifecycle Event Nodes**\n   - On Start (`event/onStart`) FlowGraphBlockNames.SceneReadyEvent\n   - On Tick (`event/onTick`) FlowGraphBlockNames.SceneTickEvent\n2. **Custom Event Nodes**\n   - Receive (`event/receive`) FlowGraphBlockNames.ReceiveCustomEvent\n   - Send (`event/send`) FlowGraphBlockNames.SendCustomEvent\n\n */\n","import type { IKHRInteractivity_Graph, IKHRInteractivity_Node, IKHRInteractivity_OutputSocketReference, IKHRInteractivity_Variable } from \"babylonjs-gltf2interface\";\nimport type { IGLTF } from \"../../glTFLoaderInterfaces\";\nimport type { IGLTFToFlowGraphMapping } from \"./declarationMapper\";\nimport { getMappingForDeclaration, getMappingForFullOperationName } from \"./declarationMapper\";\nimport { Logger } from \"core/Misc/logger\";\nimport type { ISerializedFlowGraph, ISerializedFlowGraphBlock, ISerializedFlowGraphConnection, ISerializedFlowGraphContext } from \"core/FlowGraph/typeDefinitions\";\nimport { RandomGUID } from \"core/Misc/guid\";\nimport type { IFlowGraphBlockConfiguration } from \"core/FlowGraph/flowGraphBlock\";\nimport type { FlowGraphBlockNames } from \"core/FlowGraph/Blocks/flowGraphBlockNames\";\nimport { FlowGraphConnectionType } from \"core/FlowGraph/flowGraphConnection\";\nimport { FlowGraphTypes } from \"core/FlowGraph/flowGraphRichTypes\";\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport interface InteractivityEvent {\n    eventId: string;\n    eventData?: {\n        eventData: boolean;\n        id: string;\n        type: string;\n        value?: any;\n    }[];\n}\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const gltfTypeToBabylonType: {\n    [key: string]: { length: number; flowGraphType: FlowGraphTypes; elementType: \"number\" | \"boolean\" };\n} = {\n    float: { length: 1, flowGraphType: FlowGraphTypes.Number, elementType: \"number\" },\n    bool: { length: 1, flowGraphType: FlowGraphTypes.Boolean, elementType: \"boolean\" },\n    float2: { length: 2, flowGraphType: FlowGraphTypes.Vector2, elementType: \"number\" },\n    float3: { length: 3, flowGraphType: FlowGraphTypes.Vector3, elementType: \"number\" },\n    float4: { length: 4, flowGraphType: FlowGraphTypes.Vector4, elementType: \"number\" },\n    float4x4: { length: 16, flowGraphType: FlowGraphTypes.Matrix, elementType: \"number\" },\n    float2x2: { length: 4, flowGraphType: FlowGraphTypes.Matrix2D, elementType: \"number\" },\n    float3x3: { length: 9, flowGraphType: FlowGraphTypes.Matrix3D, elementType: \"number\" },\n    int: { length: 1, flowGraphType: FlowGraphTypes.Integer, elementType: \"number\" },\n};\n\nexport class InteractivityGraphToFlowGraphParser {\n    /**\n     * Note - the graph should be rejected if the same type is defined twice.\n     * We currently don't validate that.\n     */\n    private _types: { length: number; flowGraphType: FlowGraphTypes; elementType: \"number\" | \"boolean\" }[] = [];\n    private _mappings: { flowGraphMapping: IGLTFToFlowGraphMapping; fullOperationName: string }[] = [];\n    private _staticVariables: { type: FlowGraphTypes; value: any[] }[] = [];\n    private _events: InteractivityEvent[] = [];\n    private _internalEventsCounter: number = 0;\n    private _nodes: { blocks: ISerializedFlowGraphBlock[]; fullOperationName: string }[] = [];\n\n    constructor(\n        private _interactivityGraph: IKHRInteractivity_Graph,\n        private _gltf: IGLTF,\n        public _animationTargetFps: number = 60\n    ) {\n        // start with types\n        this._parseTypes();\n        // continue with declarations\n        this._parseDeclarations();\n        this._parseVariables();\n        this._parseEvents();\n        this._parseNodes();\n    }\n\n    public get arrays() {\n        return {\n            types: this._types,\n            mappings: this._mappings,\n            staticVariables: this._staticVariables,\n            events: this._events,\n            nodes: this._nodes,\n        };\n    }\n\n    private _parseTypes() {\n        if (!this._interactivityGraph.types) {\n            return;\n        }\n        for (const type of this._interactivityGraph.types) {\n            this._types.push(gltfTypeToBabylonType[type.signature]);\n        }\n    }\n\n    private _parseDeclarations() {\n        if (!this._interactivityGraph.declarations) {\n            return;\n        }\n        for (const declaration of this._interactivityGraph.declarations) {\n            // make sure we have the mapping for this operation\n            const mapping = getMappingForDeclaration(declaration);\n            // mapping is defined, because we generate an empty mapping if it's not found\n            if (!mapping) {\n                Logger.Error([\"No mapping found for declaration\", declaration]);\n                throw new Error(\"Error parsing declarations\");\n            }\n            this._mappings.push({\n                flowGraphMapping: mapping,\n                fullOperationName: declaration.extension ? declaration.op + \":\" + declaration.extension : declaration.op,\n            });\n        }\n    }\n\n    private _parseVariables() {\n        if (!this._interactivityGraph.variables) {\n            return;\n        }\n        for (const variable of this._interactivityGraph.variables) {\n            const parsed = this._parseVariable(variable);\n            // set the default values here\n            this._staticVariables.push(parsed);\n        }\n    }\n\n    private _parseVariable(variable: IKHRInteractivity_Variable, dataTransform?: (value: any, parser: InteractivityGraphToFlowGraphParser) => any) {\n        const type = this._types[variable.type];\n        if (!type) {\n            Logger.Error([\"No type found for variable\", variable]);\n            throw new Error(\"Error parsing variables\");\n        }\n        if (variable.value) {\n            if (variable.value.length !== type.length) {\n                Logger.Error([\"Invalid value length for variable\", variable, type]);\n                throw new Error(\"Error parsing variables\");\n            }\n        }\n        const value = variable.value || [];\n        if (!value.length) {\n            switch (type.flowGraphType) {\n                case FlowGraphTypes.Boolean:\n                    value.push(false);\n                    break;\n                case FlowGraphTypes.Integer:\n                    value.push(0);\n                    break;\n                case FlowGraphTypes.Number:\n                    value.push(NaN);\n                    break;\n                case FlowGraphTypes.Vector2:\n                    value.push(NaN, NaN);\n                    break;\n                case FlowGraphTypes.Vector3:\n                    value.push(NaN, NaN, NaN);\n                    break;\n                case FlowGraphTypes.Vector4:\n                case FlowGraphTypes.Matrix2D:\n                case FlowGraphTypes.Quaternion:\n                    value.fill(NaN, 0, 4);\n                    break;\n                case FlowGraphTypes.Matrix:\n                    value.fill(NaN, 0, 16);\n                    break;\n                case FlowGraphTypes.Matrix3D:\n                    value.fill(NaN, 0, 9);\n                    break;\n                default:\n                    break;\n            }\n        }\n        // in case of NaN, Infinity, we need to parse the string to the object itself\n        if (type.elementType === \"number\" && typeof value[0] === \"string\") {\n            value[0] = parseFloat(value[0]);\n        }\n        return { type: type.flowGraphType, value: dataTransform ? dataTransform(value, this) : value };\n    }\n\n    private _parseEvents() {\n        if (!this._interactivityGraph.events) {\n            return;\n        }\n        for (const event of this._interactivityGraph.events) {\n            const converted: InteractivityEvent = {\n                eventId: event.id || \"internalEvent_\" + this._internalEventsCounter++,\n            };\n            if (event.values) {\n                converted.eventData = Object.keys(event.values).map((key) => {\n                    const eventValue = event.values?.[key];\n                    if (!eventValue) {\n                        Logger.Error([\"No value found for event key\", key]);\n                        throw new Error(\"Error parsing events\");\n                    }\n                    const type = this._types[eventValue.type];\n                    if (!type) {\n                        Logger.Error([\"No type found for event value\", eventValue]);\n                        throw new Error(\"Error parsing events\");\n                    }\n                    const value = typeof eventValue.value !== \"undefined\" ? this._parseVariable(eventValue) : undefined;\n                    return {\n                        id: key,\n                        type: type.flowGraphType,\n                        eventData: true,\n                        value,\n                    };\n                });\n            }\n            this._events.push(converted);\n        }\n    }\n\n    private _parseNodes() {\n        if (!this._interactivityGraph.nodes) {\n            return;\n        }\n        for (const node of this._interactivityGraph.nodes) {\n            // some validation\n            if (typeof node.declaration !== \"number\") {\n                Logger.Error([\"No declaration found for node\", node]);\n                throw new Error(\"Error parsing nodes\");\n            }\n            const mapping = this._mappings[node.declaration];\n            if (!mapping) {\n                Logger.Error([\"No mapping found for node\", node]);\n                throw new Error(\"Error parsing nodes\");\n            }\n            if (mapping.flowGraphMapping.validation) {\n                const validationResult = mapping.flowGraphMapping.validation(node, this._interactivityGraph, this._gltf);\n                if (!validationResult.valid) {\n                    throw new Error(`Error validating interactivity node ${this._interactivityGraph.declarations?.[node.declaration].op} - ${validationResult.error}`);\n                }\n            }\n            const blocks: ISerializedFlowGraphBlock[] = [];\n            // create block(s) for this node using the mapping\n            for (const blockType of mapping.flowGraphMapping.blocks) {\n                const block = this._getEmptyBlock(blockType, mapping.fullOperationName);\n                this._parseNodeConfiguration(node, block, mapping.flowGraphMapping, blockType);\n                blocks.push(block);\n            }\n            this._nodes.push({ blocks, fullOperationName: mapping.fullOperationName });\n        }\n    }\n\n    private _getEmptyBlock(className: string, type: string): ISerializedFlowGraphBlock {\n        const uniqueId = RandomGUID();\n        const dataInputs: ISerializedFlowGraphConnection[] = [];\n        const dataOutputs: ISerializedFlowGraphConnection[] = [];\n        const signalInputs: ISerializedFlowGraphConnection[] = [];\n        const signalOutputs: ISerializedFlowGraphConnection[] = [];\n        const config: IFlowGraphBlockConfiguration = {};\n        const metadata = {};\n        return {\n            uniqueId,\n            className,\n            dataInputs,\n            dataOutputs,\n            signalInputs,\n            signalOutputs,\n            config,\n            type,\n            metadata,\n        };\n    }\n\n    private _parseNodeConfiguration(node: IKHRInteractivity_Node, block: ISerializedFlowGraphBlock, nodeMapping: IGLTFToFlowGraphMapping, blockType: FlowGraphBlockNames | string) {\n        const configuration = block.config;\n        if (node.configuration) {\n            const keys = Object.keys(node.configuration);\n            for (const key of keys) {\n                const value = node.configuration?.[key];\n                // value is always an array, never a number or string\n                if (!value) {\n                    Logger.Error([\"No value found for node configuration\", key]);\n                    throw new Error(\"Error parsing node configuration\");\n                }\n                const configMapping = nodeMapping.configuration?.[key];\n                const belongsToBlock = configMapping && configMapping.toBlock ? configMapping.toBlock === blockType : nodeMapping.blocks.indexOf(blockType) === 0;\n                if (belongsToBlock) {\n                    // get the right name for the configuration key\n                    const configKey = configMapping?.name || key;\n                    if ((!value || typeof value.value === \"undefined\") && typeof configMapping?.defaultValue !== \"undefined\") {\n                        configuration[configKey] = {\n                            value: configMapping.defaultValue,\n                        };\n                    } else if (value.value.length >= 0) {\n                        // supporting int[] and int/boolean/string\n                        configuration[configKey] = {\n                            value: value.value.length === 1 ? value.value[0] : value.value,\n                        };\n                    } else {\n                        Logger.Warn([\"Invalid value for node configuration\", value]);\n                    }\n                    // make sure we transform the data if needed\n                    if (configMapping && configMapping.dataTransformer) {\n                        configuration[configKey].value = configMapping.dataTransformer([configuration[configKey].value], this)[0];\n                    }\n                }\n            }\n        }\n    }\n\n    private _parseNodeConnections(context: ISerializedFlowGraphContext) {\n        for (let i = 0; i < this._nodes.length; i++) {\n            // get the corresponding gltf node\n            const gltfNode = this._interactivityGraph.nodes?.[i];\n            if (!gltfNode) {\n                // should never happen but let's still check\n                Logger.Error([\"No node found for interactivity node\", this._nodes[i]]);\n                throw new Error(\"Error parsing node connections\");\n            }\n            const flowGraphBlocks = this._nodes[i];\n            const outputMapper = this._mappings[gltfNode.declaration];\n            // validate\n            if (!outputMapper) {\n                Logger.Error([\"No mapping found for node\", gltfNode]);\n                throw new Error(\"Error parsing node connections\");\n            }\n            const flowsFromGLTF = gltfNode.flows || {};\n            const flowsKeys = Object.keys(flowsFromGLTF).sort(); // sorting as some operations require sorted keys\n            // connect the flows\n            for (const flowKey of flowsKeys) {\n                const flow = flowsFromGLTF[flowKey];\n                const flowMapping = outputMapper.flowGraphMapping.outputs?.flows?.[flowKey];\n                const socketOutName = flowMapping?.name || flowKey;\n                // create a serialized socket\n                const socketOut = this._createNewSocketConnection(socketOutName, true);\n                const block = (flowMapping && flowMapping.toBlock && flowGraphBlocks.blocks.find((b) => b.className === flowMapping.toBlock)) || flowGraphBlocks.blocks[0];\n                block.signalOutputs.push(socketOut);\n                // get the input node of this block\n                const inputNodeId = flow.node;\n                const nodeIn = this._nodes[inputNodeId];\n                if (!nodeIn) {\n                    Logger.Error([\"No node found for input node id\", inputNodeId]);\n                    throw new Error(\"Error parsing node connections\");\n                }\n                // get the mapper for the input node - in case it mapped to multiple blocks\n                const inputMapper = getMappingForFullOperationName(nodeIn.fullOperationName);\n                if (!inputMapper) {\n                    Logger.Error([\"No mapping found for input node\", nodeIn]);\n                    throw new Error(\"Error parsing node connections\");\n                }\n                let flowInMapping = inputMapper.inputs?.flows?.[flow.socket || \"in\"];\n                let arrayMapping = false;\n                if (!flowInMapping) {\n                    for (const key in inputMapper.inputs?.flows) {\n                        if (key.startsWith(\"[\") && key.endsWith(\"]\")) {\n                            arrayMapping = true;\n                            flowInMapping = inputMapper.inputs?.flows?.[key];\n                        }\n                    }\n                }\n                const nodeInSocketName = flowInMapping ? (arrayMapping ? flowInMapping.name.replace(\"$1\", flow.socket || \"\") : flowInMapping.name) : flow.socket || \"in\";\n                const inputBlock = (flowInMapping && flowInMapping.toBlock && nodeIn.blocks.find((b) => b.className === flowInMapping.toBlock)) || nodeIn.blocks[0];\n                // in all of the flow graph input connections, find the one with the same name as the socket\n                let socketIn = inputBlock.signalInputs.find((s) => s.name === nodeInSocketName);\n                // if the socket doesn't exist, create the input socket for the connection\n                if (!socketIn) {\n                    socketIn = this._createNewSocketConnection(nodeInSocketName);\n                    inputBlock.signalInputs.push(socketIn);\n                }\n                // connect the sockets\n                socketIn.connectedPointIds.push(socketOut.uniqueId);\n                socketOut.connectedPointIds.push(socketIn.uniqueId);\n            }\n            // connect the values\n            const valuesFromGLTF = gltfNode.values || {};\n            const valuesKeys = Object.keys(valuesFromGLTF);\n            for (const valueKey of valuesKeys) {\n                const value = valuesFromGLTF[valueKey];\n                let valueMapping = outputMapper.flowGraphMapping.inputs?.values?.[valueKey];\n                let arrayMapping = false;\n                if (!valueMapping) {\n                    for (const key in outputMapper.flowGraphMapping.inputs?.values) {\n                        if (key.startsWith(\"[\") && key.endsWith(\"]\")) {\n                            arrayMapping = true;\n                            valueMapping = outputMapper.flowGraphMapping.inputs?.values?.[key];\n                        }\n                    }\n                }\n                const socketInName = valueMapping ? (arrayMapping ? valueMapping.name.replace(\"$1\", valueKey) : valueMapping.name) : valueKey;\n                // create a serialized socket\n                const socketIn = this._createNewSocketConnection(socketInName);\n                const block = (valueMapping && valueMapping.toBlock && flowGraphBlocks.blocks.find((b) => b.className === valueMapping.toBlock)) || flowGraphBlocks.blocks[0];\n                block.dataInputs.push(socketIn);\n                if ((value as IKHRInteractivity_Variable).value !== undefined) {\n                    const convertedValue = this._parseVariable(value as IKHRInteractivity_Variable, valueMapping && valueMapping.dataTransformer);\n                    context._connectionValues[socketIn.uniqueId] = convertedValue;\n                } else if (typeof (value as IKHRInteractivity_OutputSocketReference).node !== \"undefined\") {\n                    const nodeOutId = (value as IKHRInteractivity_OutputSocketReference).node;\n                    const nodeOutSocketName = (value as IKHRInteractivity_OutputSocketReference).socket || \"value\";\n                    const nodeOut = this._nodes[nodeOutId];\n                    if (!nodeOut) {\n                        Logger.Error([\"No node found for output socket reference\", value]);\n                        throw new Error(\"Error parsing node connections\");\n                    }\n                    const outputMapper = getMappingForFullOperationName(nodeOut.fullOperationName);\n                    if (!outputMapper) {\n                        Logger.Error([\"No mapping found for output socket reference\", value]);\n                        throw new Error(\"Error parsing node connections\");\n                    }\n                    let valueMapping = outputMapper.outputs?.values?.[nodeOutSocketName];\n                    let arrayMapping = false;\n                    // check if there is an array mapping defined\n                    if (!valueMapping) {\n                        // search for a value mapping that has an array mapping\n                        for (const key in outputMapper.outputs?.values) {\n                            if (key.startsWith(\"[\") && key.endsWith(\"]\")) {\n                                arrayMapping = true;\n                                valueMapping = outputMapper.outputs?.values?.[key];\n                            }\n                        }\n                    }\n                    const socketOutName = valueMapping ? (arrayMapping ? valueMapping.name.replace(\"$1\", nodeOutSocketName) : valueMapping?.name) : nodeOutSocketName;\n                    const outBlock = (valueMapping && valueMapping.toBlock && nodeOut.blocks.find((b) => b.className === valueMapping.toBlock)) || nodeOut.blocks[0];\n                    let socketOut = outBlock.dataOutputs.find((s) => s.name === socketOutName);\n                    // if the socket doesn't exist, create it\n                    if (!socketOut) {\n                        socketOut = this._createNewSocketConnection(socketOutName, true);\n                        outBlock.dataOutputs.push(socketOut);\n                    }\n                    // connect the sockets\n                    socketIn.connectedPointIds.push(socketOut.uniqueId);\n                    socketOut.connectedPointIds.push(socketIn.uniqueId);\n                } else {\n                    Logger.Error([\"Invalid value for value connection\", value]);\n                    throw new Error(\"Error parsing node connections\");\n                }\n            }\n\n            // inter block connections\n            if (outputMapper.flowGraphMapping.interBlockConnectors) {\n                for (const connector of outputMapper.flowGraphMapping.interBlockConnectors) {\n                    const input = connector.input;\n                    const output = connector.output;\n                    const isVariable = connector.isVariable;\n                    this._connectFlowGraphNodes(input, output, flowGraphBlocks.blocks[connector.inputBlockIndex], flowGraphBlocks.blocks[connector.outputBlockIndex], isVariable);\n                }\n            }\n\n            if (outputMapper.flowGraphMapping.extraProcessor) {\n                const declaration = this._interactivityGraph.declarations?.[gltfNode.declaration];\n                if (!declaration) {\n                    Logger.Error([\"No declaration found for extra processor\", gltfNode]);\n                    throw new Error(\"Error parsing node connections\");\n                }\n                flowGraphBlocks.blocks = outputMapper.flowGraphMapping.extraProcessor(\n                    gltfNode,\n                    declaration,\n                    outputMapper.flowGraphMapping,\n                    this,\n                    flowGraphBlocks.blocks,\n                    context,\n                    this._gltf\n                );\n            }\n        }\n    }\n\n    private _createNewSocketConnection(name: string, isOutput?: boolean): ISerializedFlowGraphConnection {\n        return {\n            uniqueId: RandomGUID(),\n            name,\n            _connectionType: isOutput ? FlowGraphConnectionType.Output : FlowGraphConnectionType.Input,\n            connectedPointIds: [],\n        };\n    }\n\n    private _connectFlowGraphNodes(input: string, output: string, serializedInput: ISerializedFlowGraphBlock, serializedOutput: ISerializedFlowGraphBlock, isVariable?: boolean) {\n        const inputArray = isVariable ? serializedInput.dataInputs : serializedInput.signalInputs;\n        const outputArray = isVariable ? serializedOutput.dataOutputs : serializedOutput.signalOutputs;\n        const inputConnection = inputArray.find((s) => s.name === input) || this._createNewSocketConnection(input);\n        const outputConnection = outputArray.find((s) => s.name === output) || this._createNewSocketConnection(output, true);\n        // of not found add it to the array\n        if (!inputArray.find((s) => s.name === input)) {\n            inputArray.push(inputConnection);\n        }\n        if (!outputArray.find((s) => s.name === output)) {\n            outputArray.push(outputConnection);\n        }\n        // connect the sockets\n        inputConnection.connectedPointIds.push(outputConnection.uniqueId);\n        outputConnection.connectedPointIds.push(inputConnection.uniqueId);\n    }\n\n    public getVariableName(index: number) {\n        return \"staticVariable_\" + index;\n    }\n\n    public serializeToFlowGraph(): ISerializedFlowGraph {\n        const context: ISerializedFlowGraphContext = {\n            uniqueId: RandomGUID(),\n            _userVariables: {},\n            _connectionValues: {},\n        };\n        this._parseNodeConnections(context);\n        for (let i = 0; i < this._staticVariables.length; i++) {\n            const variable = this._staticVariables[i];\n            context._userVariables[this.getVariableName(i)] = variable;\n        }\n\n        const allBlocks = this._nodes.reduce((acc, val) => acc.concat(val.blocks), [] as ISerializedFlowGraphBlock[]);\n\n        return {\n            rightHanded: true,\n            allBlocks,\n            executionContexts: [context],\n        };\n    }\n}\n","/* eslint-disable @typescript-eslint/naming-convention */\r\nimport type { IKHRInteractivity } from \"babylonjs-gltf2interface\";\r\nimport type { GLTFLoader } from \"../glTFLoader\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport { FlowGraphCoordinator } from \"core/FlowGraph/flowGraphCoordinator\";\r\nimport { ParseFlowGraphAsync } from \"core/FlowGraph/flowGraphParser\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\nimport type { GLTFPathToObjectConverter } from \"./gltfPathToObjectConverter\";\r\nimport { AddObjectAccessorToKey, GetPathToObjectConverter } from \"./objectModelMapping\";\r\nimport { InteractivityGraphToFlowGraphParser } from \"./KHR_interactivity/interactivityGraphParser\";\r\nimport { addToBlockFactory } from \"core/FlowGraph/Blocks/flowGraphBlockFactory\";\r\nimport { Quaternion, Vector3 } from \"core/Maths/math.vector\";\r\nimport type { Scene } from \"core/scene\";\r\nimport type { IAnimation } from \"../glTFLoaderInterfaces\";\r\n\r\nconst NAME = \"KHR_interactivity\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the KHR_interactivity extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"KHR_interactivity\"]: {};\r\n    }\r\n}\r\n\r\n/**\r\n * Loader extension for KHR_interactivity\r\n */\r\nexport class KHR_interactivity implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled: boolean;\r\n\r\n    private _pathConverter?: GLTFPathToObjectConverter<any, any, any>;\r\n\r\n    /**\r\n     * @internal\r\n     * @param _loader\r\n     */\r\n    constructor(private _loader: GLTFLoader) {\r\n        this.enabled = this._loader.isExtensionUsed(NAME);\r\n        this._pathConverter = GetPathToObjectConverter(this._loader.gltf);\r\n        // avoid starting animations automatically.\r\n        _loader._skipStartAnimationStep = true;\r\n\r\n        // Update object model with new pointers\r\n\r\n        const scene = _loader.babylonScene;\r\n        if (scene) {\r\n            _AddInteractivityObjectModel(scene);\r\n        }\r\n    }\r\n\r\n    public dispose() {\r\n        (this._loader as any) = null;\r\n        delete this._pathConverter;\r\n    }\r\n\r\n    // eslint-disable-next-line no-restricted-syntax, @typescript-eslint/no-misused-promises\r\n    public async onReady(): Promise<void> {\r\n        if (!this._loader.babylonScene || !this._pathConverter) {\r\n            return;\r\n        }\r\n        const scene = this._loader.babylonScene;\r\n        const interactivityDefinition = this._loader.gltf.extensions?.KHR_interactivity as IKHRInteractivity;\r\n        if (!interactivityDefinition) {\r\n            // This can technically throw, but it's not a critical error\r\n            return;\r\n        }\r\n\r\n        const coordinator = new FlowGraphCoordinator({ scene });\r\n        coordinator.dispatchEventsSynchronously = false; // glTF interactivity dispatches events asynchronously\r\n        const graphs = interactivityDefinition.graphs.map((graph) => {\r\n            const parser = new InteractivityGraphToFlowGraphParser(graph, this._loader.gltf, this._loader.parent.targetFps);\r\n            return parser.serializeToFlowGraph();\r\n        });\r\n        // parse each graph async\r\n        await Promise.all(graphs.map(async (graph) => await ParseFlowGraphAsync(graph, { coordinator, pathConverter: this._pathConverter })));\r\n\r\n        coordinator.start();\r\n    }\r\n}\r\n\r\n/**\r\n * @internal\r\n * populates the object model with the interactivity extension\r\n */\r\nexport function _AddInteractivityObjectModel(scene: Scene) {\r\n    // Note - all of those are read-only, as per the specs!\r\n\r\n    // active camera rotation\r\n    AddObjectAccessorToKey(\"/extensions/KHR_interactivity/?/activeCamera/rotation\", {\r\n        get: () => {\r\n            if (!scene.activeCamera) {\r\n                return new Quaternion(NaN, NaN, NaN, NaN);\r\n            }\r\n            const quat = Quaternion.FromRotationMatrix(scene.activeCamera.getWorldMatrix()).normalize();\r\n            if (!scene.useRightHandedSystem) {\r\n                quat.w *= -1; // glTF uses right-handed system, while babylon uses left-handed\r\n                quat.x *= -1; // glTF uses right-handed system, while babylon uses left-handed\r\n            }\r\n            return quat;\r\n        },\r\n        type: \"Quaternion\",\r\n        getTarget: () => scene.activeCamera,\r\n    });\r\n    // activeCamera position\r\n    AddObjectAccessorToKey(\"/extensions/KHR_interactivity/?/activeCamera/position\", {\r\n        get: () => {\r\n            if (!scene.activeCamera) {\r\n                return new Vector3(NaN, NaN, NaN);\r\n            }\r\n            const pos = scene.activeCamera.getWorldMatrix().getTranslation(); // not global position\r\n            if (!scene.useRightHandedSystem) {\r\n                pos.x *= -1; // glTF uses right-handed system, while babylon uses left-handed\r\n            }\r\n            return pos;\r\n        },\r\n        type: \"Vector3\",\r\n        getTarget: () => scene.activeCamera,\r\n    });\r\n\r\n    // /animations/{} pointers:\r\n    AddObjectAccessorToKey(\"/animations/{}/extensions/KHR_interactivity/isPlaying\", {\r\n        get: (animation: IAnimation) => {\r\n            return animation._babylonAnimationGroup?.isPlaying ?? false;\r\n        },\r\n        type: \"boolean\",\r\n        getTarget: (animation: IAnimation) => {\r\n            return animation._babylonAnimationGroup;\r\n        },\r\n    });\r\n    AddObjectAccessorToKey(\"/animations/{}/extensions/KHR_interactivity/minTime\", {\r\n        get: (animation: IAnimation) => {\r\n            return (animation._babylonAnimationGroup?.from ?? 0) / 60; // fixed factor for duration-to-frames conversion\r\n        },\r\n        type: \"number\",\r\n        getTarget: (animation: IAnimation) => {\r\n            return animation._babylonAnimationGroup;\r\n        },\r\n    });\r\n    AddObjectAccessorToKey(\"/animations/{}/extensions/KHR_interactivity/maxTime\", {\r\n        get: (animation: IAnimation) => {\r\n            return (animation._babylonAnimationGroup?.to ?? 0) / 60; // fixed factor for duration-to-frames conversion\r\n        },\r\n        type: \"number\",\r\n        getTarget: (animation: IAnimation) => {\r\n            return animation._babylonAnimationGroup;\r\n        },\r\n    });\r\n    // playhead\r\n    AddObjectAccessorToKey(\"/animations/{}/extensions/KHR_interactivity/playhead\", {\r\n        get: (animation: IAnimation) => {\r\n            return (animation._babylonAnimationGroup?.getCurrentFrame() ?? 0) / 60; // fixed factor for duration-to-frames conversion\r\n        },\r\n        type: \"number\",\r\n        getTarget: (animation: IAnimation) => {\r\n            return animation._babylonAnimationGroup;\r\n        },\r\n    });\r\n    //virtualPlayhead - TODO, do we support this property in our animations? getCurrentFrame  is the only method we have for this.\r\n    AddObjectAccessorToKey(\"/animations/{}/extensions/KHR_interactivity/virtualPlayhead\", {\r\n        get: (animation: IAnimation) => {\r\n            return (animation._babylonAnimationGroup?.getCurrentFrame() ?? 0) / 60; // fixed factor for duration-to-frames conversion\r\n        },\r\n        type: \"number\",\r\n        getTarget: (animation: IAnimation) => {\r\n            return animation._babylonAnimationGroup;\r\n        },\r\n    });\r\n}\r\n\r\n// Register flow graph blocks. Do it here so they are available when the extension is enabled.\r\naddToBlockFactory(NAME, \"FlowGraphGLTFDataProvider\", async () => {\r\n    return (await import(\"./KHR_interactivity/flowGraphGLTFDataProvider\")).FlowGraphGLTFDataProvider;\r\n});\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, true, (loader) => new KHR_interactivity(loader));\r\n","import type { AbstractMesh } from \"core/Meshes/abstractMesh\";\nimport type { GLTFLoader } from \"../glTFLoader\";\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\nimport type { INode } from \"../glTFLoaderInterfaces\";\nimport { AddObjectAccessorToKey } from \"./objectModelMapping\";\n\nconst NAME = \"KHR_node_visibility\";\n\ndeclare module \"../../glTFFileLoader\" {\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\n    export interface GLTFLoaderExtensionOptions {\n        /**\n         * Defines options for the KHR_node_visibility extension.\n         */\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\n        [\"KHR_node_visibility\"]: {};\n    }\n}\n\n// object model extension for visibility\nAddObjectAccessorToKey(\"/nodes/{}/extensions/KHR_node_visibility/visible\", {\n    get: (node: INode) => {\n        const tn = node._babylonTransformNode as any;\n        if (tn && tn.isVisible !== undefined) {\n            return tn.isVisible;\n        }\n        return true;\n    },\n    set: (value: boolean, node: INode) => {\n        node._primitiveBabylonMeshes?.forEach((mesh) => {\n            mesh.inheritVisibility = true;\n        });\n        if (node._babylonTransformNode) {\n            (node._babylonTransformNode as AbstractMesh).isVisible = value;\n        }\n        node._primitiveBabylonMeshes?.forEach((mesh) => {\n            mesh.isVisible = value;\n        });\n    },\n    getTarget: (node: INode) => node._babylonTransformNode,\n    getPropertyName: [() => \"isVisible\"],\n    type: \"boolean\",\n});\n\n/**\n * Loader extension for KHR_node_visibility\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport class KHR_node_visibility implements IGLTFLoaderExtension {\n    /**\n     * The name of this extension.\n     */\n    public readonly name = NAME;\n    /**\n     * Defines whether this extension is enabled.\n     */\n    public enabled: boolean;\n\n    private _loader: GLTFLoader;\n\n    /**\n     * @internal\n     */\n    constructor(loader: GLTFLoader) {\n        this._loader = loader;\n        this.enabled = loader.isExtensionUsed(NAME);\n    }\n\n    // eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-misused-promises\n    public async onReady(): Promise<void> {\n        this._loader.gltf.nodes?.forEach((node) => {\n            node._primitiveBabylonMeshes?.forEach((mesh) => {\n                mesh.inheritVisibility = true;\n            });\n            // When the JSON Pointer is used we need to change both the transform node and the primitive meshes to the new value.\n            if (node.extensions?.KHR_node_visibility) {\n                if (node.extensions?.KHR_node_visibility.visible === false) {\n                    if (node._babylonTransformNode) {\n                        (node._babylonTransformNode as AbstractMesh).isVisible = false;\n                    }\n                    node._primitiveBabylonMeshes?.forEach((mesh) => {\n                        mesh.isVisible = false;\n                    });\n                }\n            }\n        });\n    }\n\n    public dispose() {\n        (this._loader as any) = null;\n    }\n}\n\nunregisterGLTFExtension(NAME);\nregisterGLTFExtension(NAME, true, (loader) => new KHR_node_visibility(loader));\n","import { FlowGraphBlockNames } from \"core/FlowGraph/Blocks/flowGraphBlockNames\";\nimport type { GLTFLoader } from \"../glTFLoader\";\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\nimport { addNewInteractivityFlowGraphMapping } from \"./KHR_interactivity/declarationMapper\";\nimport type { INode } from \"../glTFLoaderInterfaces\";\nimport { AddObjectAccessorToKey } from \"./objectModelMapping\";\n\nconst NAME = \"KHR_node_selectability\";\n\ndeclare module \"../../glTFFileLoader\" {\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\n    export interface GLTFLoaderExtensionOptions {\n        /**\n         * Defines options for the KHR_selectability extension.\n         */\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\n        [\"KHR_node_selectability\"]: {};\n    }\n}\n\n// add the interactivity mapping for the onSelect event\naddNewInteractivityFlowGraphMapping(\"event/onSelect\", NAME, {\n    // using GetVariable as the nodeIndex is a configuration and not a value (i.e. it's not mutable)\n    blocks: [FlowGraphBlockNames.MeshPickEvent, FlowGraphBlockNames.GetVariable, FlowGraphBlockNames.IndexOf, \"KHR_interactivity/FlowGraphGLTFDataProvider\"],\n    configuration: {\n        stopPropagation: { name: \"stopPropagation\" },\n        nodeIndex: {\n            name: \"variable\",\n            toBlock: FlowGraphBlockNames.GetVariable,\n            dataTransformer(data) {\n                return [\"pickedMesh_\" + data[0]];\n            },\n        },\n    },\n    outputs: {\n        values: {\n            selectedNodeIndex: { name: \"index\", toBlock: FlowGraphBlockNames.IndexOf },\n            controllerIndex: { name: \"pointerId\" },\n            selectionPoint: { name: \"pickedPoint\" },\n            selectionRayOrigin: { name: \"pickOrigin\" },\n        },\n        flows: {\n            out: { name: \"done\" },\n        },\n    },\n    interBlockConnectors: [\n        {\n            input: \"asset\",\n            output: \"value\",\n            inputBlockIndex: 0,\n            outputBlockIndex: 1,\n            isVariable: true,\n        },\n        {\n            input: \"array\",\n            output: \"nodes\",\n            inputBlockIndex: 2,\n            outputBlockIndex: 3,\n            isVariable: true,\n        },\n        {\n            input: \"object\",\n            output: \"pickedMesh\",\n            inputBlockIndex: 2,\n            outputBlockIndex: 0,\n            isVariable: true,\n        },\n    ],\n    extraProcessor(gltfBlock, _declaration, _mapping, _arrays, serializedObjects, context, globalGLTF) {\n        // add the glTF to the configuration of the last serialized object\n        const serializedObject = serializedObjects[serializedObjects.length - 1];\n        serializedObject.config = serializedObject.config || {};\n        serializedObject.config.glTF = globalGLTF;\n        // find the listener nodeIndex value\n        const nodeIndex = gltfBlock.configuration?.[\"nodeIndex\"]?.value[0];\n        if (nodeIndex === undefined || typeof nodeIndex !== \"number\") {\n            throw new Error(\"nodeIndex not found in configuration\");\n        }\n        const variableName = \"pickedMesh_\" + nodeIndex;\n        // find the nodeIndex value\n        serializedObjects[1].config.variable = variableName;\n        context._userVariables[variableName] = {\n            className: \"Mesh\",\n            id: globalGLTF?.nodes?.[nodeIndex]._babylonTransformNode?.id,\n            uniqueId: globalGLTF?.nodes?.[nodeIndex]._babylonTransformNode?.uniqueId,\n        };\n        return serializedObjects;\n    },\n});\n\n// object model extension for selectable\nAddObjectAccessorToKey(\"/nodes/{}/extensions/KHR_node_selectability/selectable\", {\n    get: (node: INode) => {\n        const tn = node._babylonTransformNode as any;\n        if (tn && tn.isPickable !== undefined) {\n            return tn.isPickable;\n        }\n        return true;\n    },\n    set: (value: boolean, node: INode) => {\n        node._primitiveBabylonMeshes?.forEach((mesh) => {\n            mesh.isPickable = value;\n        });\n    },\n    getTarget: (node: INode) => node._babylonTransformNode,\n    getPropertyName: [() => \"isPickable\"],\n    type: \"boolean\",\n});\n\n/**\n * Loader extension for KHR_selectability\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport class KHR_node_selectability implements IGLTFLoaderExtension {\n    /**\n     * The name of this extension.\n     */\n    public readonly name = NAME;\n    /**\n     * Defines whether this extension is enabled.\n     */\n    public enabled: boolean;\n\n    private _loader: GLTFLoader;\n\n    /**\n     * @internal\n     */\n    constructor(loader: GLTFLoader) {\n        this._loader = loader;\n        this.enabled = loader.isExtensionUsed(NAME);\n    }\n\n    // eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-misused-promises\n    public async onReady(): Promise<void> {\n        this._loader.gltf.nodes?.forEach((node) => {\n            if (node.extensions?.KHR_node_selectability && node.extensions?.KHR_node_selectability.selectable === false) {\n                node._babylonTransformNode?.getChildMeshes().forEach((mesh) => {\n                    mesh.isPickable = false;\n                });\n            }\n        });\n    }\n\n    public dispose() {\n        (this._loader as any) = null;\n    }\n}\n\nunregisterGLTFExtension(NAME);\nregisterGLTFExtension(NAME, true, (loader) => new KHR_node_selectability(loader));\n","import { FlowGraphBlockNames } from \"core/FlowGraph/Blocks/flowGraphBlockNames\";\nimport type { GLTFLoader } from \"../glTFLoader\";\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\nimport { addNewInteractivityFlowGraphMapping } from \"./KHR_interactivity/declarationMapper\";\nimport type { INode } from \"../glTFLoaderInterfaces\";\nimport { AddObjectAccessorToKey } from \"./objectModelMapping\";\n\nconst NAME = \"KHR_node_hoverability\";\n\ndeclare module \"../../glTFFileLoader\" {\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\n    export interface GLTFLoaderExtensionOptions {\n        /**\n         * Defines options for the KHR_node_hoverability extension.\n         */\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\n        [\"KHR_node_hoverability\"]: {};\n    }\n}\n\n// interactivity\nconst MeshPointerOverPrefix = \"targetMeshPointerOver_\";\naddNewInteractivityFlowGraphMapping(\"event/onHoverIn\", NAME, {\n    // using GetVariable as the nodeIndex is a configuration and not a value (i.e. it's not mutable)\n    blocks: [FlowGraphBlockNames.PointerOverEvent, FlowGraphBlockNames.GetVariable, FlowGraphBlockNames.IndexOf, \"KHR_interactivity/FlowGraphGLTFDataProvider\"],\n    configuration: {\n        stopPropagation: { name: \"stopPropagation\" },\n        nodeIndex: {\n            name: \"variable\",\n            toBlock: FlowGraphBlockNames.GetVariable,\n            dataTransformer(data) {\n                return [MeshPointerOverPrefix + data[0]];\n            },\n        },\n    },\n    outputs: {\n        values: {\n            hoverNodeIndex: { name: \"index\", toBlock: FlowGraphBlockNames.IndexOf },\n            controllerIndex: { name: \"pointerId\" },\n        },\n        flows: {\n            out: { name: \"done\" },\n        },\n    },\n    interBlockConnectors: [\n        {\n            input: \"targetMesh\",\n            output: \"value\",\n            inputBlockIndex: 0,\n            outputBlockIndex: 1,\n            isVariable: true,\n        },\n        {\n            input: \"array\",\n            output: \"nodes\",\n            inputBlockIndex: 2,\n            outputBlockIndex: 3,\n            isVariable: true,\n        },\n        {\n            input: \"object\",\n            output: \"meshUnderPointer\",\n            inputBlockIndex: 2,\n            outputBlockIndex: 0,\n            isVariable: true,\n        },\n    ],\n    extraProcessor(gltfBlock, _declaration, _mapping, _arrays, serializedObjects, context, globalGLTF) {\n        // add the glTF to the configuration of the last serialized object\n        const serializedObject = serializedObjects[serializedObjects.length - 1];\n        serializedObject.config = serializedObject.config || {};\n        serializedObject.config.glTF = globalGLTF;\n        // find the listener nodeIndex value\n        const nodeIndex = gltfBlock.configuration?.[\"nodeIndex\"]?.value[0];\n        if (nodeIndex === undefined || typeof nodeIndex !== \"number\") {\n            throw new Error(\"nodeIndex not found in configuration\");\n        }\n        const variableName = MeshPointerOverPrefix + nodeIndex;\n        // find the nodeIndex value\n        serializedObjects[1].config.variable = variableName;\n        context._userVariables[variableName] = {\n            className: \"Mesh\",\n            id: globalGLTF?.nodes?.[nodeIndex]._babylonTransformNode?.id,\n            uniqueId: globalGLTF?.nodes?.[nodeIndex]._babylonTransformNode?.uniqueId,\n        };\n        return serializedObjects;\n    },\n});\n\nconst MeshPointerOutPrefix = \"targetMeshPointerOut_\";\naddNewInteractivityFlowGraphMapping(\"event/onHoverOut\", NAME, {\n    // using GetVariable as the nodeIndex is a configuration and not a value (i.e. it's not mutable)\n    blocks: [FlowGraphBlockNames.PointerOutEvent, FlowGraphBlockNames.GetVariable, FlowGraphBlockNames.IndexOf, \"KHR_interactivity/FlowGraphGLTFDataProvider\"],\n    configuration: {\n        stopPropagation: { name: \"stopPropagation\" },\n        nodeIndex: {\n            name: \"variable\",\n            toBlock: FlowGraphBlockNames.GetVariable,\n            dataTransformer(data) {\n                return [MeshPointerOutPrefix + data[0]];\n            },\n        },\n    },\n    outputs: {\n        values: {\n            hoverNodeIndex: { name: \"index\", toBlock: FlowGraphBlockNames.IndexOf },\n            controllerIndex: { name: \"pointerId\" },\n        },\n        flows: {\n            out: { name: \"done\" },\n        },\n    },\n    interBlockConnectors: [\n        {\n            input: \"targetMesh\",\n            output: \"value\",\n            inputBlockIndex: 0,\n            outputBlockIndex: 1,\n            isVariable: true,\n        },\n        {\n            input: \"array\",\n            output: \"nodes\",\n            inputBlockIndex: 2,\n            outputBlockIndex: 3,\n            isVariable: true,\n        },\n        {\n            input: \"object\",\n            output: \"meshOutOfPointer\",\n            inputBlockIndex: 2,\n            outputBlockIndex: 0,\n            isVariable: true,\n        },\n    ],\n    extraProcessor(gltfBlock, _declaration, _mapping, _arrays, serializedObjects, context, globalGLTF) {\n        // add the glTF to the configuration of the last serialized object\n        const serializedObject = serializedObjects[serializedObjects.length - 1];\n        serializedObject.config = serializedObject.config || {};\n        serializedObject.config.glTF = globalGLTF;\n\n        const nodeIndex = gltfBlock.configuration?.[\"nodeIndex\"]?.value[0];\n        if (nodeIndex === undefined || typeof nodeIndex !== \"number\") {\n            throw new Error(\"nodeIndex not found in configuration\");\n        }\n        const variableName = MeshPointerOutPrefix + nodeIndex;\n        // find the nodeIndex value\n        serializedObjects[1].config.variable = variableName;\n        context._userVariables[variableName] = {\n            className: \"Mesh\",\n            id: globalGLTF?.nodes?.[nodeIndex]._babylonTransformNode?.id,\n            uniqueId: globalGLTF?.nodes?.[nodeIndex]._babylonTransformNode?.uniqueId,\n        };\n        return serializedObjects;\n    },\n});\n\nAddObjectAccessorToKey(\"/nodes/{}/extensions/KHR_node_hoverability/hoverable\", {\n    get: (node: INode) => {\n        const tn = node._babylonTransformNode as any;\n        if (tn && tn.pointerOverDisableMeshTesting !== undefined) {\n            return tn.pointerOverDisableMeshTesting;\n        }\n        return true;\n    },\n    set: (value: boolean, node: INode) => {\n        node._primitiveBabylonMeshes?.forEach((mesh) => {\n            mesh.pointerOverDisableMeshTesting = !value;\n        });\n    },\n    getTarget: (node: INode) => node._babylonTransformNode,\n    getPropertyName: [() => \"pointerOverDisableMeshTesting\"],\n    type: \"boolean\",\n});\n\n/**\n * Loader extension for KHR_node_hoverability\n * @see https://github.com/KhronosGroup/glTF/pull/2426\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport class KHR_node_hoverability implements IGLTFLoaderExtension {\n    /**\n     * The name of this extension.\n     */\n    public readonly name = NAME;\n    /**\n     * Defines whether this extension is enabled.\n     */\n    public enabled: boolean;\n\n    private _loader: GLTFLoader;\n\n    /**\n     * @internal\n     */\n    constructor(loader: GLTFLoader) {\n        this._loader = loader;\n        this.enabled = loader.isExtensionUsed(NAME);\n    }\n\n    // eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-misused-promises\n    public async onReady(): Promise<void> {\n        this._loader.gltf.nodes?.forEach((node) => {\n            // default is true, so only apply if false\n            if (node.extensions?.KHR_node_hoverability && node.extensions?.KHR_node_hoverability.hoverable === false) {\n                node._babylonTransformNode?.getChildMeshes().forEach((mesh) => {\n                    mesh.pointerOverDisableMeshTesting = true;\n                });\n            }\n        });\n    }\n\n    public dispose() {\n        (this._loader as any) = null;\n    }\n}\n\nunregisterGLTFExtension(NAME);\nregisterGLTFExtension(NAME, true, (loader) => new KHR_node_hoverability(loader));\n","import type { Nullable } from \"core/types\";\r\nimport type { TransformNode } from \"core/Meshes/transformNode\";\r\nimport type { Camera } from \"core/Cameras/camera\";\r\n\r\nimport type { IProperty } from \"babylonjs-gltf2interface\";\r\nimport type { INode, ICamera, IMaterial } from \"../glTFLoaderInterfaces\";\r\nimport type { IGLTFLoaderExtension } from \"../glTFLoaderExtension\";\r\nimport type { GLTFLoader } from \"../glTFLoader\";\r\nimport type { Material } from \"core/Materials/material\";\r\nimport { registerGLTFExtension, unregisterGLTFExtension } from \"../glTFLoaderExtensionRegistry\";\r\n\r\nconst NAME = \"ExtrasAsMetadata\";\r\n\r\ndeclare module \"../../glTFFileLoader\" {\r\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/naming-convention\r\n    export interface GLTFLoaderExtensionOptions {\r\n        /**\r\n         * Defines options for the ExtrasAsMetadata extension.\r\n         */\r\n        // NOTE: Don't use NAME here as it will break the UMD type declarations.\r\n        [\"ExtrasAsMetadata\"]: {};\r\n    }\r\n}\r\n\r\ninterface IObjectWithMetadata {\r\n    metadata: any;\r\n}\r\n\r\n/**\r\n * Store glTF extras (if present) in BJS objects' metadata\r\n */\r\nexport class ExtrasAsMetadata implements IGLTFLoaderExtension {\r\n    /**\r\n     * The name of this extension.\r\n     */\r\n    public readonly name = NAME;\r\n\r\n    /**\r\n     * Defines whether this extension is enabled.\r\n     */\r\n    public enabled = true;\r\n\r\n    private _loader: GLTFLoader;\r\n\r\n    private _assignExtras(babylonObject: IObjectWithMetadata, gltfProp: IProperty): void {\r\n        if (gltfProp.extras && Object.keys(gltfProp.extras).length > 0) {\r\n            const metadata = (babylonObject.metadata = babylonObject.metadata || {});\r\n            const gltf = (metadata.gltf = metadata.gltf || {});\r\n            gltf.extras = gltfProp.extras;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public constructor(loader: GLTFLoader) {\r\n        this._loader = loader;\r\n    }\r\n\r\n    /** @internal */\r\n    public dispose(): void {\r\n        (this._loader as any) = null;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadNodeAsync(context: string, node: INode, assign: (babylonTransformNode: TransformNode) => void): Nullable<Promise<TransformNode>> {\r\n        return this._loader.loadNodeAsync(context, node, (babylonTransformNode): void => {\r\n            this._assignExtras(babylonTransformNode, node);\r\n            assign(babylonTransformNode);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    public loadCameraAsync(context: string, camera: ICamera, assign: (babylonCamera: Camera) => void): Nullable<Promise<Camera>> {\r\n        return this._loader.loadCameraAsync(context, camera, (babylonCamera): void => {\r\n            this._assignExtras(babylonCamera, camera);\r\n            assign(babylonCamera);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public createMaterial(context: string, material: IMaterial, babylonDrawMode: number): Nullable<Material> {\r\n        const babylonMaterial = this._loader.createMaterial(context, material, babylonDrawMode);\r\n        this._assignExtras(babylonMaterial, material);\r\n        return babylonMaterial;\r\n    }\r\n}\r\n\r\nunregisterGLTFExtension(NAME);\r\nregisterGLTFExtension(NAME, false, (loader) => new ExtrasAsMetadata(loader));\r\n","/* eslint-disable @typescript-eslint/no-restricted-imports */\r\nimport * as Extensions from \"loaders/glTF/2.0/Extensions/index\";\r\nimport * as Interfaces from \"loaders/glTF/2.0/glTFLoaderInterfaces\";\r\nimport * as GLTF2 from \"loaders/glTF/2.0/index\";\r\n\r\n/**\r\n * This is the entry point for the UMD module.\r\n * The entry point for a future ESM package should be index.ts\r\n */\r\nconst GlobalObject = typeof global !== \"undefined\" ? global : typeof window !== \"undefined\" ? window : undefined;\r\nif (typeof GlobalObject !== \"undefined\") {\r\n    (<any>GlobalObject).BABYLON = (<any>GlobalObject).BABYLON || {};\r\n    // eslint-disable-next-line @typescript-eslint/naming-convention\r\n    const BABYLON = (<any>GlobalObject).BABYLON;\r\n    BABYLON.GLTF2 = BABYLON.GLTF2 || {};\r\n    BABYLON.GLTF2.Loader = BABYLON.GLTF2.Loader || {};\r\n    BABYLON.GLTF2.Loader.Extensions = BABYLON.GLTF2.Loader.Extensions || {};\r\n\r\n    const keys = [];\r\n    for (const key in Extensions) {\r\n        BABYLON.GLTF2.Loader.Extensions[key] = (<any>Extensions)[key];\r\n        keys.push(key);\r\n    }\r\n    for (const key in Interfaces) {\r\n        BABYLON.GLTF2.Loader[key] = (<any>Interfaces)[key];\r\n        keys.push(key);\r\n    }\r\n\r\n    for (const key in GLTF2) {\r\n        // Prevent Reassignment.\r\n        if (keys.indexOf(key) > -1) {\r\n            continue;\r\n        }\r\n\r\n        BABYLON.GLTF2[key] = (<any>GLTF2)[key];\r\n    }\r\n}\r\n\r\nexport { GLTF2 };\r\n","import * as loaders from \"@lts/loaders/legacy/legacy-glTF2FileLoader\";\r\nexport { loaders };\r\nexport default loaders;\r\n"],"names":["root","factory","exports","module","require","define","amd","self","global","this","__WEBPACK_EXTERNAL_MODULE__597__","leafPrototypes","getProto","config","glTF","animationGroups","animations","map","a","_babylonAnimationGroup","registerDataOutput","RichTypeAny","nodes","n","_babylonTransformNode","getClassName","FlowGraphBlock","extendStatics","d","b","Object","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","call","__extends","TypeError","String","__","constructor","create","__assign","assign","t","s","i","arguments","length","apply","__awaiter","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","value","step","next","e","rejected","result","done","then","__generator","body","f","y","_","label","sent","trys","ops","g","Iterator","verb","Symbol","iterator","v","op","pop","push","SuppressedError","OptionalPathExceptionsList","regex","RegExp","_gltf","_infoTree","convert","path","objectTree","infoTree","target","undefined","startsWith","Error","parts","split","shift","includes","ignoreObjectTree","part","isLength","__array__","__ignoreObjectTree__","find","test","__target__","object","info","GetTexture","material","payload","textureType","textureInObject","babylonMaterial","GetMaterial","_index","_data","fillMode","Constants","MATERIAL_TriangleFillMode","GenerateTextureMap","offset","componentsCount","type","get","texture","Vector2","uOffset","vOffset","getTarget","set","x","getPropertyName","rotation","wAng","scale","uScale","vScale","index","objectModelMapping","cameras","orthographic","xmag","camera","_babylonCamera","orthoLeft","orthoRight","ymag","orthoBottom","orthoTop","zfar","maxZ","znear","minZ","perspective","aspectRatio","getEngine","getAspectRatio","isReadOnly","yfov","fov","node","translation","position","copyFrom","rotationQuaternion","scaling","weights","_numMorphTargets","_primitiveBabylonMeshes","morphTargetManager","influence","matrix","Matrix","Compose","globalMatrix","Identity","rootNode","parent","forceUpdate","_isDirty","rootMatrix","computeWorldMatrix","invert","multiplyToRef","extensions","EXT_lights_ies","multiplier","getChildren","child","SpotLight","intensity","light","color","diffuse","materials","emissiveFactor","emissiveColor","emissiveTexture","KHR_texture_transform","normalTexture","level","occlusionTexture","strength","ambientTextureStrength","mat","pbrMetallicRoughness","baseColorFactor","Color4","FromColor3","albedoColor","alpha","r","baseColorTexture","metallicFactor","metallic","roughnessFactor","roughness","metallicRoughnessTexture","KHR_materials_anisotropy","anisotropyStrength","anisotropy","anisotropyRotation","angle","anisotropyTexture","KHR_materials_clearcoat","clearcoatFactor","clearCoat","clearcoatRoughnessFactor","clearcoatTexture","clearcoatNormalTexture","bumpTexture","clearcoatRoughnessTexture","KHR_materials_dispersion","dispersion","subSurface","KHR_materials_emissive_strength","emissiveStrength","emissiveIntensity","KHR_materials_ior","ior","indexOfRefraction","KHR_materials_iridescence","iridescenceFactor","iridescence","iridescenceIor","iridescenceTexture","iridescenceThicknessMaximum","maximumThickness","iridescenceThicknessMinimum","minimumThickness","iridescenceThicknessTexture","KHR_materials_sheen","sheenColorFactor","sheen","sheenColorTexture","sheenRoughnessFactor","sheenRoughnessTexture","KHR_materials_specular","specularFactor","metallicF0Factor","specularColorFactor","metallicReflectanceColor","specularTexture","specularColorTexture","KHR_materials_transmission","transmissionFactor","refractionIntensity","transmissionTexture","KHR_materials_diffuse_transmission","diffuseTransmissionFactor","translucencyIntensity","diffuseTransmissionTexture","diffuseTransmissionColorFactor","translucencyColor","diffuseTransmissionColorTexture","KHR_materials_volume","attenuationColor","tintColor","attenuationDistance","tintColorAtDistance","thicknessFactor","thicknessTexture","KHR_lights_punctual","lights","_babylonLight","_lights","_light","range","spot","innerConeAngle","innerAngle","outerConeAngle","EXT_lights_image_based","_babylonTexture","Quaternion","FromRotationMatrix","getReflectionTextureMatrix","getScene","useRightHandedSystem","Inverse","FromQuaternionToRef","animation","meshes","mesh","primitives","_instanceData","babylonSourceMesh","GetPathToObjectConverter","gltf","GLTFPathToObjectConverter","GetMappingForKey","key","keyParts","replace","current","SetInterpolationForKey","interpolation","AddObjectAccessorToKey","accessor","getVector3","_target","source","Vector3","FromArray","scaleInPlace","getQuaternion","getWeights","name","getValue","getStride","_buildAnimation","fps","keys","babylonAnimation","Animation","setKeys","buildAnimations","babylonAnimations","babylonAnimatable","AnimationPropertyInfo","targetIndex","frame","inTangent","outTangent","babylonMesh","morphTarget","babylonAnimationClone","clone","TransformNodeAnimationPropertyInfo","ANIMATIONTYPE_VECTOR3","ANIMATIONTYPE_QUATERNION","WeightAnimationPropertyInfo","ANIMATIONTYPE_FLOAT","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","getter","__esModule","getPrototypeOf","obj","mode","ns","def","indexOf","getOwnPropertyNames","forEach","definition","o","defineProperty","enumerable","globalThis","Function","window","prop","toStringTag","ValidateAsync","data","rootUrl","fileName","getExternalResource","options","externalResourceFunction","uri","ArrayBuffer","isView","GLTFValidator","validateBytes","validateString","WorkerFunc","pendingExternalResources","onmessage","message","id","importScripts","url","postMessage","reason","GLTFLoaderCoordinateSystemMode","GLTFLoaderAnimationStartMode","GLTFLoaderState","Worker","workerContent","workerBlobUrl","URL","createObjectURL","Blob","worker","onError","error","removeEventListener","onMessage","buffer","terminate","addEventListener","Tools","GetBabylonScriptURL","Configuration","slicedData","slice","_LoadScriptPromise","LoadBabylonScriptAsync","_DefaultCdnUrl","GLTFMagicBase64Encoded","GLTFFileLoaderMetadata","isBinary","mimeType","readAsync","arrayBuffer","byteOffset","byteLength","Uint8Array","alwaysComputeBoundingBox","alwaysComputeSkeletonRootNode","animationStartMode","FIRST","compileMaterials","compileShadowGenerators","coordinateSystemMode","AUTO","createInstances","loadAllMaterials","loadMorphTargets","loadNodeAnimations","loadOnlyMaterials","loadSkins","skipMaterials","targetFps","transparencyAsCoverage","useClipPlane","useGltfTextureNames","useRangeRequests","useSRGBBuffers","validate","GLTFLoaderDefaultOptions","GLTFLoaderBaseOptions","onParsedObservable","Observable","onMeshLoadedObservable","onSkinLoadedObservable","onTextureLoadedObservable","onMaterialLoadedObservable","onCameraLoadedObservable","onCompleteObservable","onErrorObservable","onDisposeObservable","onExtensionLoadedObservable","onValidatedObservable","_loader","_state","_requests","onLoaderStateChangedObservable","_logIndentLevel","_loggingEnabled","_log","_logDisabled","_capturePerformanceCounters","_startPerformanceCounter","_startPerformanceCounterDisabled","_endPerformanceCounter","_endPerformanceCounterDisabled","callback","_onParsedObserver","remove","add","_onMeshLoadedObserver","_onSkinLoadedObserver","skinnedNode","_onTextureLoadedObserver","_onMaterialLoadedObserver","_onCameraLoadedObserver","_onCompleteObserver","_onErrorObserver","_onDisposeObserver","_onExtensionLoadedObserver","_logEnabled","_startPerformanceCounterEnabled","_endPerformanceCounterEnabled","_onValidatedObserver","dispose","abort","_progressCallback","preprocessUrlAsync","clear","notifyObservers","loadFile","scene","fileOrUrl","onSuccess","onProgress","useArrayBuffer","_loadBinary","GetFilename","Logger","Warn","dataBuffer","_loadFile","webRequest","setRequestHeader","_unpackBinaryAsync","DataReader","loaderData","_validate","json","_parseJson","arrayBufferView","RangeError","readViewAsync","importMeshAsync","meshesNames","_getLoader","loadAsync","loadAssetContainerAsync","container","AssetContainer","textures","morphTargetManagers","geometries","particleSystems","skeletons","transformNodes","canDirectLoad","directLoad","DecodeBase64UrlToBinary","createPlugin","GLTFFileLoader","whenCompleteAsync","addOnce","_setState","state","onOpened","request","event","_onProgress","_lengthComputable","_total","_loaded","lengthComputable","loaded","total","GLTFValidation","_loadFileAsync","asset","version","minVersion","_parseVersion","_compareVersion","major","minor","createLoader","_CreateGLTF1Loader","_CreateGLTF2Loader","parsed","JSON","parse","dataReader","magic","readUint32","RuntimeError","ErrorCodes","GLTFLoaderUnexpectedMagicError","loggingEnabled","unpacked","_unpackBinaryV1Async","_unpackBinaryV2Async","contentLength","contentFormat","bodyLength","readString","bin","ChunkFormat","chunkLength","skipBytes","match","parseInt","_logOpen","_logClose","spaces","_logSpaces","substring","Log","counterName","StartPerformanceCounter","EndPerformanceCounter","IncrementalLoading","HomogeneousCoordinates","extensionOptions","capturePerformanceCounters","customRootNode","onCameraLoaded","onMaterialLoaded","onMeshLoaded","onParsed","onSkinLoaded","onTextureLoaded","onValidated","RegisterSceneLoaderPlugin","GlobalObject","BABYLON","RegisteredGLTFExtensions","Map","registeredGLTFExtensions","registerGLTFExtension","isGLTFExtension","unregisterGLTFExtension","delete","LazyAnimationGroupModulePromise","Lazy","LazyLoaderAnimationModulePromise","Get","context","array","TryGet","Assign","LoadBoundingInfoFromPositionAccessor","min","max","minArray","maxArray","minVector","TmpVectors","copyFromFloats","maxVector","normalized","componentType","divider","oneOverDivider","BoundingInfo","_completePromises","_assetContainer","_babylonLights","_disableInstancedMesh","_allMaterialsDirtyRequired","_skipStartAnimationStep","_extensions","_disposed","_rootUrl","_fileName","_uniqueRootUrl","_bin","_rootBabylonMesh","_defaultBabylonMaterialData","_postSceneLoadActions","_parent","RegisterExtension","UnregisterExtension","_babylonScene","extension","_loadData","_loadAsync","_getMeshes","_getSkeletons","_getAnimationGroups","_getTransformNodes","_getGeometries","spriteManagers","resultFunc","Date","now","_loadExtensionsAsync","loadingToReadyCounterName","LOADING","READY","loadingToCompleteCounterName","COMPLETE","_extensionsOnLoading","promises","oldBlockMaterialDirtyMechanism","blockMaterialDirtyMechanism","loadSceneAsync","scenes","ArrayItem","m","babylonDrawMode","Material","TriangleFillMode","_loadMaterialAsync","_forceBlockMaterialDirtyMechanism","_compileMaterialsAsync","_compileShadowGeneratorsAsync","resultPromise","all","setEnabled","maxSimultaneousLights","Math","_extensionsOnReady","_startAnimations","SetImmediate","catch","_setupData","buffers","binaryBuffer","accessors","bufferViews","images","samplers","skins","nodeParents","children","_createRootNode","parentIndex","extensionPromises","registeredExtension","enabled","isExtensionUsed","sort","order","Number","MAX_VALUE","extensionsRequired","some","_blockEntityCollection","rootMesh","Mesh","_parentContainer","GLTFLoader","_LoadTransform","FORCE_RIGHT_HANDED","extensionPromise","_extensionsLoadSceneAsync","logOpen","loadNodeAsync","action","_loadAnimationsAsync","logClose","_forEachPrimitive","geometry","AbstractMesh","_babylonTransformNodeForSkin","skin","babylonSkeleton","NONE","babylonAnimationGroups","start","ALL","_extensionsLoadNodeAsync","loadNode","babylonTransformNode","AddPointerMetadata","loadCameraAsync","babylonCamera","childNode","childBabylonMesh","hasMesh","hasSkin","nodeName","transformNode","TransformNode","_loadMeshAsync","babylonTransformNodeForSkin","metadata","deepMerge","_loadSkinAsync","skeleton","parentNode","asMesh","isAnInstance","useBoundingInfoFromGeometry","_updateBoundingInfo","refreshBoundingInfo","primitive","_loadMeshPrimitiveAsync","_extensionsLoadMeshPrimitiveAsync","babylonAbstractMesh","promise","shouldInstance","targets","createInstance","sideOrientation","CounterClockWiseSideOrientation","ClockWiseSideOrientation","_createMorphTargets","_loadVertexDataAsync","babylonGeometry","_loadMorphTargetsAsync","applyToMesh","_GetDrawMode","_createDefaultMaterial","_extensionsLoadVertexDataAsync","attributes","Geometry","indices","isUnIndexed","_loadIndicesAccessorAsync","setIndices","loadAttribute","kind","_delayInfo","_loadVertexAccessorAsync","babylonVertexBuffer","getKind","VertexBuffer","PositionKind","babylonBoundingInfo","_boundingInfo","setVerticesBuffer","count","MatricesIndicesExtraKind","numBoneInfluencers","NormalKind","TangentKind","UVKind","UV2Kind","UV3Kind","UV4Kind","UV5Kind","UV6Kind","MatricesIndicesKind","MatricesWeightsKind","MatricesWeightsExtraKind","ColorKind","hasVertexAlpha","targetNames","extras","MorphTargetManager","areUpdatesFrozen","weight","addTarget","MorphTarget","numTargets","babylonMorphTarget","_loadMorphTargetVertexDataAsync","attribute","setData","getVertexBuffer","_loadFloatAccessorAsync","positions","Float32Array","setPositions","normals","setNormals","tangents","dataIndex","setTangents","uvs","setUVs","setUV2s","colors","componentSize","getSize","pixid","floor","channel","setColors","babylonNode","Zero","One","decompose","_extensionsLoadSkinAsync","skeletonId","Skeleton","_loadBones","_loadSkinInverseBindMatricesDataAsync","inverseBindMatricesData","_updateBoneMatrices","_findSkeletonRootNode","joints","skeletonNode","isParent","babylonBones","_loadBone","paths","unshift","j","_isJoint","babylonBone","parentBabylonBone","boneIndex","Bone","_getNodeMatrix","linkTransformNode","inverseBindMatrices","bones","baseMatrix","FromArrayToRef","invertToRef","babylonParentBone","getParent","getAbsoluteInverseBindMatrix","updateMatrix","_updateAbsoluteBindMatrices","_extensionsLoadCameraAsync","FreeCamera","setTarget","Camera","ORTHOGRAPHIC_CAMERA","loadAnimationAsync","animationGroup","targetedAnimations","_extensionsLoadAnimationAsync","AnimationGroup","babylonAnimationGroup","channels","_loadAnimationChannelAsync","babylonTarget","addTargetedAnimation","normalize","animationContext","onLoad","_extensionsLoadAnimationChannelAsync","targetNode","channelTargetPath","pathIsWeights","properties","targetInfo","_loadAnimationChannelFromTargetInfoAsync","invfps","sampler","_loadAnimationSamplerAsync","numAnimations","propertyInfo","stride","input","output","outputOffset","inputAccessor","outputAccessor","inputData","outputData","loadBufferAsync","_extensionsLoadBufferAsync","loadUriAsync","loadBufferViewAsync","bufferView","_extensionsLoadBufferViewAsync","_loadAccessorAsync","numComponents","_GetNumComponents","byteStride","GetTypeByteLength","ForEach","_GetTypedArray","sparse","typedArray","indicesBufferView","valuesBufferView","values","indicesData","valuesData","sparseLength","sparseData","valuesIndex","indicesIndex","componentIndex","_GetTypedArrayConstructor","_loadVertexBufferViewAsync","_babylonBuffer","engine","Buffer","_babylonVertexBuffer","babylonBuffer","_loadMaterialMetallicRoughnessPropertiesAsync","PBRMaterial","Color3","White","loadTextureInfoAsync","albedoTexture","nonColorData","metallicTexture","useMetallnessFromMetallicTextureBlue","useRoughnessFromMetallicTextureGreen","useRoughnessFromMetallicTextureAlpha","_extensionsLoadMaterialAsync","babylonData","createMaterial","babylonMeshes","loadMaterialPropertiesAsync","splice","enableSpecularAntiAliasing","useRadianceOverAlpha","useSpecularOverAlpha","transparencyMode","PBRMATERIAL_OPAQUE","_extensionsCreateMaterial","_extensionsLoadMaterialPropertiesAsync","loadMaterialBasePropertiesAsync","loadMaterialAlphaProperties","doubleSided","backFaceCulling","twoSidedLighting","invertNormalMapX","invertNormalMapY","forceIrradianceInFragment","ambientTexture","useAmbientInGrayScale","alphaMode","PBRMATERIAL_ALPHATEST","alphaCutOff","alphaCutoff","hasAlpha","PBRMATERIAL_ALPHABLEND","useAlphaFromAlbedoTexture","textureInfo","_extensionsLoadTextureInfoAsync","texCoord","_textureInfo","_loadTextureAsync","babylonTexture","coordinatesIndex","_extensionsLoadTextureAsync","DefaultSampler","image","_createTextureAsync","textureLoaderOptions","useSRGBBuffer","samplerData","_loadSampler","deferred","Deferred","textureCreationOptions","noMipmap","noMipMaps","invertY","samplingMode","exception","GetMimeType","loaderOptions","Texture","loadImageAsync","dataUrl","updateURL","internalTexture","getInternalTexture","wrapU","wrapV","minFilter","_GetTextureSamplingMode","_GetTextureWrapMode","wrapS","wrapT","property","_extensionsLoadUriAsync","_ValidateUri","IsBase64DataUrl","log","LoadFileError","status","statusText","babylonObject","pointer","_internalMetadata","pointers","CLAMP_ADDRESSMODE","MIRROR_ADDRESSMODE","WRAP_ADDRESSMODE","magFilter","LINEAR_NEAREST","LINEAR_LINEAR","LINEAR_NEAREST_MIPNEAREST","LINEAR_LINEAR_MIPNEAREST","LINEAR_NEAREST_MIPLINEAR","LINEAR_LINEAR_MIPLINEAR","NEAREST_NEAREST","NEAREST_LINEAR","NEAREST_NEAREST_MIPNEAREST","NEAREST_LINEAR_MIPNEAREST","NEAREST_NEAREST_MIPLINEAR","NEAREST_LINEAR_MIPLINEAR","GetTypedArrayConstructor","componentTypeLength","IsBase64","PointListDrawMode","LineListDrawMode","LineLoopDrawMode","LineStripDrawMode","TriangleStripDrawMode","TriangleFanDrawMode","forceCompilationAsync","useInstances","clipPlane","getShadowGenerator","_forEachExtensions","_applyExtensions","functionName","actionAsync","loaderProperty","_activeLoaderExtensionFunctions","activeLoaderExtensionFunctions","onLoading","onReady","_loadUriAsync","LoadExtensionAsync","extensionName","LoadExtraAsync","extra","extensionsUsed","startPerformanceCounter","endPerformanceCounter","NAME","loader","extensionContext","_loadLightAsync","babylonScene","environmentTexture","specularImages","mipmap","faces","face","specularImageContext","RawCubeTexture","specularImageSize","irradianceCoefficients","sphericalHarmonics","SphericalHarmonics","convertIrradianceToLambertianRadiance","sphericalPolynomial","SphericalPolynomial","FromHarmonics","lodGenerationScale","log2","updateRGBDAsync","instanceCount","translationBuffer","rotationBuffer","scaleBuffer","matrices","ComposeToRef","copyToArray","thinInstanceSetBuffer","EXT_mesh_gpu_instancing","bufferViewMeshopt","_meshOptData","MeshoptCompression","Default","decodeGltfBufferAsync","filter","EXT_meshopt_compression","EXT_texture_webp","EXT_texture_avif","babylonSpotLight","Backward","PI","falloffType","Light","FALLOFF_GLTF","bufferData","iesProfileTexture","useNormalizedFlagFromAccessor","DracoDecoder","DefaultAvailable","dracoDecoder","uniqueId","_dracoBabylonGeometry","positionAccessor","_decodeMeshToGeometryForGltfAsync","KHR_draco_mesh_compression","babylonLight","babylonDirectionalLight","DirectionalLight","setAll","PointLight","KHR_lights","_loadSpecularGlossinessPropertiesAsync","diffuseFactor","reflectivityColor","microSurface","glossinessFactor","diffuseTexture","specularGlossinessTexture","reflectivityTexture","useMicroSurfaceFromReflectivityMapAlpha","KHR_materials_pbrSpecularGlossiness","_loadUnlitPropertiesAsync","unlit","KHR_materials_unlit","_loadClearCoatPropertiesAsync","isEnabled","useRoughnessFromMainTexture","remapF0OnInterfaceChange","textureRoughness","_loadIridescencePropertiesAsync","iridescenceIOR","_loadEmissiveProperties","_loadSheenPropertiesAsync","Black","albedoScaling","_loadSpecularPropertiesAsync","EXT_materials_specular_edge_color","specularEdgeColorEnabled","brdf","dielectricSpecularModel","MATERIAL_DIELECTRIC_SPECULAR_MODEL_OPENPBR","conductorSpecularModel","MATERIAL_CONDUCTOR_SPECULAR_MODEL_OPENPBR","metallicReflectanceTexture","useOnlyMetallicFromMetallicReflectanceTexture","reflectanceTexture","_loadIorPropertiesAsync","_DEFAULT_IOR","GetAvailableVariants","extensionMetadata","_GetExtensionMetadata","variants","getAvailableVariants","KHR_materials_variants","SelectVariant","variantName","select","entries","entry","lastSelected","selectVariant","Reset","original","reset","GetLastSelectedVariant","getLastSelectedVariant","_variants","rootBabylonMesh","defaultVariant","onLoaded","selectedVariant","lastSelectedVariant","isArray","mappingIndex","mapping","mappings","mappingVariantIndex","variantIndex","variant","onClonedObservable","newOne","newMesh","newRoot","variantEntry","_opaqueRenderTarget","_opaqueMeshesCache","_transparentMeshesCache","_materialObservers","_options","TransmissionHelper","_GetDefaultOptions","_scene","_transmissionHelper","_parseScene","_setupRenderTargets","renderSize","samples","lodGenerationOffset","renderTargetTextureType","TEXTURETYPE_HALF_FLOAT","generateMipmaps","updateOptions","newValues","newOptions","oldOptions","getOpaqueTarget","_shouldRenderAsTransmission","isRefractionEnabled","_addMesh","onMaterialChangedObservable","_onMeshMaterialChanged","bind","refractionTexture","_removeMesh","idx","onNewMeshAddedObservable","onMeshRemovedObservable","transparentIdx","opaqueIdx","_isRenderTargetValid","saveSceneEnvIntensity","RenderTargetTexture","ignoreCameraViewport","renderList","clearColor","gammaSpace","renderSprites","renderParticles","disableImageProcessing","onBeforeBindObservable","opaqueRenderTarget","environmentIntensity","toLinearSpaceToRef","useExactSrgbConversions","onAfterUnbindObservable","_loadTransparentPropertiesAsync","pbrMaterial","volumeIndexOfRefraction","useAlbedoToTintRefraction","refractionIntensityTexture","useGltfStyleTextures","_loadTranslucentPropertiesAsync","isTranslucencyEnabled","useAlbedoToTintTranslucency","translucencyIntensityTexture","translucencyColorTexture","_loadVolumePropertiesAsync","useThicknessAsDepth","_loadDispersionPropertiesAsync","isDispersionEnabled","_loadDiffuseRoughnessPropertiesAsync","baseDiffuseModel","MATERIAL_DIFFUSE_MODEL_E_OREN_NAYAR","diffuseRoughnessFactor","baseDiffuseRoughness","diffuseRoughnessTexture","baseDiffuseRoughnessTexture","EXT_materials_diffuse_roughness","KHR_mesh_quantization","useRGBAIfASTCBC7NotAvailableWhenUASTC","KHR_texture_basisu","uRotationCenter","vRotationCenter","xmpGltf","KHR_xmp_json_ld","xmpNode","packet","packets","xmp","getColor3","getFloat","getMinusFloat","getNextFloat","getFloatBy2","getTextureTransformTree","textureName","MaterialAnimationPropertyInfo","CameraAnimationPropertyInfo","ANIMATIONTYPE_COLOR3","baseColorTextureInterpolation","metallicRoughnessTextureInterpolation","normalTextureInterpolation","occlusionTextureInterpolation","emissiveTextureInterpolation","anisotropyTextureInterpolation","clearcoatTextureInterpolation","clearcoatNormalTextureInterpolation","clearcoatRoughnessTextureInterpolation","iridescenceTextureInterpolation","iridescenceThicknessTextureInterpolation","sheenTextureInterpolation","sheenRoughnessTextureInterpolation","specularTextureInterpolation","specularColorTextureInterpolation","transmissionTextureInterpolation","thicknessTextureInterpolation","diffuseTransmissionTextureInterpolation","diffuseTransmissionColorTextureInterpolation","LightAnimationPropertyInfo","_pathToObjectConverter","KHR_animation_pointer","_clips","_emitters","clips","emitters","emitterIndex","emitter","refDistance","maxDistance","rolloffFactor","distanceModel","outerAngle","_loadEmitterAsync","_babylonSounds","sound","attachToMesh","setLocalDirectionToMesh","Forward","setDirectionalCone","ToDegrees","events","_loadAnimationEventAsync","_loadClipAsync","clip","_objectURL","_babylonData","clipPromises","loop","autoplay","volume","clipContext","objectURL","Sound","weightedSound","WeightedSound","directionalConeInnerAngle","directionalConeOuterAngle","_getEventAction","time","startOffset","currentFrame","frameOffset","play","stop","pause","babylonAnimationEvent","AnimationEvent","addEvent","onAnimationGroupEndObservable","onAnimationGroupPauseObservable","MSFT_audio_emitter","maxLODsToLoad","onNodeLODsLoadedObservable","onMaterialLODsLoadedObservable","_bufferLODs","_nodeIndexLOD","_nodeSignalLODs","_nodePromiseLODs","_nodeBufferLODs","_materialIndexLOD","_materialSignalLODs","_materialPromiseLODs","_materialBufferLODs","indexLOD","_loadBufferLOD","nodeLODs","_getLODs","ids","nodeLOD","previousNodeLOD","_disposeTransformNode","firstPromise","materialLODs","materialLOD","previousDataLOD","_disposeMaterials","previousIndexLOD","bufferLODs","end","bufferLOD","babylonMaterials","getChildMeshes","babylonMaterialsToDispose","every","babylonTextures","getActiveTextures","hasTexture","MSFT_lod","extraContext","needAlphaBlending","forceDepthWrite","separateCullingPass","MSFT_minecraftMesh","getMappingForFullOperationName","fullOperationName","getMappingForDeclaration","declaration","returnNoOpIfNotAvailable","gltfExtensionsToFlowGraphMapping","gltfToFlowGraphMapping","inputs","flows","inputValueSockets","outputValueSockets","blocks","outputs","addNewInteractivityFlowGraphMapping","MSFT_sRGBFactors","out","timeSinceLastTick","gltfType","extraProcessor","gltfBlock","_mapping","parser","serializedObjects","configuration","eventId","arrays","serializedObject","eventData","validation","interactivityGraph","valid","eventConfiguration","getSimpleInputMapping","roundHalfAwayFromZero","_gltfBlock","_declaration","_parser","useMatrixPerComponent","preventIntegerFloatArithmetic","types","flowGraphType","ValidateTypes","condition","c","dataInputs","_connectionValues","axis","inputIsColumnMajor","h","k","l","socketIn","valueType","socketInA","socketInB","_arrays","outputSignalCount","signalOutputs","true","false","cases","inOptions","defaultValue","selection","default","caseValue","toString","uniqueCases","Set","from","loopBody","initialIndex","startIndex","endIndex","incrementIndexWhenLoopDone","currentCount","isRandom","isLoop","inputFlows","err","variable","isVariable","dataTransformer","getVariableName","variables","useSlerp","duration","p1","toBlock","p2","in","interBlockConnectors","inputBlockIndex","outputBlockIndex","serializedValueInterpolation","propertyIndex","staticVariables","animationType","getAnimationTypeByFlowGraphType","serializedGetVariable","className","outputValue","speed","startTime","_animationTargetFps","endTime","_context","globalGLTF","stopTime","treatCasesAsIntegers","inferType","reduce","acc","getAllSupportedNativeNodeTypes","gltfTypeToBabylonType","float","elementType","bool","float2","float3","float4","float4x4","float2x2","float3x3","int","_interactivityGraph","_types","_mappings","_staticVariables","_events","_internalEventsCounter","_nodes","_parseTypes","_parseDeclarations","_parseVariables","_parseEvents","_parseNodes","signature","declarations","flowGraphMapping","_parseVariable","dataTransform","NaN","fill","parseFloat","converted","eventValue","validationResult","blockType","block","_getEmptyBlock","_parseNodeConfiguration","RandomGUID","dataOutputs","signalInputs","nodeMapping","configMapping","configKey","_parseNodeConnections","gltfNode","flowGraphBlocks","outputMapper","flowsFromGLTF","flowsKeys","flowKey","flow","flowMapping","socketOutName","socketOut","_createNewSocketConnection","inputNodeId","nodeIn","inputMapper","flowInMapping","socket","arrayMapping","endsWith","nodeInSocketName","inputBlock","connectedPointIds","valuesFromGLTF","valuesKeys","valueKey","valueMapping","socketInName","convertedValue","nodeOutId","nodeOutSocketName","nodeOut","outBlock","connector","_connectFlowGraphNodes","isOutput","_connectionType","serializedInput","serializedOutput","inputArray","outputArray","inputConnection","outputConnection","serializeToFlowGraph","_userVariables","rightHanded","allBlocks","val","concat","executionContexts","_pathConverter","_AddInteractivityObjectModel","interactivityDefinition","KHR_interactivity","coordinator","FlowGraphCoordinator","dispatchEventsSynchronously","graphs","graph","InteractivityGraphToFlowGraphParser","ParseFlowGraphAsync","pathConverter","activeCamera","quat","getWorldMatrix","w","pos","getTranslation","isPlaying","to","getCurrentFrame","addToBlockFactory","FlowGraphGLTFDataProvider","tn","isVisible","inheritVisibility","KHR_node_visibility","visible","stopPropagation","nodeIndex","selectedNodeIndex","controllerIndex","selectionPoint","selectionRayOrigin","variableName","isPickable","KHR_node_selectability","selectable","MeshPointerOverPrefix","hoverNodeIndex","MeshPointerOutPrefix","pointerOverDisableMeshTesting","KHR_node_hoverability","hoverable","_assignExtras","gltfProp","ExtrasAsMetadata","GLTF2","Loader","Extensions"],"sourceRoot":""}