babylonjs-loaders 5.17.1 → 5.20.0

package/babylon.glTF2FileLoader.js

@@ -744,6 +744,805 @@ var ExtrasAsMetadata = /** @class */ (function () {
 _glTFLoader__WEBPACK_IMPORTED_MODULE_0__.GLTFLoader.RegisterExtension(NAME, function (loader) { return new ExtrasAsMetadata(loader); });
 
 
+/***/ }),
+
+/***/ "../../../lts/loaders/dist/glTF/2.0/Extensions/KHR_animation_pointer.js":
+/*!******************************************************************************!*\
+  !*** ../../../lts/loaders/dist/glTF/2.0/Extensions/KHR_animation_pointer.js ***!
+  \******************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "KHR_animation_pointer": () => (/* binding */ KHR_animation_pointer)
+/* harmony export */ });
+/* harmony import */ var _glTFLoader__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../glTFLoader */ "../../../lts/loaders/dist/glTF/2.0/glTFLoader.js");
+/* harmony import */ var core_Animations_animationGroup__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Animations/animationKey */ "core/Misc/observable");
+/* harmony import */ var core_Animations_animationGroup__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_Animations_animationGroup__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _KHR_animation_pointer_map__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./KHR_animation_pointer.map */ "../../../lts/loaders/dist/glTF/2.0/Extensions/KHR_animation_pointer.map.js");
+/* harmony import */ var _glTFUtilities__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../glTFUtilities */ "../../../lts/loaders/dist/glTF/2.0/glTFUtilities.js");
+
+
+
+
+
+var NAME = _glTFLoader__WEBPACK_IMPORTED_MODULE_0__.GLTFLoader._KHRAnimationPointerName;
+/**
+ * [Specification PR](https://github.com/KhronosGroup/glTF/pull/2147)
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+var KHR_animation_pointer = /** @class */ (function () {
+    /**
+     * @param loader
+     * @hidden
+     */
+    function KHR_animation_pointer(loader) {
+        /**
+         * used to gently ignore invalid pointer. If false, invalid pointer will throw exception.
+         */
+        this.ignoreInvalidPointer = true;
+        /**
+         * The name of this extension.
+         */
+        this.name = NAME;
+        this._loader = loader;
+    }
+    Object.defineProperty(KHR_animation_pointer.prototype, "enabled", {
+        /**
+         * Defines whether this extension is enabled.
+         */
+        get: function () {
+            return this._loader.isExtensionUsed(NAME);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /** @hidden */
+    KHR_animation_pointer.prototype.dispose = function () {
+        this._loader = null;
+    };
+    /**
+     * according to specification,
+     * It is not allowed to animate a glTFid property, as it does change the structure of the glTF in general
+     * It is not allowed to animate a name property in general.
+     * @param property
+     * @hidden
+     */
+    KHR_animation_pointer.prototype.accept = function (property) {
+        return property != "name";
+    };
+    KHR_animation_pointer.prototype.loadAnimationAsync = function (context, animation) {
+        // ensure an animation group is present.
+        if (!animation._babylonAnimationGroup) {
+            this._loader.babylonScene._blockEntityCollection = !!this._loader._assetContainer;
+            var group = new core_Animations_animationGroup__WEBPACK_IMPORTED_MODULE_1__.AnimationGroup(animation.name || "animation".concat(animation.index), this._loader.babylonScene);
+            group._parentContainer = this._loader._assetContainer;
+            this._loader.babylonScene._blockEntityCollection = false;
+            animation._babylonAnimationGroup = group;
+        }
+        var babylonAnimationGroup = animation._babylonAnimationGroup;
+        var promises = new Array();
+        _glTFLoader__WEBPACK_IMPORTED_MODULE_0__.ArrayItem.Assign(animation.channels);
+        _glTFLoader__WEBPACK_IMPORTED_MODULE_0__.ArrayItem.Assign(animation.samplers);
+        for (var _i = 0, _a = animation.channels; _i < _a.length; _i++) {
+            var channel = _a[_i];
+            promises.push(this._loadAnimationChannelAsync("".concat(context, "/channels/").concat(channel.index), context, animation, channel));
+        }
+        return Promise.all(promises).then(function () {
+            babylonAnimationGroup.normalize(0);
+            return babylonAnimationGroup;
+        });
+    };
+    /**
+     * @hidden Loads a glTF animation channel.
+     * @param context The context when loading the asset
+     * @param animationContext The context of the animation when loading the asset
+     * @param animation The glTF animation property
+     * @param channel The glTF animation channel property
+     * @param animationTargetOverride The babylon animation channel target override property. My be null.
+     * @returns A void promise when the channel load is complete
+     */
+    KHR_animation_pointer.prototype._loadAnimationChannelAsync = function (context, animationContext, animation, channel, animationTargetOverride) {
+        var _this = this;
+        var _a, _b;
+        if (animationTargetOverride === void 0) { animationTargetOverride = null; }
+        if (channel.target.path != "pointer" /* POINTER */) {
+            throw new Error("".concat(context, "/target/path: Invalid value (").concat(channel.target.path, ")"));
+        }
+        if (channel.target.node != undefined) {
+            // According to KHR_animation_pointer specification
+            // If this extension is used, the animation.channel.target.node must not be set.
+            // Because the node is defined, the channel is ignored and not animated due to the specification.
+            return Promise.resolve();
+        }
+        var pointer = (_b = (_a = channel.target.extensions) === null || _a === void 0 ? void 0 : _a.KHR_animation_pointer) === null || _b === void 0 ? void 0 : _b.pointer;
+        if (!pointer) {
+            throw new Error("".concat(context, "/target/extensions/").concat(this.name, ": Pointer is missing"));
+        }
+        var sampler = _glTFLoader__WEBPACK_IMPORTED_MODULE_0__.ArrayItem.Get("".concat(context, "/sampler"), animation.samplers, channel.sampler);
+        return this._loadAnimationSamplerAsync("".concat(context, "/samplers/").concat(channel.sampler), sampler).then(function (data) {
+            var _a;
+            // this is where we process the pointer.
+            var animationTarget = _this._parseAnimationPointer("".concat(context, "/extensions/").concat(_this.name, "/pointer"), pointer);
+            if (!animationTarget) {
+                return;
+            }
+            // build the keys
+            // build the animations into the group
+            var babylonAnimationGroup = animation._babylonAnimationGroup;
+            if (!babylonAnimationGroup) {
+                return;
+            }
+            var outputAccessor = _glTFLoader__WEBPACK_IMPORTED_MODULE_0__.ArrayItem.Get("".concat(context, "/output"), _this._loader.gltf.accessors, sampler.output);
+            // stride is the size of each element stored into the output buffer.
+            var stride = (_a = animationTarget.stride) !== null && _a !== void 0 ? _a : (0,_glTFUtilities__WEBPACK_IMPORTED_MODULE_3__.getDataAccessorElementCount)(outputAccessor.type);
+            var fps = _this._loader.parent.targetFps;
+            // we extract the corresponding values from the read value.
+            // the reason for that is one GLTF value may be dispatched to several Babylon properties
+            // one of example is baseColorFactor which is a Color4 under GLTF and dispatched to
+            // - albedoColor as Color3(Color4.r,Color4.g,Color4.b)
+            // - alpha as Color4.a
+            for (var _i = 0, _b = animationTarget.properties; _i < _b.length; _i++) {
+                var propertyInfo = _b[_i];
+                // Ignore animations that have no animation valid targets.
+                if (!propertyInfo.isValid(animationTarget.target)) {
+                    return;
+                }
+                // build the keys.
+                var keys = new Array(data.input.length);
+                var outputOffset = 0;
+                switch (data.interpolation) {
+                    case "STEP" /* STEP */: {
+                        for (var frameIndex = 0; frameIndex < data.input.length; frameIndex++) {
+                            keys[frameIndex] = {
+                                frame: data.input[frameIndex] * fps,
+                                value: propertyInfo.get(animationTarget.target, data.output, outputOffset),
+                                interpolation: core_Animations_animationGroup__WEBPACK_IMPORTED_MODULE_1__.AnimationKeyInterpolation.STEP,
+                            };
+                            outputOffset += stride;
+                        }
+                        break;
+                    }
+                    case "CUBICSPLINE" /* CUBICSPLINE */: {
+                        var invfps = 1 / fps;
+                        for (var frameIndex = 0; frameIndex < data.input.length; frameIndex++) {
+                            var k = {
+                                frame: data.input[frameIndex] * fps,
+                            };
+                            (k.inTangent = propertyInfo.get(animationTarget.target, data.output, outputOffset, invfps)), (outputOffset += stride);
+                            (k.value = propertyInfo.get(animationTarget.target, data.output, outputOffset)), (outputOffset += stride);
+                            (k.outTangent = propertyInfo.get(animationTarget.target, data.output, outputOffset, invfps)), (outputOffset += stride);
+                            keys[frameIndex] = k;
+                        }
+                        break;
+                    }
+                    case "LINEAR" /* LINEAR */:
+                    default: {
+                        for (var frameIndex = 0; frameIndex < data.input.length; frameIndex++) {
+                            keys[frameIndex] = {
+                                frame: data.input[frameIndex] * fps,
+                                value: propertyInfo.get(animationTarget.target, data.output, outputOffset),
+                            };
+                            outputOffset += stride;
+                        }
+                        break;
+                    }
+                }
+                // each properties has its own build animation process.
+                // these logics are located into KHR_animation_pointer.map.ts
+                propertyInfo.buildAnimations(animationTarget.target, fps, keys, babylonAnimationGroup, animationTargetOverride, animationTarget.params);
+            }
+        });
+    };
+    KHR_animation_pointer.prototype._loadAnimationSamplerAsync = function (context, sampler) {
+        if (sampler._data) {
+            return sampler._data;
+        }
+        var interpolation = sampler.interpolation || "LINEAR" /* LINEAR */;
+        switch (interpolation) {
+            case "STEP" /* STEP */:
+            case "LINEAR" /* LINEAR */:
+            case "CUBICSPLINE" /* CUBICSPLINE */: {
+                break;
+            }
+            default: {
+                throw new Error("".concat(context, "/interpolation: Invalid value (").concat(sampler.interpolation, ")"));
+            }
+        }
+        var inputAccessor = _glTFLoader__WEBPACK_IMPORTED_MODULE_0__.ArrayItem.Get("".concat(context, "/input"), this._loader.gltf.accessors, sampler.input);
+        var outputAccessor = _glTFLoader__WEBPACK_IMPORTED_MODULE_0__.ArrayItem.Get("".concat(context, "/output"), this._loader.gltf.accessors, sampler.output);
+        sampler._data = Promise.all([
+            this._loader._loadFloatAccessorAsync("/accessors/".concat(inputAccessor.index), inputAccessor),
+            this._loader._loadFloatAccessorAsync("/accessors/".concat(outputAccessor.index), outputAccessor),
+        ]).then(function (_a) {
+            var inputData = _a[0], outputData = _a[1];
+            return {
+                input: inputData,
+                interpolation: interpolation,
+                output: outputData,
+            };
+        });
+        return sampler._data;
+    };
+    /**
+     * parsing animation pointer is the core of animation channel.
+     * Animation pointer is a Json pointer, which mean it locate an item into the json hierarchy.
+     * Consequentely the pointer has the following BNF
+   
+     * <animationPointer> := <sep><assetContainer><sep><assetIndex><sep><propertyPath>
+     * <assetContainer> := "nodes" | "materials" | "meshes" | "cameras" | "extensions"
+     * <assetIndex> := <digit> | <name>
+     * <propertyPath> := <extensionPath> | <standardPath>
+     * <extensionPath> := "extensions"<sep><name><sep><standardPath>
+     * <standardPath> := <name> | <name><sep><standardPath>
+     * <sep>:= "/"
+     * <name> := W+
+     * <digit> := D+
+     *
+     * examples of pointer are
+     *  - "/nodes/0/rotation"
+     *  - "/materials/2/emissiveFactor"
+     *  - "/materials/2/pbrMetallicRoughness/baseColorFactor"
+     *  - "/materials/2/extensions/KHR_materials_emissive_strength/emissiveStrength"
+     * @param context
+     * @param pointer
+     * @return
+     */
+    KHR_animation_pointer.prototype._parseAnimationPointer = function (context, pointer) {
+        var sep = "/";
+        if (pointer.charAt(0) == sep) {
+            pointer = pointer.substring(1);
+        }
+        var parts = pointer.split(sep);
+        // we have a least 3 part
+        if (parts.length >= 3) {
+            var node = _KHR_animation_pointer_map__WEBPACK_IMPORTED_MODULE_2__.CoreAnimationPointerMap; // the map of possible path
+            var indices = [];
+            var getTarget = null;
+            for (var i = 0; i < parts.length; i++) {
+                var part = parts[i];
+                node = node[part];
+                if (!node) {
+                    // nothing to do so far
+                    break;
+                }
+                if (node.getTarget) {
+                    getTarget = node.getTarget;
+                }
+                if (node.hasIndex) {
+                    indices.push(parts[++i]);
+                    // move to the next part
+                    continue;
+                }
+                if (node.isIndex) {
+                    indices.push(part);
+                    // move to the next part
+                    continue;
+                }
+                if (node.properties && getTarget) {
+                    var t = getTarget(this._loader.gltf, indices[0]);
+                    if (t != null) {
+                        return {
+                            target: t,
+                            stride: node.getStride ? node.getStride(t) : undefined,
+                            properties: node.properties,
+                            params: indices,
+                        };
+                    }
+                }
+            }
+        }
+        if (this.ignoreInvalidPointer) {
+            return null;
+        }
+        throw new Error("".concat(context, " invalid pointer. ").concat(pointer));
+    };
+    return KHR_animation_pointer;
+}());
+
+_glTFLoader__WEBPACK_IMPORTED_MODULE_0__.GLTFLoader.RegisterExtension(NAME, function (loader) { return new KHR_animation_pointer(loader); });
+
+
+/***/ }),
+
+/***/ "../../../lts/loaders/dist/glTF/2.0/Extensions/KHR_animation_pointer.map.js":
+/*!**********************************************************************************!*\
+  !*** ../../../lts/loaders/dist/glTF/2.0/Extensions/KHR_animation_pointer.map.js ***!
+  \**********************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "CoreAnimationPointerMap": () => (/* binding */ CoreAnimationPointerMap)
+/* harmony export */ });
+/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! tslib */ "../../../../node_modules/tslib/tslib.es6.js");
+/* harmony import */ var core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! core/Materials/material */ "core/Misc/observable");
+/* harmony import */ var core_Animations_animation__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__);
+
+/* eslint-disable @typescript-eslint/naming-convention */
+
+
+
+
+var parseIntIndex = function (str) {
+    var targetIndex = parseInt(str);
+    if (isNaN(targetIndex)) {
+        return -1;
+    }
+    return targetIndex;
+};
+var getGltfNode = function (gltf, index) {
+    if (gltf.nodes) {
+        var i = parseIntIndex(index);
+        if (i != -1) {
+            return gltf.nodes[i];
+        }
+    }
+    return null;
+};
+var getGltfMaterial = function (gltf, index) {
+    if (gltf.materials) {
+        var i = parseIntIndex(index);
+        if (i != -1) {
+            return gltf.materials[i];
+        }
+    }
+    return null;
+};
+var getGltfCamera = function (gltf, index) {
+    if (gltf.cameras) {
+        var i = parseIntIndex(index);
+        if (i != -1) {
+            return gltf.cameras[i];
+        }
+    }
+    return null;
+};
+var getGltfExtension = function (gltf, index) {
+    if (gltf.extensions && index) {
+        return gltf.extensions[index];
+    }
+    return null;
+};
+var getMatrix = function (_target, source, offset, scale) {
+    return scale ? core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Matrix.FromArray(source, offset).scale(scale) : core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Matrix.FromArray(source, offset);
+};
+var getVector3 = function (_target, source, offset, scale) {
+    return scale ? core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArray(source, offset).scaleInPlace(scale) : core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArray(source, offset);
+};
+var getQuaternion = function (_target, source, offset, scale) {
+    return scale ? core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Quaternion.FromArray(source, offset).scaleInPlace(scale) : core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Quaternion.FromArray(source, offset);
+};
+var getColor3 = function (_target, source, offset, scale) {
+    return scale ? core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Color3.FromArray(source, offset).scale(scale) : core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Color3.FromArray(source, offset);
+};
+var getAlpha = function (_target, source, offset, scale) {
+    return scale ? source[offset + 3] * scale : source[offset + 3];
+};
+var getFloat = function (_target, source, offset, scale) {
+    return scale ? source[offset] * scale : source[offset];
+};
+var getMinusFloat = function (_target, source, offset, scale) {
+    return -(scale ? source[offset] * scale : source[offset]);
+};
+var getNextFloat = function (_target, source, offset, scale) {
+    return scale ? source[offset + 1] * scale : source[offset + 1];
+};
+var getFloatBy2 = function (_target, source, offset, scale) {
+    return (scale ? source[offset] * scale : source[offset]) * 2;
+};
+var getWeights = function (target, source, offset, scale) {
+    if (target._numMorphTargets) {
+        var value = new Array(target._numMorphTargets);
+        for (var i = 0; i < target._numMorphTargets; i++) {
+            value[i] = scale ? source[offset++] * scale : source[offset++];
+        }
+        return value;
+    }
+    return null;
+};
+var AbstractAnimationPointerPropertyInfos = /** @class */ (function () {
+    function AbstractAnimationPointerPropertyInfos(type, name, get) {
+        this.type = type;
+        this.name = name;
+        this.get = get;
+    }
+    AbstractAnimationPointerPropertyInfos.prototype._buildAnimation = function (animatable, fps, keys, babylonAnimationGroup, animationTargetOverride) {
+        if (animationTargetOverride === void 0) { animationTargetOverride = null; }
+        if (animatable || animationTargetOverride) {
+            var animationName = "".concat(babylonAnimationGroup.name, "_channel").concat(babylonAnimationGroup.targetedAnimations.length, "_").concat(this.name);
+            var babylonAnimation = new core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation(animationName, this.name, fps, this.type);
+            babylonAnimation.setKeys(keys);
+            if (animationTargetOverride != null && animationTargetOverride.animations != null) {
+                animationTargetOverride.animations.push(babylonAnimation);
+                babylonAnimationGroup.addTargetedAnimation(babylonAnimation, animationTargetOverride);
+            }
+            else if (animatable) {
+                animatable.animations = animatable.animations || Array(1);
+                animatable.animations.push(babylonAnimation);
+                babylonAnimationGroup.addTargetedAnimation(babylonAnimation, animatable);
+            }
+        }
+    };
+    AbstractAnimationPointerPropertyInfos.prototype.isValid = function (_target) {
+        return true;
+    };
+    return AbstractAnimationPointerPropertyInfos;
+}());
+var TransformNodeAnimationPointerPropertyInfos = /** @class */ (function (_super) {
+    (0,tslib__WEBPACK_IMPORTED_MODULE_0__.__extends)(TransformNodeAnimationPointerPropertyInfos, _super);
+    function TransformNodeAnimationPointerPropertyInfos(type, name, get) {
+        if (get === void 0) { get = getVector3; }
+        return _super.call(this, type, name, get) || this;
+    }
+    TransformNodeAnimationPointerPropertyInfos.prototype.isValid = function (target) {
+        return target._babylonTransformNode !== null && target._babylonTransformNode !== undefined;
+    };
+    TransformNodeAnimationPointerPropertyInfos.prototype.buildAnimations = function (target, fps, keys, group, animationTargetOverride) {
+        if (animationTargetOverride === void 0) { animationTargetOverride = null; }
+        return this._buildAnimation(target._babylonTransformNode, fps, keys, group, animationTargetOverride);
+    };
+    return TransformNodeAnimationPointerPropertyInfos;
+}(AbstractAnimationPointerPropertyInfos));
+var CameraAnimationPointerPropertyInfos = /** @class */ (function (_super) {
+    (0,tslib__WEBPACK_IMPORTED_MODULE_0__.__extends)(CameraAnimationPointerPropertyInfos, _super);
+    function CameraAnimationPointerPropertyInfos(type, name, get) {
+        if (get === void 0) { get = getFloat; }
+        return _super.call(this, type, name, get) || this;
+    }
+    CameraAnimationPointerPropertyInfos.prototype.isValid = function (target) {
+        return target._babylonCamera != null && target._babylonCamera !== undefined;
+    };
+    CameraAnimationPointerPropertyInfos.prototype.buildAnimations = function (target, fps, keys, group, animationTargetOverride) {
+        if (animationTargetOverride === void 0) { animationTargetOverride = null; }
+        return this._buildAnimation(target._babylonCamera, fps, keys, group, animationTargetOverride);
+    };
+    return CameraAnimationPointerPropertyInfos;
+}(AbstractAnimationPointerPropertyInfos));
+var MaterialAnimationPointerPropertyInfos = /** @class */ (function (_super) {
+    (0,tslib__WEBPACK_IMPORTED_MODULE_0__.__extends)(MaterialAnimationPointerPropertyInfos, _super);
+    function MaterialAnimationPointerPropertyInfos(type, name, get, fillMode) {
+        if (get === void 0) { get = getFloat; }
+        if (fillMode === void 0) { fillMode = core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Material.TriangleFillMode; }
+        var _this = _super.call(this, type, name, get) || this;
+        _this.fillMode = fillMode;
+        return _this;
+    }
+    MaterialAnimationPointerPropertyInfos.prototype.isValid = function (target) {
+        var data = target._data;
+        if (data) {
+            var c = data[this.fillMode];
+            if (c) {
+                return c.babylonMaterial !== null && c.babylonMaterial !== undefined;
+            }
+        }
+        return false;
+    };
+    MaterialAnimationPointerPropertyInfos.prototype.buildAnimations = function (target, fps, keys, group, animationTargetOverride) {
+        if (animationTargetOverride === void 0) { animationTargetOverride = null; }
+        return this._buildAnimation(target._data[this.fillMode].babylonMaterial, fps, keys, group, animationTargetOverride);
+    };
+    return MaterialAnimationPointerPropertyInfos;
+}(AbstractAnimationPointerPropertyInfos));
+var LightAnimationPointerPropertyInfos = /** @class */ (function (_super) {
+    (0,tslib__WEBPACK_IMPORTED_MODULE_0__.__extends)(LightAnimationPointerPropertyInfos, _super);
+    function LightAnimationPointerPropertyInfos(type, name, get) {
+        if (get === void 0) { get = getFloat; }
+        return _super.call(this, type, name, get) || this;
+    }
+    LightAnimationPointerPropertyInfos.prototype.isValid = function (target) {
+        return target && target.length != 0;
+    };
+    // note : the extensions array store directly the BabylonLight reference
+    LightAnimationPointerPropertyInfos.prototype.buildAnimations = function (target, fps, keys, group, animationTargetOverride, params) {
+        if (animationTargetOverride === void 0) { animationTargetOverride = null; }
+        var i = parseIntIndex(params[1]);
+        var l = i >= 0 && i < target.lights.length ? target.lights[i] : null;
+        return this._buildAnimation(l._babylonLight, fps, keys, group, animationTargetOverride);
+    };
+    return LightAnimationPointerPropertyInfos;
+}(AbstractAnimationPointerPropertyInfos));
+var WeightAnimationPointerPropertyInfos = /** @class */ (function (_super) {
+    (0,tslib__WEBPACK_IMPORTED_MODULE_0__.__extends)(WeightAnimationPointerPropertyInfos, _super);
+    function WeightAnimationPointerPropertyInfos(type, name, get) {
+        if (get === void 0) { get = getWeights; }
+        return _super.call(this, type, name, get) || this;
+    }
+    WeightAnimationPointerPropertyInfos.prototype.isValid = function (target) {
+        return target._numMorphTargets;
+    };
+    WeightAnimationPointerPropertyInfos.prototype.buildAnimations = function (targetNode, fps, keys, babylonAnimationGroup, _animationTargetOverride) {
+        if (_animationTargetOverride === void 0) { _animationTargetOverride = null; }
+        if (targetNode._numMorphTargets) {
+            var _loop_1 = function (targetIndex) {
+                var animationName = "".concat(babylonAnimationGroup.name, "_channel").concat(babylonAnimationGroup.targetedAnimations.length);
+                var babylonAnimation = new core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation(animationName, this_1.name, fps, this_1.type);
+                babylonAnimation.setKeys(keys.map(function (key) { return ({
+                    frame: key.frame,
+                    inTangent: key.inTangent ? key.inTangent[targetIndex] : undefined,
+                    value: key.value[targetIndex],
+                    outTangent: key.outTangent ? key.outTangent[targetIndex] : undefined,
+                    interpolation: key.interpolation,
+                }); }));
+                if (targetNode._primitiveBabylonMeshes) {
+                    for (var _i = 0, _a = targetNode._primitiveBabylonMeshes; _i < _a.length; _i++) {
+                        var m = _a[_i];
+                        var babylonMesh = m;
+                        if (babylonMesh.morphTargetManager) {
+                            var morphTarget = babylonMesh.morphTargetManager.getTarget(targetIndex);
+                            var babylonAnimationClone = babylonAnimation.clone();
+                            morphTarget.animations.push(babylonAnimationClone);
+                            babylonAnimationGroup.addTargetedAnimation(babylonAnimationClone, morphTarget);
+                        }
+                    }
+                }
+            };
+            var this_1 = this;
+            for (var targetIndex = 0; targetIndex < targetNode._numMorphTargets; targetIndex++) {
+                _loop_1(targetIndex);
+            }
+        }
+    };
+    return WeightAnimationPointerPropertyInfos;
+}(AbstractAnimationPointerPropertyInfos));
+var CoreAnimationNodesPointerMap = {
+    getTarget: getGltfNode,
+    hasIndex: true,
+    matrix: {
+        properties: [new TransformNodeAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_MATRIX, "matrix", getMatrix)],
+    },
+    translation: {
+        properties: [new TransformNodeAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_VECTOR3, "position")],
+    },
+    rotation: {
+        properties: [new TransformNodeAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_QUATERNION, "rotationQuaternion", getQuaternion)],
+    },
+    scale: {
+        properties: [new TransformNodeAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_VECTOR3, "scaling")],
+    },
+    weights: {
+        getStride: function (target) {
+            return target._numMorphTargets;
+        },
+        properties: [new WeightAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "influence")],
+    },
+};
+var CoreAnimationCamerasPointerMap = {
+    hasIndex: true,
+    getTarget: getGltfCamera,
+    orthographic: {
+        xmag: {
+            properties: [
+                new CameraAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "orthoLeft", getMinusFloat),
+                new CameraAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "orthoRight", getNextFloat),
+            ],
+        },
+        ymag: {
+            properties: [
+                new CameraAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "orthoBottom", getMinusFloat),
+                new CameraAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "orthoTop", getNextFloat),
+            ],
+        },
+        zfar: {
+            properties: [new CameraAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "maxZ")],
+        },
+        znear: {
+            properties: [new CameraAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "minZ")],
+        },
+    },
+    perspective: {
+        aspectRatio: {
+        // not supported.
+        },
+        yfov: {
+            properties: [new CameraAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "fov")],
+        },
+        zfar: {
+            properties: [new CameraAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "maxZ")],
+        },
+        znear: {
+            properties: [new CameraAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "minZ")],
+        },
+    },
+};
+var CoreAnimationMaterialsPointerMap = {
+    hasIndex: true,
+    getTarget: getGltfMaterial,
+    pbrMetallicRoughness: {
+        baseColorFactor: {
+            properties: [
+                new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_COLOR3, "albedoColor", getColor3),
+                new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "alpha", getAlpha),
+            ],
+        },
+        metallicFactor: {
+            properties: [new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "metallic")],
+        },
+        roughnessFactor: {
+            properties: [new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "roughness")],
+        },
+        baseColorTexture: {
+            extensions: {
+                KHR_texture_transform: {
+                    scale: {
+                        properties: [
+                            // MAY introduce set scale(Vector2) into texture.
+                            new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "albedoTexture.uScale"),
+                            new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "albedoTexture.vScale", getNextFloat),
+                        ],
+                    },
+                    offset: {
+                        properties: [
+                            // MAY introduce set offset(Vector2) into texture.
+                            new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "albedoTexture.uOffset"),
+                            new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "albedoTexture.vOffset", getNextFloat),
+                        ],
+                    },
+                    rotation: {
+                        properties: [new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "albedoTexture.wAng", getMinusFloat)],
+                    },
+                },
+            },
+        },
+    },
+    emissiveFactor: {
+        properties: [new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_COLOR3, "emissiveColor", getColor3)],
+    },
+    normalTexture: {
+        scale: {
+            properties: [new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "bumpTexture.level")],
+        },
+    },
+    occlusionTexture: {
+        strength: {
+            properties: [new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "ambientTextureStrength")],
+        },
+        extensions: {
+            KHR_texture_transform: {
+                scale: {
+                    properties: [
+                        // MAY introduce set scale(Vector2) into texture.
+                        new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "ambientTexture.uScale"),
+                        new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "ambientTexture.vScale", getNextFloat),
+                    ],
+                },
+                offset: {
+                    properties: [
+                        // MAY introduce set offset(Vector2) into texture.
+                        new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "ambientTexture.uOffset"),
+                        new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "ambientTexture.vOffset", getNextFloat),
+                    ],
+                },
+                rotation: {
+                    properties: [new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "ambientTexture.wAng", getMinusFloat)],
+                },
+            },
+        },
+    },
+    emissiveTexture: {
+        extensions: {
+            KHR_texture_transform: {
+                scale: {
+                    properties: [
+                        // MAY introduce set scale(Vector2) into texture.
+                        new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "emissiveTexture.uScale"),
+                        new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "emissiveTexture.vScale", getNextFloat),
+                    ],
+                },
+                offset: {
+                    properties: [
+                        // MAY introduce set offset(Vector2) into texture.
+                        new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "emissiveTexture.uOffset"),
+                        new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "emissiveTexture.vOffset", getNextFloat),
+                    ],
+                },
+                rotation: {
+                    properties: [new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "emissiveTexture.wAng", getMinusFloat)],
+                },
+            },
+        },
+    },
+    extensions: {
+        KHR_materials_ior: {
+            ior: {
+                properties: [new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "indexOfRefraction")],
+            },
+        },
+        KHR_materials_clearcoat: {
+            clearcoatFactor: {
+                properties: [new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "clearCoat.intensity")],
+            },
+            clearcoatRoughnessFactor: {
+                properties: [new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "clearCoat.roughness")],
+            },
+        },
+        KHR_materials_sheen: {
+            sheenColorFactor: {
+                properties: [new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_COLOR3, "sheen.color", getColor3)],
+            },
+            sheenRoughnessFactor: {
+                properties: [new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "sheen.roughness")],
+            },
+        },
+        KHR_materials_specular: {
+            specularFactor: {
+                properties: [new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "metallicF0Factor")],
+            },
+            specularColorFactor: {
+                properties: [new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_COLOR3, "metallicReflectanceColor", getColor3)],
+            },
+        },
+        KHR_materials_emissive_strength: {
+            emissiveStrength: {
+                properties: [new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "emissiveIntensity")],
+            },
+        },
+        KHR_materials_transmission: {
+            transmissionFactor: {
+                properties: [new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "subSurface.refractionIntensity")],
+            },
+        },
+        KHR_materials_volume: {
+            attenuationColor: {
+                properties: [new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_COLOR3, "subSurface.tintColor", getColor3)],
+            },
+            attenuationDistance: {
+                properties: [new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "subSurface.tintColorAtDistance")],
+            },
+            thicknessFactor: {
+                properties: [new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "subSurface.maximumThickness")],
+            },
+        },
+        KHR_materials_iridescence: {
+            iridescenceFactor: {
+                properties: [new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "iridescence.intensity")],
+            },
+            iridescenceIor: {
+                properties: [new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "iridescence.indexOfRefraction")],
+            },
+            iridescenceThicknessMinimum: {
+                properties: [new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "iridescence.minimumThickness")],
+            },
+            iridescenceThicknessMaximum: {
+                properties: [new MaterialAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "iridescence.maximumThickness")],
+            },
+        },
+    },
+};
+var CoreAnimationExtensionsPointerMap = {
+    getTarget: getGltfExtension,
+    KHR_lights_punctual: {
+        isIndex: true,
+        lights: {
+            hasIndex: true,
+            color: {
+                properties: [new LightAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_COLOR3, "diffuse", getColor3)],
+            },
+            intensity: {
+                properties: [new LightAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "intensity")],
+            },
+            range: {
+                properties: [new LightAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "range")],
+            },
+            spot: {
+                innerConeAngle: {
+                    properties: [new LightAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "innerAngle", getFloatBy2)],
+                },
+                outerConeAngle: {
+                    properties: [new LightAnimationPointerPropertyInfos(core_Animations_animation__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_FLOAT, "angle", getFloatBy2)],
+                },
+            },
+        },
+    },
+};
+var CoreAnimationPointerMap = {
+    nodes: CoreAnimationNodesPointerMap,
+    materials: CoreAnimationMaterialsPointerMap,
+    cameras: CoreAnimationCamerasPointerMap,
+    extensions: CoreAnimationExtensionsPointerMap,
+};
+
+
 /***/ }),
 
 /***/ "../../../lts/loaders/dist/glTF/2.0/Extensions/KHR_draco_mesh_compression.js":
