@fps-games/editor 0.2.0-beta.3 → 0.2.1-beta.1

package/node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_animation_pointer.d.ts

@@ -0,0 +1,47 @@
+import type { IGLTFLoaderExtension } from "../glTFLoaderExtension.js";
+import type { GLTFLoader } from "../glTFLoader.js";
+import type { Nullable } from "@babylonjs/core/types.js";
+import type { Animation } from "@babylonjs/core/Animations/animation.js";
+import type { IAnimatable } from "@babylonjs/core/Animations/animatable.interface.js";
+import type { IAnimation, IAnimationChannel } from "../glTFLoaderInterfaces.js";
+import "./KHR_animation_pointer.data.js";
+declare module "../../glTFFileLoader.js" {
+    interface GLTFLoaderExtensionOptions {
+        /**
+         * Defines options for the KHR_animation_pointer extension.
+         */
+        ["KHR_animation_pointer"]: {};
+    }
+}
+/**
+ * [Specification PR](https://github.com/KhronosGroup/glTF/pull/2147)
+ * !!! Experimental Extension Subject to Changes !!!
+ */
+export declare class KHR_animation_pointer implements IGLTFLoaderExtension {
+    /**
+     * The name of this extension.
+     */
+    readonly name = "KHR_animation_pointer";
+    private _loader;
+    private _pathToObjectConverter?;
+    /**
+     * @internal
+     */
+    constructor(loader: GLTFLoader);
+    /**
+     * Defines whether this extension is enabled.
+     */
+    get enabled(): boolean;
+    /** @internal */
+    dispose(): void;
+    /**
+     * 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 onLoad Called for each animation loaded
+     * @returns A void promise that resolves when the load is complete or null if not handled
+     */
+    _loadAnimationChannelAsync(context: string, animationContext: string, animation: IAnimation, channel: IAnimationChannel, onLoad: (babylonAnimatable: IAnimatable, babylonAnimation: Animation) => void): Nullable<Promise<void>>;
+}

package/node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_animation_pointer.data.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_animation_pointer.data.js

@@ -0,0 +1,251 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { Animation } from "@babylonjs/core/Animations/animation.js";
+import { AnimationPropertyInfo } from "../glTFLoaderAnimation.js";
+import { Color3 } from "@babylonjs/core/Maths/math.color.js";
+import { SetInterpolationForKey } from "./objectModelMapping.js";
+function getColor3(_target, source, offset, scale) {
+    return Color3.FromArray(source, offset).scale(scale);
+}
+function getAlpha(_target, source, offset, scale) {
+    return source[offset + 3] * scale;
+}
+function getFloat(_target, source, offset, scale) {
+    return source[offset] * scale;
+}
+function getMinusFloat(_target, source, offset, scale) {
+    return -source[offset] * scale;
+}
+function getNextFloat(_target, source, offset, scale) {
+    return source[offset + 1] * scale;
+}
+function getFloatBy2(_target, source, offset, scale) {
+    return source[offset] * scale * 2;
+}
+function getTextureTransformTree(textureName) {
+    return {
+        scale: [
+            new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, `${textureName}.uScale`, getFloat, () => 2),
+            new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, `${textureName}.vScale`, getNextFloat, () => 2),
+        ],
+        offset: [
+            new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, `${textureName}.uOffset`, getFloat, () => 2),
+            new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, `${textureName}.vOffset`, getNextFloat, () => 2),
+        ],
+        rotation: [new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, `${textureName}.wAng`, getMinusFloat, () => 1)],
+    };
+}
+class CameraAnimationPropertyInfo extends AnimationPropertyInfo {
+    /** @internal */
+    buildAnimations(target, name, fps, keys) {
+        return [{ babylonAnimatable: target._babylonCamera, babylonAnimation: this._buildAnimation(name, fps, keys) }];
+    }
+}
+class MaterialAnimationPropertyInfo extends AnimationPropertyInfo {
+    /** @internal */
+    buildAnimations(target, name, fps, keys) {
+        const babylonAnimations = [];
+        for (const fillMode in target._data) {
+            babylonAnimations.push({
+                babylonAnimatable: target._data[fillMode].babylonMaterial,
+                babylonAnimation: this._buildAnimation(name, fps, keys),
+            });
+        }
+        return babylonAnimations;
+    }
+}
+class LightAnimationPropertyInfo extends AnimationPropertyInfo {
+    /** @internal */
+    buildAnimations(target, name, fps, keys) {
+        return [{ babylonAnimatable: target._babylonLight, babylonAnimation: this._buildAnimation(name, fps, keys) }];
+    }
+}
+class MeshAnimationPropertyInfo extends AnimationPropertyInfo {
+    /** @internal */
+    buildAnimations(target, name, fps, keys) {
+        return target._primitiveBabylonMeshes
+            ? target._primitiveBabylonMeshes.map((mesh) => ({ babylonAnimatable: mesh, babylonAnimation: this._buildAnimation(name, fps, keys) }))
+            : [];
+    }
+}
+SetInterpolationForKey("/cameras/{}/orthographic/xmag", [
+    new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "orthoLeft", getMinusFloat, () => 1),
+    new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "orthoRight", getNextFloat, () => 1),
+]);
+SetInterpolationForKey("/cameras/{}/orthographic/ymag", [
+    new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "orthoBottom", getMinusFloat, () => 1),
+    new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "orthoTop", getNextFloat, () => 1),
+]);
+SetInterpolationForKey("/cameras/{}/orthographic/zfar", [new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "maxZ", getFloat, () => 1)]);
+SetInterpolationForKey("/cameras/{}/orthographic/znear", [new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "minZ", getFloat, () => 1)]);
+SetInterpolationForKey("/cameras/{}/perspective/yfov", [new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "fov", getFloat, () => 1)]);
+SetInterpolationForKey("/cameras/{}/perspective/zfar", [new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "maxZ", getFloat, () => 1)]);
+SetInterpolationForKey("/cameras/{}/perspective/znear", [new CameraAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "minZ", getFloat, () => 1)]);
+// add interpolation to the materials mapping
+SetInterpolationForKey("/materials/{}/pbrMetallicRoughness/baseColorFactor", [
+    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_COLOR3, "albedoColor", getColor3, () => 4),
+    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "alpha", getAlpha, () => 4),
+]);
+SetInterpolationForKey("/materials/{}/pbrMetallicRoughness/metallicFactor", [new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "metallic", getFloat, () => 1)]);
+SetInterpolationForKey("/materials/{}/pbrMetallicRoughness/metallicFactor", [new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "roughness", getFloat, () => 1)]);
+const baseColorTextureInterpolation = getTextureTransformTree("albedoTexture");
+SetInterpolationForKey("/materials/{}/pbrMetallicRoughness/baseColorTexture/extensions/KHR_texture_transform/scale", baseColorTextureInterpolation.scale);
+SetInterpolationForKey("/materials/{}/pbrMetallicRoughness/baseColorTexture/extensions/KHR_texture_transform/offset", baseColorTextureInterpolation.offset);
+SetInterpolationForKey("/materials/{}/pbrMetallicRoughness/baseColorTexture/extensions/KHR_texture_transform/rotation", baseColorTextureInterpolation.rotation);
+const metallicRoughnessTextureInterpolation = getTextureTransformTree("metallicTexture");
+SetInterpolationForKey("//materials/{}/pbrMetallicRoughness/metallicRoughnessTexture/scale", metallicRoughnessTextureInterpolation.scale);
+SetInterpolationForKey("//materials/{}/pbrMetallicRoughness/metallicRoughnessTexture/offset", metallicRoughnessTextureInterpolation.offset);
+SetInterpolationForKey("//materials/{}/pbrMetallicRoughness/metallicRoughnessTexture/rotation", metallicRoughnessTextureInterpolation.rotation);
+SetInterpolationForKey("/materials/{}/emissiveFactor", [new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_COLOR3, "emissiveColor", getColor3, () => 3)]);
+const normalTextureInterpolation = getTextureTransformTree("bumpTexture");
+SetInterpolationForKey("/materials/{}/normalTexture/scale", [new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "bumpTexture.level", getFloat, () => 1)]);
+SetInterpolationForKey("/materials/{}/normalTexture/extensions/KHR_texture_transform/scale", normalTextureInterpolation.scale);
+SetInterpolationForKey("/materials/{}/normalTexture/extensions/KHR_texture_transform/offset", normalTextureInterpolation.offset);
+SetInterpolationForKey("/materials/{}/normalTexture/extensions/KHR_texture_transform/rotation", normalTextureInterpolation.rotation);
+SetInterpolationForKey("/materials/{}/occlusionTexture/strength", [new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "ambientTextureStrength", getFloat, () => 1)]);
+const occlusionTextureInterpolation = getTextureTransformTree("ambientTexture");
+SetInterpolationForKey("/materials/{}/occlusionTexture/extensions/KHR_texture_transform/scale", occlusionTextureInterpolation.scale);
+SetInterpolationForKey("/materials/{}/occlusionTexture/extensions/KHR_texture_transform/offset", occlusionTextureInterpolation.offset);
+SetInterpolationForKey("/materials/{}/occlusionTexture/extensions/KHR_texture_transform/rotation", occlusionTextureInterpolation.rotation);
+const emissiveTextureInterpolation = getTextureTransformTree("emissiveTexture");
+SetInterpolationForKey("/materials/{}/emissiveTexture/extensions/KHR_texture_transform/scale", emissiveTextureInterpolation.scale);
+SetInterpolationForKey("/materials/{}/emissiveTexture/extensions/KHR_texture_transform/offset", emissiveTextureInterpolation.offset);
+SetInterpolationForKey("/materials/{}/emissiveTexture/extensions/KHR_texture_transform/rotation", emissiveTextureInterpolation.rotation);
+// materials extensions
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_anisotropy/anisotropyStrength", [
+    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "anisotropy.intensity", getFloat, () => 1),
+]);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_anisotropy/anisotropyRotation", [
+    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "anisotropy.angle", getFloat, () => 1),
+]);
+const anisotropyTextureInterpolation = getTextureTransformTree("anisotropy.texture");
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_anisotropy/anisotropyTexture/extensions/KHR_texture_transform/scale", anisotropyTextureInterpolation.scale);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_anisotropy/anisotropyTexture/extensions/KHR_texture_transform/offset", anisotropyTextureInterpolation.offset);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_anisotropy/anisotropyTexture/extensions/KHR_texture_transform/rotation", anisotropyTextureInterpolation.rotation);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_clearcoat/clearcoatFactor", [
+    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "clearCoat.intensity", getFloat, () => 1),
+]);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_clearcoat/clearcoatRoughnessFactor", [
+    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "clearCoat.roughness", getFloat, () => 1),
+]);
+const clearcoatTextureInterpolation = getTextureTransformTree("clearCoat.texture");
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_clearcoat/clearcoatTexture/extensions/KHR_texture_transform/scale", clearcoatTextureInterpolation.scale);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_clearcoat/clearcoatTexture/extensions/KHR_texture_transform/offset", clearcoatTextureInterpolation.offset);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_clearcoat/clearcoatTexture/extensions/KHR_texture_transform/rotation", clearcoatTextureInterpolation.rotation);
+const clearcoatNormalTextureInterpolation = getTextureTransformTree("clearCoat.bumpTexture");
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_clearcoat/clearcoatNormalTexture/scale", [
+    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "clearCoat.bumpTexture.level", getFloat, () => 1),
+]);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_clearcoat/clearcoatNormalTexture/extensions/KHR_texture_transform/scale", clearcoatNormalTextureInterpolation.scale);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_clearcoat/clearcoatNormalTexture/extensions/KHR_texture_transform/offset", clearcoatNormalTextureInterpolation.offset);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_clearcoat/clearcoatNormalTexture/extensions/KHR_texture_transform/rotation", clearcoatNormalTextureInterpolation.rotation);
+const clearcoatRoughnessTextureInterpolation = getTextureTransformTree("clearCoat.textureRoughness");
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_clearcoat/clearcoatRoughnessTexture/extensions/KHR_texture_transform/scale", clearcoatRoughnessTextureInterpolation.scale);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_clearcoat/clearcoatRoughnessTexture/extensions/KHR_texture_transform/offset", clearcoatRoughnessTextureInterpolation.offset);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_clearcoat/clearcoatRoughnessTexture/extensions/KHR_texture_transform/rotation", clearcoatRoughnessTextureInterpolation.rotation);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_dispersion/dispersionFactor", [
+    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "subSurface.dispersion", getFloat, () => 1),
+]);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_emissive_strength/emissiveStrength", [
+    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "emissiveIntensity", getFloat, () => 1),
+]);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_ior/ior", [
+    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "indexOfRefraction", getFloat, () => 1),
+]);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_iridescence/iridescenceFactor", [
+    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "iridescence.intensity", getFloat, () => 1),
+]);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_iridescence/iridescenceIor", [
+    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "iridescence.indexOfRefraction", getFloat, () => 1),
+]);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_iridescence/iridescenceThicknessMinimum", [
+    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "iridescence.minimumThickness", getFloat, () => 1),
+]);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_iridescence/iridescenceThicknessMaximum", [
+    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "iridescence.maximumThickness", getFloat, () => 1),
+]);
+const iridescenceTextureInterpolation = getTextureTransformTree("iridescence.texture");
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_iridescence/iridescenceTexture/extensions/KHR_texture_transform/scale", iridescenceTextureInterpolation.scale);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_iridescence/iridescenceTexture/extensions/KHR_texture_transform/offset", iridescenceTextureInterpolation.offset);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_iridescence/iridescenceTexture/extensions/KHR_texture_transform/rotation", iridescenceTextureInterpolation.rotation);
+const iridescenceThicknessTextureInterpolation = getTextureTransformTree("iridescence.thicknessTexture");
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_iridescence/iridescenceThicknessTexture/extensions/KHR_texture_transform/scale", iridescenceThicknessTextureInterpolation.scale);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_iridescence/iridescenceThicknessTexture/extensions/KHR_texture_transform/offset", iridescenceThicknessTextureInterpolation.offset);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_iridescence/iridescenceThicknessTexture/extensions/KHR_texture_transform/rotation", iridescenceThicknessTextureInterpolation.rotation);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_sheen/sheenColorFactor", [
+    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_COLOR3, "sheen.color", getColor3, () => 3),
+]);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_sheen/sheenRoughnessFactor", [
+    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "sheen.roughness", getFloat, () => 1),
+]);
+const sheenTextureInterpolation = getTextureTransformTree("sheen.texture");
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_sheen/sheenColorTexture/extensions/KHR_texture_transform/scale", sheenTextureInterpolation.scale);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_sheen/sheenColorTexture/extensions/KHR_texture_transform/offset", sheenTextureInterpolation.offset);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_sheen/sheenColorTexture/extensions/KHR_texture_transform/rotation", sheenTextureInterpolation.rotation);
+const sheenRoughnessTextureInterpolation = getTextureTransformTree("sheen.textureRoughness");
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_sheen/sheenRoughnessTexture/extensions/KHR_texture_transform/scale", sheenRoughnessTextureInterpolation.scale);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_sheen/sheenRoughnessTexture/extensions/KHR_texture_transform/offset", sheenRoughnessTextureInterpolation.offset);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_sheen/sheenRoughnessTexture/extensions/KHR_texture_transform/rotation", sheenRoughnessTextureInterpolation.rotation);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_specular/specularFactor", [
+    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "metallicF0Factor", getFloat, () => 1),
+]);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_specular/specularColorFactor", [
+    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_COLOR3, "metallicReflectanceColor", getColor3, () => 3),
+]);
+const specularTextureInterpolation = getTextureTransformTree("metallicReflectanceTexture");
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_specular/specularTexture/extensions/KHR_texture_transform/scale", specularTextureInterpolation.scale);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_specular/specularTexture/extensions/KHR_texture_transform/offset", specularTextureInterpolation.offset);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_specular/specularTexture/extensions/KHR_texture_transform/rotation", specularTextureInterpolation.rotation);
+const specularColorTextureInterpolation = getTextureTransformTree("reflectanceTexture");
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_specular/specularColorTexture/extensions/KHR_texture_transform/scale", specularColorTextureInterpolation.scale);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_specular/specularColorTexture/extensions/KHR_texture_transform/offset", specularColorTextureInterpolation.offset);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_specular/specularColorTexture/extensions/KHR_texture_transform/rotation", specularColorTextureInterpolation.rotation);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_transmission/transmissionFactor", [
+    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "subSurface.refractionIntensity", getFloat, () => 1),
+]);
+const transmissionTextureInterpolation = getTextureTransformTree("subSurface.refractionIntensityTexture");
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_transmission/transmissionTexture/extensions/KHR_texture_transform/scale", transmissionTextureInterpolation.scale);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_transmission/transmissionTexture/extensions/KHR_texture_transform/offset", transmissionTextureInterpolation.offset);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_transmission/transmissionTexture/extensions/KHR_texture_transform/rotation", transmissionTextureInterpolation.rotation);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_volume/attenuationColor", [
+    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_COLOR3, "subSurface.tintColor", getColor3, () => 3),
+]);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_volume/attenuationDistance", [
+    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "subSurface.tintColorAtDistance", getFloat, () => 1),
+]);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_volume/thicknessFactor", [
+    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "subSurface.maximumThickness", getFloat, () => 1),
+]);
+const thicknessTextureInterpolation = getTextureTransformTree("subSurface.thicknessTexture");
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_volume/thicknessTexture/extensions/KHR_texture_transform/scale", thicknessTextureInterpolation.scale);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_volume/thicknessTexture/extensions/KHR_texture_transform/offset", thicknessTextureInterpolation.offset);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_volume/thicknessTexture/extensions/KHR_texture_transform/rotation", thicknessTextureInterpolation.rotation);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_diffuse_transmission/diffuseTransmissionFactor", [
+    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "subSurface.translucencyIntensity", getFloat, () => 1),
+]);
+const diffuseTransmissionTextureInterpolation = getTextureTransformTree("subSurface.translucencyIntensityTexture");
+SetInterpolationForKey("materials/{}/extensions/KHR_materials_diffuse_transmission/diffuseTransmissionTexture/extensions/KHR_texture_transform/scale", diffuseTransmissionTextureInterpolation.scale);
+SetInterpolationForKey("materials/{}/extensions/KHR_materials_diffuse_transmission/diffuseTransmissionTexture/extensions/KHR_texture_transform/offset", diffuseTransmissionTextureInterpolation.offset);
+SetInterpolationForKey("materials/{}/extensions/KHR_materials_diffuse_transmission/diffuseTransmissionTexture/extensions/KHR_texture_transform/rotation", diffuseTransmissionTextureInterpolation.rotation);
+SetInterpolationForKey("/materials/{}/extensions/KHR_materials_diffuse_transmission/diffuseTransmissionColorFactor", [
+    new MaterialAnimationPropertyInfo(Animation.ANIMATIONTYPE_COLOR3, "subSurface.translucencyColor", getColor3, () => 3),
+]);
+const diffuseTransmissionColorTextureInterpolation = getTextureTransformTree("subSurface.translucencyColorTexture");
+SetInterpolationForKey("materials/{}/extensions/KHR_materials_diffuse_transmission/diffuseTransmissionColorTexture/extensions/KHR_texture_transform/scale", diffuseTransmissionColorTextureInterpolation.scale);
+SetInterpolationForKey("materials/{}/extensions/KHR_materials_diffuse_transmission/diffuseTransmissionColorTexture/extensions/KHR_texture_transform/offset", diffuseTransmissionColorTextureInterpolation.offset);
+SetInterpolationForKey("materials/{}/extensions/KHR_materials_diffuse_transmission/diffuseTransmissionColorTexture/extensions/KHR_texture_transform/rotation", diffuseTransmissionColorTextureInterpolation.rotation);
+SetInterpolationForKey("/extensions/KHR_lights_punctual/lights/{}/color", [new LightAnimationPropertyInfo(Animation.ANIMATIONTYPE_COLOR3, "diffuse", getColor3, () => 3)]);
+SetInterpolationForKey("/extensions/KHR_lights_punctual/lights/{}/intensity", [new LightAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "intensity", getFloat, () => 1)]);
+SetInterpolationForKey("/extensions/KHR_lights_punctual/lights/{}/range", [new LightAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "range", getFloat, () => 1)]);
+SetInterpolationForKey("/extensions/KHR_lights_punctual/lights/{}/spot/innerConeAngle", [
+    new LightAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "innerAngle", getFloatBy2, () => 1),
+]);
+SetInterpolationForKey("/extensions/KHR_lights_punctual/lights/{}/spot/outerConeAngle", [
+    new LightAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "angle", getFloatBy2, () => 1),
+]);
+SetInterpolationForKey("/extensions/EXT_lights_area/lights/{}/color", [new LightAnimationPropertyInfo(Animation.ANIMATIONTYPE_COLOR3, "diffuse", getColor3, () => 3)]);
+SetInterpolationForKey("/extensions/EXT_lights_area/lights/{}/intensity", [new LightAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "intensity", getFloat, () => 1)]);
+SetInterpolationForKey("/extensions/EXT_lights_area/lights/{}/size", [new LightAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "radius", getFloat, () => 1)]);
+SetInterpolationForKey("/extensions/EXT_lights_area/lights/{}/rect/aspect", [new LightAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "radius", getFloat, () => 1)]);
+SetInterpolationForKey("/nodes/{}/extensions/EXT_lights_ies/color", [new LightAnimationPropertyInfo(Animation.ANIMATIONTYPE_COLOR3, "diffuse", getColor3, () => 3)]);
+SetInterpolationForKey("/nodes/{}/extensions/EXT_lights_ies/multiplier", [new LightAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "intensity", getFloat, () => 1)]);
+SetInterpolationForKey("/nodes/{}/extensions/KHR_node_visibility/visible", [new MeshAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "isVisible", getFloat, () => 1)]);