@@ -968,6 +1767,7 @@ var KHR_lights = /** @class */ (function () {
                 babylonLight.range = light.range == undefined ? Number.MAX_VALUE : light.range;
                 babylonLight.parent = babylonMesh;
                 _this._loader._babylonLights.push(babylonLight);
+                light._babylonLight = babylonLight;
                 _glTFLoader__WEBPACK_IMPORTED_MODULE_1__.GLTFLoader.AddPointerMetadata(babylonLight, extensionContext);
                 assign(babylonMesh);
             });
@@ -3483,7 +4283,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "EXT_mesh_gpu_instancing": () => (/* reexport safe */ _EXT_mesh_gpu_instancing__WEBPACK_IMPORTED_MODULE_1__.EXT_mesh_gpu_instancing),
 /* harmony export */   "EXT_meshopt_compression": () => (/* reexport safe */ _EXT_meshopt_compression__WEBPACK_IMPORTED_MODULE_2__.EXT_meshopt_compression),
 /* harmony export */   "EXT_texture_webp": () => (/* reexport safe */ _EXT_texture_webp__WEBPACK_IMPORTED_MODULE_3__.EXT_texture_webp),
-/* harmony export */   "ExtrasAsMetadata": () => (/* reexport safe */ _ExtrasAsMetadata__WEBPACK_IMPORTED_MODULE_26__.ExtrasAsMetadata),
+/* harmony export */   "ExtrasAsMetadata": () => (/* reexport safe */ _ExtrasAsMetadata__WEBPACK_IMPORTED_MODULE_27__.ExtrasAsMetadata),
+/* harmony export */   "KHR_animation_pointer": () => (/* reexport safe */ _KHR_animation_pointer__WEBPACK_IMPORTED_MODULE_22__.KHR_animation_pointer),
 /* harmony export */   "KHR_draco_mesh_compression": () => (/* reexport safe */ _KHR_draco_mesh_compression__WEBPACK_IMPORTED_MODULE_4__.KHR_draco_mesh_compression),
 /* harmony export */   "KHR_lights": () => (/* reexport safe */ _KHR_lights_punctual__WEBPACK_IMPORTED_MODULE_5__.KHR_lights),
 /* harmony export */   "KHR_materials_clearcoat": () => (/* reexport safe */ _KHR_materials_clearcoat__WEBPACK_IMPORTED_MODULE_8__.KHR_materials_clearcoat),
@@ -3502,10 +4303,10 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "KHR_texture_basisu": () => (/* reexport safe */ _KHR_texture_basisu__WEBPACK_IMPORTED_MODULE_19__.KHR_texture_basisu),
 /* harmony export */   "KHR_texture_transform": () => (/* reexport safe */ _KHR_texture_transform__WEBPACK_IMPORTED_MODULE_20__.KHR_texture_transform),
 /* harmony export */   "KHR_xmp_json_ld": () => (/* reexport safe */ _KHR_xmp_json_ld__WEBPACK_IMPORTED_MODULE_21__.KHR_xmp_json_ld),
-/* harmony export */   "MSFT_audio_emitter": () => (/* reexport safe */ _MSFT_audio_emitter__WEBPACK_IMPORTED_MODULE_22__.MSFT_audio_emitter),
-/* harmony export */   "MSFT_lod": () => (/* reexport safe */ _MSFT_lod__WEBPACK_IMPORTED_MODULE_23__.MSFT_lod),
-/* harmony export */   "MSFT_minecraftMesh": () => (/* reexport safe */ _MSFT_minecraftMesh__WEBPACK_IMPORTED_MODULE_24__.MSFT_minecraftMesh),
-/* harmony export */   "MSFT_sRGBFactors": () => (/* reexport safe */ _MSFT_sRGBFactors__WEBPACK_IMPORTED_MODULE_25__.MSFT_sRGBFactors)
+/* harmony export */   "MSFT_audio_emitter": () => (/* reexport safe */ _MSFT_audio_emitter__WEBPACK_IMPORTED_MODULE_23__.MSFT_audio_emitter),
+/* harmony export */   "MSFT_lod": () => (/* reexport safe */ _MSFT_lod__WEBPACK_IMPORTED_MODULE_24__.MSFT_lod),
+/* harmony export */   "MSFT_minecraftMesh": () => (/* reexport safe */ _MSFT_minecraftMesh__WEBPACK_IMPORTED_MODULE_25__.MSFT_minecraftMesh),
+/* harmony export */   "MSFT_sRGBFactors": () => (/* reexport safe */ _MSFT_sRGBFactors__WEBPACK_IMPORTED_MODULE_26__.MSFT_sRGBFactors)
 /* harmony export */ });
 /* harmony import */ var _EXT_lights_image_based__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./EXT_lights_image_based */ "../../../lts/loaders/dist/glTF/2.0/Extensions/EXT_lights_image_based.js");
 /* harmony import */ var _EXT_mesh_gpu_instancing__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./EXT_mesh_gpu_instancing */ "../../../lts/loaders/dist/glTF/2.0/Extensions/EXT_mesh_gpu_instancing.js");