package/node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_animation_pointer.js

@@ -0,0 +1,77 @@
+import { Logger } from "@babylonjs/core/Misc/logger.js";
+import { registerGLTFExtension, unregisterGLTFExtension } from "../glTFLoaderExtensionRegistry.js";
+import { GetPathToObjectConverter } from "./objectModelMapping.js";
+import "./KHR_animation_pointer.data.js";
+const NAME = "KHR_animation_pointer";
+/**
+ * [Specification PR](https://github.com/KhronosGroup/glTF/pull/2147)
+ * !!! Experimental Extension Subject to Changes !!!
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export class KHR_animation_pointer {
+    /**
+     * @internal
+     */
+    constructor(loader) {
+        /**
+         * The name of this extension.
+         */
+        this.name = NAME;
+        this._loader = loader;
+        this._pathToObjectConverter = GetPathToObjectConverter(this._loader.gltf);
+    }
+    /**
+     * Defines whether this extension is enabled.
+     */
+    get enabled() {
+        return this._loader.isExtensionUsed(NAME);
+    }
+    /** @internal */
+    dispose() {
+        this._loader = null;
+        delete this._pathToObjectConverter; // GC
+    }
+    /**
+     * 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 onLoad Called for each animation loaded
+     * @returns A void promise that resolves when the load is complete or null if not handled
+     */
+    // eslint-disable-next-line no-restricted-syntax
+    _loadAnimationChannelAsync(context, animationContext, animation, channel, onLoad) {
+        const extension = channel.target.extensions?.KHR_animation_pointer;
+        if (!extension || !this._pathToObjectConverter) {
+            return null;
+        }
+        if (channel.target.path !== "pointer" /* AnimationChannelTargetPath.POINTER */) {
+            Logger.Warn(`${context}/target/path: Value (${channel.target.path}) must be (${"pointer" /* AnimationChannelTargetPath.POINTER */}) when using the ${this.name} extension`);
+        }
+        if (channel.target.node != undefined) {
+            Logger.Warn(`${context}/target/node: Value (${channel.target.node}) must not be present when using the ${this.name} extension`);
+        }
+        const extensionContext = `${context}/extensions/${this.name}`;
+        const pointer = extension.pointer;
+        if (!pointer) {
+            throw new Error(`${extensionContext}: Pointer is missing`);
+        }
+        try {
+            const obj = this._pathToObjectConverter.convert(pointer);
+            if (!obj.info.interpolation) {
+                throw new Error(`${extensionContext}/pointer: Interpolation is missing`);
+            }
+            return this._loader._loadAnimationChannelFromTargetInfoAsync(context, animationContext, animation, channel, {
+                object: obj.object,
+                info: obj.info.interpolation,
+            }, onLoad);
+        }
+        catch (e) {
+            Logger.Warn(`${extensionContext}/pointer: Invalid pointer (${pointer}) skipped`);
+            return null;
+        }
+    }
+}
+unregisterGLTFExtension(NAME);
+registerGLTFExtension(NAME, true, (loader) => new KHR_animation_pointer(loader));