@@ -3529,11 +4330,13 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _KHR_texture_basisu__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(/*! ./KHR_texture_basisu */ "../../../lts/loaders/dist/glTF/2.0/Extensions/KHR_texture_basisu.js");
 /* harmony import */ var _KHR_texture_transform__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(/*! ./KHR_texture_transform */ "../../../lts/loaders/dist/glTF/2.0/Extensions/KHR_texture_transform.js");
 /* harmony import */ var _KHR_xmp_json_ld__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(/*! ./KHR_xmp_json_ld */ "../../../lts/loaders/dist/glTF/2.0/Extensions/KHR_xmp_json_ld.js");
-/* harmony import */ var _MSFT_audio_emitter__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__(/*! ./MSFT_audio_emitter */ "../../../lts/loaders/dist/glTF/2.0/Extensions/MSFT_audio_emitter.js");
-/* harmony import */ var _MSFT_lod__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__(/*! ./MSFT_lod */ "../../../lts/loaders/dist/glTF/2.0/Extensions/MSFT_lod.js");
-/* harmony import */ var _MSFT_minecraftMesh__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__(/*! ./MSFT_minecraftMesh */ "../../../lts/loaders/dist/glTF/2.0/Extensions/MSFT_minecraftMesh.js");
-/* harmony import */ var _MSFT_sRGBFactors__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__(/*! ./MSFT_sRGBFactors */ "../../../lts/loaders/dist/glTF/2.0/Extensions/MSFT_sRGBFactors.js");
-/* harmony import */ var _ExtrasAsMetadata__WEBPACK_IMPORTED_MODULE_26__ = __webpack_require__(/*! ./ExtrasAsMetadata */ "../../../lts/loaders/dist/glTF/2.0/Extensions/ExtrasAsMetadata.js");
+/* harmony import */ var _KHR_animation_pointer__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__(/*! ./KHR_animation_pointer */ "../../../lts/loaders/dist/glTF/2.0/Extensions/KHR_animation_pointer.js");
+/* harmony import */ var _MSFT_audio_emitter__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__(/*! ./MSFT_audio_emitter */ "../../../lts/loaders/dist/glTF/2.0/Extensions/MSFT_audio_emitter.js");
+/* harmony import */ var _MSFT_lod__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__(/*! ./MSFT_lod */ "../../../lts/loaders/dist/glTF/2.0/Extensions/MSFT_lod.js");
+/* harmony import */ var _MSFT_minecraftMesh__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__(/*! ./MSFT_minecraftMesh */ "../../../lts/loaders/dist/glTF/2.0/Extensions/MSFT_minecraftMesh.js");
+/* harmony import */ var _MSFT_sRGBFactors__WEBPACK_IMPORTED_MODULE_26__ = __webpack_require__(/*! ./MSFT_sRGBFactors */ "../../../lts/loaders/dist/glTF/2.0/Extensions/MSFT_sRGBFactors.js");
+/* harmony import */ var _ExtrasAsMetadata__WEBPACK_IMPORTED_MODULE_27__ = __webpack_require__(/*! ./ExtrasAsMetadata */ "../../../lts/loaders/dist/glTF/2.0/Extensions/ExtrasAsMetadata.js");
+
 
 
 
@@ -3598,8 +4401,6 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
-
-
 
 
 
@@ -4806,6 +5607,8 @@ var GLTFLoader = /** @class */ (function () {
         GLTFLoader.AddPointerMetadata(babylonCamera, context);
         this._parent.onCameraLoadedObservable.notifyObservers(babylonCamera);
         assign(babylonCamera);
+        // register the camera to be used later.
+        camera._babylonCamera = babylonCamera;
         this.logClose();
         return Promise.all(promises).then(function () {
             return babylonCamera;
@@ -4835,217 +5638,33 @@ var GLTFLoader = /** @class */ (function () {
      * @returns A promise that resolves with the loaded Babylon animation group when the load is complete
      */
     GLTFLoader.prototype.loadAnimationAsync = function (context, animation) {
-        var promise = this._extensionsLoadAnimationAsync(context, animation);
-        if (promise) {
-            return promise;
+        // turn everything into pointer
+        for (var _i = 0, _a = animation.channels; _i < _a.length; _i++) {
+            var channel = _a[_i];
+            if (channel.target.path == "pointer" /* POINTER */) {
+                continue;
+            }
+            // decorate the channel with a KHR_animation_pointer extension.
+            channel.target.extensions = channel.target.extensions || {};
+            channel.target.extensions.KHR_animation_pointer = {
+                pointer: "/nodes/".concat(channel.target.node, "/").concat(channel.target.path),
+            };
+            channel.target.path = "pointer" /* POINTER */;
+            delete channel.target.node;
+            // ensure to declare extension used.
+            this._gltf.extensionsUsed = this._gltf.extensionsUsed || [];
+            if (this._gltf.extensionsUsed.indexOf(GLTFLoader._KHRAnimationPointerName) === -1) {
+                this._gltf.extensionsUsed.push(GLTFLoader._KHRAnimationPointerName);
+            }
         }
+        // create the animation group to be passed to extension.
         this._babylonScene._blockEntityCollection = !!this._assetContainer;
         var babylonAnimationGroup = new core_Misc_deferred__WEBPACK_IMPORTED_MODULE_0__.AnimationGroup(animation.name || "animation".concat(animation.index), this._babylonScene);
         babylonAnimationGroup._parentContainer = this._assetContainer;
         this._babylonScene._blockEntityCollection = false;
         animation._babylonAnimationGroup = babylonAnimationGroup;
-        var promises = new Array();
-        ArrayItem.Assign(animation.channels);
-        ArrayItem.Assign(animation.samplers);
-        for (var _i = 0, _a = animation.channels; _i < _a.length; _i++) {
-            var channel = _a[_i];
-            promises.push(this._loadAnimationChannelAsync("".concat(context, "/channels/").concat(channel.index), context, animation, channel, babylonAnimationGroup));
-        }
-        return Promise.all(promises).then(function () {
-            babylonAnimationGroup.normalize(0);
-            return babylonAnimationGroup;
-        });
-    };
-    /**
-     * @hidden Loads a glTF animation channel.
-     * @param context The context when loading the asset
-     * @param animationContext The context of the animation when loading the asset
-     * @param animation The glTF animation property
-     * @param channel The glTF animation channel property
-     * @param babylonAnimationGroup The babylon animation group property
-     * @param animationTargetOverride The babylon animation channel target override property. My be null.
-     * @returns A void promise when the channel load is complete
-     */
-    GLTFLoader.prototype._loadAnimationChannelAsync = function (context, animationContext, animation, channel, babylonAnimationGroup, animationTargetOverride) {
-        var _this = this;
-        if (animationTargetOverride === void 0) { animationTargetOverride = null; }
-        if (channel.target.node == undefined) {
-            return Promise.resolve();
-        }
-        var targetNode = ArrayItem.Get("".concat(context, "/target/node"), this._gltf.nodes, channel.target.node);
-        // Ignore animations that have no animation targets.
-        if ((channel.target.path === "weights" /* WEIGHTS */ && !targetNode._numMorphTargets) ||
-            (channel.target.path !== "weights" /* WEIGHTS */ && !targetNode._babylonTransformNode)) {
-            return Promise.resolve();
-        }
-        var sampler = ArrayItem.Get("".concat(context, "/sampler"), animation.samplers, channel.sampler);
-        return this._loadAnimationSamplerAsync("".concat(animationContext, "/samplers/").concat(channel.sampler), sampler).then(function (data) {
-            var targetPath;
-            var animationType;
-            switch (channel.target.path) {
-                case "translation" /* TRANSLATION */: {
-                    targetPath = "position";
-                    animationType = core_Misc_deferred__WEBPACK_IMPORTED_MODULE_0__.Animation.ANIMATIONTYPE_VECTOR3;
-                    break;
-                }
-                case "rotation" /* ROTATION */: {
-                    targetPath = "rotationQuaternion";
-                    animationType = core_Misc_deferred__WEBPACK_IMPORTED_MODULE_0__.Animation.ANIMATIONTYPE_QUATERNION;
-                    break;
-                }
-                case "scale" /* SCALE */: {
-                    targetPath = "scaling";
-                    animationType = core_Misc_deferred__WEBPACK_IMPORTED_MODULE_0__.Animation.ANIMATIONTYPE_VECTOR3;
-                    break;
-                }
-                case "weights" /* WEIGHTS */: {
-                    targetPath = "influence";
-                    animationType = core_Misc_deferred__WEBPACK_IMPORTED_MODULE_0__.Animation.ANIMATIONTYPE_FLOAT;
-                    break;
-                }
-                default: {
-                    throw new Error("".concat(context, "/target/path: Invalid value (").concat(channel.target.path, ")"));
-                }
-            }
-            var outputBufferOffset = 0;
-            var getNextOutputValue;
-            switch (targetPath) {
-                case "position": {
-                    getNextOutputValue = function (scale) {
-                        var value = core_Misc_deferred__WEBPACK_IMPORTED_MODULE_0__.Vector3.FromArray(data.output, outputBufferOffset).scaleInPlace(scale);
-                        outputBufferOffset += 3;
-                        return value;
-                    };
-                    break;
-                }
-                case "rotationQuaternion": {
-                    getNextOutputValue = function (scale) {
-                        var value = core_Misc_deferred__WEBPACK_IMPORTED_MODULE_0__.Quaternion.FromArray(data.output, outputBufferOffset).scaleInPlace(scale);
-                        outputBufferOffset += 4;
-                        return value;
-                    };
-                    break;
-                }
-                case "scaling": {
-                    getNextOutputValue = function (scale) {
-                        var value = core_Misc_deferred__WEBPACK_IMPORTED_MODULE_0__.Vector3.FromArray(data.output, outputBufferOffset).scaleInPlace(scale);
-                        outputBufferOffset += 3;
-                        return value;
-                    };
-                    break;
-                }
-                case "influence": {
-                    getNextOutputValue = function (scale) {
-                        var value = new Array(targetNode._numMorphTargets);
-                        for (var i = 0; i < targetNode._numMorphTargets; i++) {
-                            value[i] = data.output[outputBufferOffset++] * scale;
-                        }
-                        return value;
-                    };
-                    break;
-                }
-            }
-            var getNextKey;
-            switch (data.interpolation) {
-                case "STEP" /* STEP */: {
-                    getNextKey = function (frameIndex) { return ({
-                        frame: data.input[frameIndex] * _this.parent.targetFps,
-                        value: getNextOutputValue(1),
-                        interpolation: core_Misc_deferred__WEBPACK_IMPORTED_MODULE_0__.AnimationKeyInterpolation.STEP,
-                    }); };
-                    break;
-                }
-                case "LINEAR" /* LINEAR */: {
-                    getNextKey = function (frameIndex) { return ({
-                        frame: data.input[frameIndex] * _this.parent.targetFps,
-                        value: getNextOutputValue(1),
-                    }); };
-                    break;
-                }
-                case "CUBICSPLINE" /* CUBICSPLINE */: {
-                    var invTargetFps_1 = 1 / _this.parent.targetFps;
-                    getNextKey = function (frameIndex) { return ({
-                        frame: data.input[frameIndex] * _this.parent.targetFps,
-                        inTangent: getNextOutputValue(invTargetFps_1),
-                        value: getNextOutputValue(1),
-                        outTangent: getNextOutputValue(invTargetFps_1),
-                    }); };
-                    break;
-                }
-            }
-            var keys = new Array(data.input.length);
-            for (var frameIndex = 0; frameIndex < data.input.length; frameIndex++) {
-                keys[frameIndex] = getNextKey(frameIndex);
-            }
-            if (targetPath === "influence") {
-                var _loop_2 = function (targetIndex) {
-                    var animationName = "".concat(babylonAnimationGroup.name, "_channel").concat(babylonAnimationGroup.targetedAnimations.length);
-                    var babylonAnimation = new core_Misc_deferred__WEBPACK_IMPORTED_MODULE_0__.Animation(animationName, targetPath, _this.parent.targetFps, animationType);
-                    babylonAnimation.setKeys(keys.map(function (key) { return ({
-                        frame: key.frame,
-                        inTangent: key.inTangent ? key.inTangent[targetIndex] : undefined,
-                        value: key.value[targetIndex],
-                        outTangent: key.outTangent ? key.outTangent[targetIndex] : undefined,
-                        interpolation: key.interpolation,
-                    }); }));
-                    _this._forEachPrimitive(targetNode, function (babylonAbstractMesh) {
-                        var babylonMesh = babylonAbstractMesh;
-                        if (babylonMesh.morphTargetManager) {
-                            var morphTarget = babylonMesh.morphTargetManager.getTarget(targetIndex);
-                            var babylonAnimationClone = babylonAnimation.clone();
-                            morphTarget.animations.push(babylonAnimationClone);
-                            babylonAnimationGroup.addTargetedAnimation(babylonAnimationClone, morphTarget);
-                        }
-                    });
-                };
-                for (var targetIndex = 0; targetIndex < targetNode._numMorphTargets; targetIndex++) {
-                    _loop_2(targetIndex);
-                }
-            }
-            else {
-                var animationName = "".concat(babylonAnimationGroup.name, "_channel").concat(babylonAnimationGroup.targetedAnimations.length);
-                var babylonAnimation = new core_Misc_deferred__WEBPACK_IMPORTED_MODULE_0__.Animation(animationName, targetPath, _this.parent.targetFps, animationType);
-                babylonAnimation.setKeys(keys);
-                if (animationTargetOverride != null && animationTargetOverride.animations != null) {
-                    animationTargetOverride.animations.push(babylonAnimation);
-                    babylonAnimationGroup.addTargetedAnimation(babylonAnimation, animationTargetOverride);
-                }
-                else {
-                    targetNode._babylonTransformNode.animations.push(babylonAnimation);
-                    babylonAnimationGroup.addTargetedAnimation(babylonAnimation, targetNode._babylonTransformNode);
-                }
-            }
-        });
-    };
-    GLTFLoader.prototype._loadAnimationSamplerAsync = function (context, sampler) {
-        if (sampler._data) {
-            return sampler._data;
-        }
-        var interpolation = sampler.interpolation || "LINEAR" /* LINEAR */;
-        switch (interpolation) {
-            case "STEP" /* STEP */:
-            case "LINEAR" /* LINEAR */:
-            case "CUBICSPLINE" /* CUBICSPLINE */: {
-                break;
-            }
-            default: {
-                throw new Error("".concat(context, "/interpolation: Invalid value (").concat(sampler.interpolation, ")"));
-            }
-        }
-        var inputAccessor = ArrayItem.Get("".concat(context, "/input"), this._gltf.accessors, sampler.input);
-        var outputAccessor = ArrayItem.Get("".concat(context, "/output"), this._gltf.accessors, sampler.output);
-        sampler._data = Promise.all([
-            this._loadFloatAccessorAsync("/accessors/".concat(inputAccessor.index), inputAccessor),
-            this._loadFloatAccessorAsync("/accessors/".concat(outputAccessor.index), outputAccessor),
-        ]).then(function (_a) {
-            var inputData = _a[0], outputData = _a[1];
-            return {
-                input: inputData,
-                interpolation: interpolation,
-                output: outputData,
-            };
-        });
-        return sampler._data;
+        var promise = this._extensionsLoadAnimationAsync(context, animation);
+        return promise !== null && promise !== void 0 ? promise : Promise.resolve(animation._babylonAnimationGroup);
     };
     /**
      * Loads a glTF buffer.
@@ -5973,6 +6592,10 @@ var GLTFLoader = /** @class */ (function () {
     GLTFLoader.prototype.endPerformanceCounter = function (counterName) {
         this._parent._endPerformanceCounter(counterName);
     };
+    /** @hidden */
+    // note : KHR_animation_pointer is used to load animation in ALL case, turning everything
+    // into pointer. This is the reason why this value is located here.
+    GLTFLoader._KHRAnimationPointerName = "KHR_animation_pointer";
     GLTFLoader._RegisteredExtensions = {};
     /**
      * The default glTF sampler.
@@ -6008,6 +6631,42 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+/***/ }),
+
+/***/ "../../../lts/loaders/dist/glTF/2.0/glTFUtilities.js":
+/*!***********************************************************!*\
+  !*** ../../../lts/loaders/dist/glTF/2.0/glTFUtilities.js ***!
+  \***********************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "getDataAccessorElementCount": () => (/* binding */ getDataAccessorElementCount)
+/* harmony export */ });
+/**
+ * Used internally to determine how much data to be gather from input buffer at each key frame.
+ * @param accessorType the accessor type
+ * @returns the number of item to be gather at each keyframe
+ */
+function getDataAccessorElementCount(accessorType) {
+    switch (accessorType) {
+        case "SCALAR" /* SCALAR */:
+            return 1;
+        case "VEC2" /* VEC2 */:
+            return 2;
+        case "VEC3" /* VEC3 */:
+            return 3;
+        case "VEC4" /* VEC4 */:
+        case "MAT2" /* MAT2 */:
+            return 4;
+        case "MAT3" /* MAT3 */:
+            return 9;
+        case "MAT4" /* MAT4 */:
+            return 16;
+    }
+}
+
+
 /***/ }),
 
 /***/ "../../../lts/loaders/dist/glTF/2.0/index.js":
@@ -6025,6 +6684,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "EXT_texture_webp": () => (/* reexport safe */ _Extensions_index__WEBPACK_IMPORTED_MODULE_3__.EXT_texture_webp),
 /* harmony export */   "ExtrasAsMetadata": () => (/* reexport safe */ _Extensions_index__WEBPACK_IMPORTED_MODULE_3__.ExtrasAsMetadata),
 /* harmony export */   "GLTFLoader": () => (/* reexport safe */ _glTFLoader__WEBPACK_IMPORTED_MODULE_0__.GLTFLoader),
+/* harmony export */   "KHR_animation_pointer": () => (/* reexport safe */ _Extensions_index__WEBPACK_IMPORTED_MODULE_3__.KHR_animation_pointer),
 /* harmony export */   "KHR_draco_mesh_compression": () => (/* reexport safe */ _Extensions_index__WEBPACK_IMPORTED_MODULE_3__.KHR_draco_mesh_compression),
 /* harmony export */   "KHR_lights": () => (/* reexport safe */ _Extensions_index__WEBPACK_IMPORTED_MODULE_3__.KHR_lights),
 /* harmony export */   "KHR_materials_clearcoat": () => (/* reexport safe */ _Extensions_index__WEBPACK_IMPORTED_MODULE_3__.KHR_materials_clearcoat),