package/node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_draco_mesh_compression.d.ts

@@ -0,0 +1,47 @@
+import { DracoDecoder } from "@babylonjs/core/Meshes/Compression/dracoDecoder.js";
+import type { Nullable } from "@babylonjs/core/types.js";
+import type { Geometry } from "@babylonjs/core/Meshes/geometry.js";
+import type { Mesh } from "@babylonjs/core/Meshes/mesh.js";
+import type { IMeshPrimitive } from "../glTFLoaderInterfaces.js";
+import type { IGLTFLoaderExtension } from "../glTFLoaderExtension.js";
+import { GLTFLoader } from "../glTFLoader.js";
+declare module "../../glTFFileLoader.js" {
+    interface GLTFLoaderExtensionOptions {
+        /**
+         * Defines options for the KHR_draco_mesh_compression extension.
+         */
+        ["KHR_draco_mesh_compression"]: {};
+    }
+}
+/**
+ * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_draco_mesh_compression/README.md)
+ */
+export declare class KHR_draco_mesh_compression implements IGLTFLoaderExtension {
+    /**
+     * The name of this extension.
+     */
+    readonly name = "KHR_draco_mesh_compression";
+    /**
+     * The draco decoder used to decode vertex data or DracoDecoder.Default if not defined
+     */
+    dracoDecoder?: DracoDecoder;
+    /**
+     * Defines whether this extension is enabled.
+     */
+    enabled: boolean;
+    /**
+     * Defines whether to use the normalized flag from the glTF accessor instead of the Draco data. Defaults to true.
+     */
+    useNormalizedFlagFromAccessor: boolean;
+    private _loader;
+    /**
+     * @internal
+     */
+    constructor(loader: GLTFLoader);
+    /** @internal */
+    dispose(): void;
+    /**
+     * @internal
+     */
+    _loadVertexDataAsync(context: string, primitive: IMeshPrimitive, babylonMesh: Mesh): Nullable<Promise<Geometry>>;
+}

package/node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_draco_mesh_compression.js

@@ -0,0 +1,92 @@
+/* eslint-disable github/no-then */
+import { DracoDecoder } from "@babylonjs/core/Meshes/Compression/dracoDecoder.js";
+import { VertexBuffer } from "@babylonjs/core/Buffers/buffer.js";
+import { GLTFLoader, ArrayItem, LoadBoundingInfoFromPositionAccessor } from "../glTFLoader.js";
+import { registerGLTFExtension, unregisterGLTFExtension } from "../glTFLoaderExtensionRegistry.js";
+const NAME = "KHR_draco_mesh_compression";
+/**
+ * [Specification](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_draco_mesh_compression/README.md)
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export class KHR_draco_mesh_compression {
+    /**
+     * @internal
+     */
+    constructor(loader) {
+        /**
+         * The name of this extension.
+         */
+        this.name = NAME;
+        /**
+         * Defines whether to use the normalized flag from the glTF accessor instead of the Draco data. Defaults to true.
+         */
+        this.useNormalizedFlagFromAccessor = true;
+        this._loader = loader;
+        this.enabled = DracoDecoder.DefaultAvailable && this._loader.isExtensionUsed(NAME);
+    }
+    /** @internal */
+    dispose() {
+        delete this.dracoDecoder;
+        this._loader = null;
+    }
+    /**
+     * @internal
+     */
+    // eslint-disable-next-line no-restricted-syntax
+    _loadVertexDataAsync(context, primitive, babylonMesh) {
+        return GLTFLoader.LoadExtensionAsync(context, primitive, this.name, async (extensionContext, extension) => {
+            if (primitive.mode != undefined) {
+                if (primitive.mode !== 4 /* MeshPrimitiveMode.TRIANGLES */ && primitive.mode !== 5 /* MeshPrimitiveMode.TRIANGLE_STRIP */) {
+                    throw new Error(`${context}: Unsupported mode ${primitive.mode}`);
+                }
+            }
+            const attributes = {};
+            const normalized = {};
+            const loadAttribute = (name, kind) => {
+                const uniqueId = extension.attributes[name];
+                if (uniqueId == undefined) {
+                    return;
+                }
+                babylonMesh._delayInfo = babylonMesh._delayInfo || [];
+                if (babylonMesh._delayInfo.indexOf(kind) === -1) {
+                    babylonMesh._delayInfo.push(kind);
+                }
+                attributes[kind] = uniqueId;
+                if (this.useNormalizedFlagFromAccessor) {
+                    const accessor = ArrayItem.TryGet(this._loader.gltf.accessors, primitive.attributes[name]);
+                    if (accessor) {
+                        normalized[kind] = accessor.normalized || false;
+                    }
+                }
+            };
+            loadAttribute("POSITION", VertexBuffer.PositionKind);
+            loadAttribute("NORMAL", VertexBuffer.NormalKind);
+            loadAttribute("TANGENT", VertexBuffer.TangentKind);
+            loadAttribute("TEXCOORD_0", VertexBuffer.UVKind);
+            loadAttribute("TEXCOORD_1", VertexBuffer.UV2Kind);
+            loadAttribute("TEXCOORD_2", VertexBuffer.UV3Kind);
+            loadAttribute("TEXCOORD_3", VertexBuffer.UV4Kind);
+            loadAttribute("TEXCOORD_4", VertexBuffer.UV5Kind);
+            loadAttribute("TEXCOORD_5", VertexBuffer.UV6Kind);
+            loadAttribute("JOINTS_0", VertexBuffer.MatricesIndicesKind);
+            loadAttribute("WEIGHTS_0", VertexBuffer.MatricesWeightsKind);
+            loadAttribute("COLOR_0", VertexBuffer.ColorKind);
+            const bufferView = ArrayItem.Get(extensionContext, this._loader.gltf.bufferViews, extension.bufferView);
+            if (!bufferView._dracoBabylonGeometry) {
+                bufferView._dracoBabylonGeometry = this._loader.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView).then(async (data) => {
+                    const dracoDecoder = this.dracoDecoder || DracoDecoder.Default;
+                    const positionAccessor = ArrayItem.TryGet(this._loader.gltf.accessors, primitive.attributes["POSITION"]);
+                    const babylonBoundingInfo = !this._loader.parent.alwaysComputeBoundingBox && !babylonMesh.skeleton && positionAccessor ? LoadBoundingInfoFromPositionAccessor(positionAccessor) : null;
+                    return await dracoDecoder
+                        ._decodeMeshToGeometryForGltfAsync(babylonMesh.name, this._loader.babylonScene, data, attributes, normalized, babylonBoundingInfo)
+                        .catch((error) => {
+                        throw new Error(`${context}: ${error.message}`);
+                    });
+                });
+            }
+            return await bufferView._dracoBabylonGeometry;
+        });
+    }
+}
+unregisterGLTFExtension(NAME);
+registerGLTFExtension(NAME, true, (loader) => new KHR_draco_mesh_compression(loader));