@fps-games/editor 0.2.0-beta.4 → 0.2.1-beta.2

package/node_modules/@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.d.ts

@@ -0,0 +1,42 @@
+import { Animation } from "@babylonjs/core/Animations/animation.js";
+import { Quaternion, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import type { INode } from "./glTFLoaderInterfaces.js";
+import type { IAnimatable } from "@babylonjs/core/Animations/animatable.interface.js";
+/** @internal */
+export type GetValueFn = (target: any, source: Float32Array, offset: number, scale: number) => any;
+/** @internal */
+export declare function getVector3(_target: any, source: Float32Array, offset: number, scale: number): Vector3;
+/** @internal */
+export declare function getQuaternion(_target: any, source: Float32Array, offset: number, scale: number): Quaternion;
+/** @internal */
+export declare function getWeights(target: INode, source: Float32Array, offset: number, scale: number): Array<number>;
+/** @internal */
+export declare abstract class AnimationPropertyInfo {
+    readonly type: number;
+    readonly name: string;
+    readonly getValue: GetValueFn;
+    readonly getStride: (target: any) => number;
+    /** @internal */
+    constructor(type: number, name: string, getValue: GetValueFn, getStride: (target: any) => number);
+    protected _buildAnimation(name: string, fps: number, keys: any[]): Animation;
+    /** @internal */
+    abstract buildAnimations(target: any, name: string, fps: number, keys: any[]): {
+        babylonAnimatable: IAnimatable;
+        babylonAnimation: Animation;
+    }[];
+}
+/** @internal */
+export declare class TransformNodeAnimationPropertyInfo extends AnimationPropertyInfo {
+    /** @internal */
+    buildAnimations(target: INode, name: string, fps: number, keys: any[]): {
+        babylonAnimatable: IAnimatable;
+        babylonAnimation: Animation;
+    }[];
+}
+/** @internal */
+export declare class WeightAnimationPropertyInfo extends AnimationPropertyInfo {
+    buildAnimations(target: INode, name: string, fps: number, keys: any[]): {
+        babylonAnimatable: IAnimatable;
+        babylonAnimation: Animation;
+    }[];
+}

package/node_modules/@babylonjs/loaders/glTF/2.0/glTFLoaderAnimation.js

@@ -0,0 +1,79 @@
+import { Animation } from "@babylonjs/core/Animations/animation.js";
+import { Quaternion, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { SetInterpolationForKey } from "./Extensions/objectModelMapping.js";
+/** @internal */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export function getVector3(_target, source, offset, scale) {
+    return Vector3.FromArray(source, offset).scaleInPlace(scale);
+}
+/** @internal */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export function getQuaternion(_target, source, offset, scale) {
+    return Quaternion.FromArray(source, offset).scaleInPlace(scale);
+}
+/** @internal */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export function getWeights(target, source, offset, scale) {
+    const value = new Array(target._numMorphTargets);
+    for (let i = 0; i < value.length; i++) {
+        value[i] = source[offset++] * scale;
+    }
+    return value;
+}
+/** @internal */
+export class AnimationPropertyInfo {
+    /** @internal */
+    constructor(type, name, getValue, getStride) {
+        this.type = type;
+        this.name = name;
+        this.getValue = getValue;
+        this.getStride = getStride;
+    }
+    _buildAnimation(name, fps, keys) {
+        const babylonAnimation = new Animation(name, this.name, fps, this.type);
+        babylonAnimation.setKeys(keys, true);
+        return babylonAnimation;
+    }
+}
+/** @internal */
+export class TransformNodeAnimationPropertyInfo extends AnimationPropertyInfo {
+    /** @internal */
+    buildAnimations(target, name, fps, keys) {
+        const babylonAnimations = [];
+        babylonAnimations.push({ babylonAnimatable: target._babylonTransformNode, babylonAnimation: this._buildAnimation(name, fps, keys) });
+        return babylonAnimations;
+    }
+}
+/** @internal */
+export class WeightAnimationPropertyInfo extends AnimationPropertyInfo {
+    buildAnimations(target, name, fps, keys) {
+        const babylonAnimations = [];
+        if (target._numMorphTargets) {
+            for (let targetIndex = 0; targetIndex < target._numMorphTargets; targetIndex++) {
+                const babylonAnimation = new Animation(`${name}_${targetIndex}`, this.name, fps, this.type);
+                babylonAnimation.setKeys(keys.map((key) => ({
+                    frame: key.frame,
+                    inTangent: key.inTangent ? key.inTangent[targetIndex] : undefined,
+                    value: key.value[targetIndex],
+                    outTangent: key.outTangent ? key.outTangent[targetIndex] : undefined,
+                    interpolation: key.interpolation,
+                })), true);
+                if (target._primitiveBabylonMeshes) {
+                    for (const babylonMesh of target._primitiveBabylonMeshes) {
+                        if (babylonMesh.morphTargetManager) {
+                            const morphTarget = babylonMesh.morphTargetManager.getTarget(targetIndex);
+                            const babylonAnimationClone = babylonAnimation.clone();
+                            morphTarget.animations.push(babylonAnimationClone);
+                            babylonAnimations.push({ babylonAnimatable: morphTarget, babylonAnimation: babylonAnimationClone });
+                        }
+                    }
+                }
+            }
+        }
+        return babylonAnimations;
+    }
+}
+SetInterpolationForKey("/nodes/{}/translation", [new TransformNodeAnimationPropertyInfo(Animation.ANIMATIONTYPE_VECTOR3, "position", getVector3, () => 3)]);
+SetInterpolationForKey("/nodes/{}/rotation", [new TransformNodeAnimationPropertyInfo(Animation.ANIMATIONTYPE_QUATERNION, "rotationQuaternion", getQuaternion, () => 4)]);
+SetInterpolationForKey("/nodes/{}/scale", [new TransformNodeAnimationPropertyInfo(Animation.ANIMATIONTYPE_VECTOR3, "scaling", getVector3, () => 3)]);
+SetInterpolationForKey("/nodes/{}/weights", [new WeightAnimationPropertyInfo(Animation.ANIMATIONTYPE_FLOAT, "influence", getWeights, (target) => target._numMorphTargets)]);

package/node_modules/@babylonjs/loaders/glTF/2.0/glTFLoaderExtension.d.ts

@@ -0,0 +1,165 @@
+import type { Nullable } from "@babylonjs/core/types.js";
+import type { Animation } from "@babylonjs/core/Animations/animation.js";
+import type { AnimationGroup } from "@babylonjs/core/Animations/animationGroup.js";
+import type { Material } from "@babylonjs/core/Materials/material.js";
+import type { Camera } from "@babylonjs/core/Cameras/camera.js";
+import type { Geometry } from "@babylonjs/core/Meshes/geometry.js";
+import type { TransformNode } from "@babylonjs/core/Meshes/transformNode.js";
+import type { BaseTexture } from "@babylonjs/core/Materials/Textures/baseTexture.js";
+import type { Mesh } from "@babylonjs/core/Meshes/mesh.js";
+import type { AbstractMesh } from "@babylonjs/core/Meshes/abstractMesh.js";
+import type { IDisposable } from "@babylonjs/core/scene.js";
+import type { IScene, INode, IMesh, ISkin, ICamera, IMeshPrimitive, IMaterial, ITextureInfo, IAnimation, ITexture, IBufferView, IBuffer, IAnimationChannel } from "./glTFLoaderInterfaces.js";
+import type { IGLTFLoaderExtension as IGLTFBaseLoaderExtension } from "../glTFFileLoader.js";
+import type { IProperty } from "babylonjs-gltf2interface";
+import type { IAnimatable } from "@babylonjs/core/Animations/animatable.interface.js";
+/**
+ * Interface for a glTF loader extension.
+ */
+export interface IGLTFLoaderExtension extends IGLTFBaseLoaderExtension, IDisposable {
+    /**
+     * Called after the loader state changes to LOADING.
+     */
+    onLoading?(): void;
+    /**
+     * Called after the loader state changes to READY.
+     */
+    onReady?(): void;
+    /**
+     * Define this method to modify the default behavior when loading scenes.
+     * @param context The context when loading the asset
+     * @param scene The glTF scene property
+     * @returns A promise that resolves when the load is complete or null if not handled
+     */
+    loadSceneAsync?(context: string, scene: IScene): Nullable<Promise<void>>;
+    /**
+     * Define this method to modify the default behavior when loading nodes.
+     * @param context The context when loading the asset
+     * @param node The glTF node property
+     * @param assign A function called synchronously after parsing the glTF properties
+     * @returns A promise that resolves with the loaded Babylon transform node when the load is complete or null if not handled
+     */
+    loadNodeAsync?(context: string, node: INode, assign: (babylonMesh: TransformNode) => void): Nullable<Promise<TransformNode>>;
+    /**
+     * Define this method to modify the default behavior when loading cameras.
+     * @param context The context when loading the asset
+     * @param camera The glTF camera property
+     * @param assign A function called synchronously after parsing the glTF properties
+     * @returns A promise that resolves with the loaded Babylon camera when the load is complete or null if not handled
+     */
+    loadCameraAsync?(context: string, camera: ICamera, assign: (babylonCamera: Camera) => void): Nullable<Promise<Camera>>;
+    /**
+     * @internal
+     * Define this method to modify the default behavior when loading vertex data for mesh primitives.
+     * @param context The context when loading the asset
+     * @param primitive The glTF mesh primitive property
+     * @returns A promise that resolves with the loaded geometry when the load is complete or null if not handled
+     */
+    _loadVertexDataAsync?(context: string, primitive: IMeshPrimitive, babylonMesh: Mesh): Nullable<Promise<Geometry>>;
+    /**
+     * @internal
+     * Define this method to modify the default behavior when loading data for mesh primitives.
+     * @param context The context when loading the asset
+     * @param name The mesh name when loading the asset
+     * @param node The glTF node when loading the asset
+     * @param mesh The glTF mesh when loading the asset
+     * @param primitive The glTF mesh primitive property
+     * @param assign A function called synchronously after parsing the glTF properties
+     * @returns A promise that resolves with the loaded mesh when the load is complete or null if not handled
+     */
+    _loadMeshPrimitiveAsync?(context: string, name: string, node: INode, mesh: IMesh, primitive: IMeshPrimitive, assign: (babylonMesh: AbstractMesh) => void): Nullable<Promise<AbstractMesh>>;
+    /**
+     * @internal
+     * Define this method to modify the default behavior when loading materials. Load material creates the material and then loads material properties.
+     * @param context The context when loading the asset
+     * @param material The glTF material property
+     * @param assign A function called synchronously after parsing the glTF properties
+     * @returns A promise that resolves with the loaded Babylon material when the load is complete or null if not handled
+     */
+    _loadMaterialAsync?(context: string, material: IMaterial, babylonMesh: Nullable<Mesh>, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable<Promise<Material>>;
+    /**
+     * Define this method to modify the default behavior when creating materials.
+     * @param context The context when loading the asset
+     * @param material The glTF material property
+     * @param babylonDrawMode The draw mode for the Babylon material
+     * @returns The Babylon material or null if not handled
+     */
+    createMaterial?(context: string, material: IMaterial, babylonDrawMode: number): Nullable<Material>;
+    /**
+     * Define this method to modify the default behavior when loading material properties.
+     * @param context The context when loading the asset
+     * @param material The glTF material property
+     * @param babylonMaterial The Babylon material
+     * @returns A promise that resolves when the load is complete or null if not handled
+     */
+    loadMaterialPropertiesAsync?(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>>;
+    /**
+     * Define this method to modify the default behavior when loading texture infos.
+     * @param context The context when loading the asset
+     * @param textureInfo The glTF texture info property
+     * @param assign A function called synchronously after parsing the glTF properties
+     * @returns A promise that resolves with the loaded Babylon texture when the load is complete or null if not handled
+     */
+    loadTextureInfoAsync?(context: string, textureInfo: ITextureInfo, assign: (babylonTexture: BaseTexture) => void): Nullable<Promise<BaseTexture>>;
+    /**
+     * @internal
+     * Define this method to modify the default behavior when loading textures.
+     * @param context The context when loading the asset
+     * @param texture The glTF texture property
+     * @param assign A function called synchronously after parsing the glTF properties
+     * @returns A promise that resolves with the loaded Babylon texture when the load is complete or null if not handled
+     */
+    _loadTextureAsync?(context: string, texture: ITexture, assign: (babylonTexture: BaseTexture) => void): Nullable<Promise<BaseTexture>>;
+    /**
+     * Define this method to modify the default behavior when loading animations.
+     * @param context The context when loading the asset
+     * @param animation The glTF animation property
+     * @returns A promise that resolves with the loaded Babylon animation group when the load is complete or null if not handled
+     */
+    loadAnimationAsync?(context: string, animation: IAnimation): Nullable<Promise<AnimationGroup>>;
+    /**
+     * @internal
+     * Define this method to modify the default behvaior when loading animation channels.
+     * @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>>;
+    /**
+     * @internal
+     * Define this method to modify the default behavior when loading skins.
+     * @param context The context when loading the asset
+     * @param node The glTF node property
+     * @param skin The glTF skin property
+     * @returns A promise that resolves when the load is complete or null if not handled
+     */
+    _loadSkinAsync?(context: string, node: INode, skin: ISkin): Nullable<Promise<void>>;
+    /**
+     * @internal
+     * Define this method to modify the default behavior when loading uris.
+     * @param context The context when loading the asset
+     * @param property The glTF property associated with the uri
+     * @param uri The uri to load
+     * @returns A promise that resolves with the loaded data when the load is complete or null if not handled
+     */
+    _loadUriAsync?(context: string, property: IProperty, uri: string): Nullable<Promise<ArrayBufferView>>;
+    /**
+     * Define this method to modify the default behavior when loading buffer views.
+     * @param context The context when loading the asset
+     * @param bufferView The glTF buffer view property
+     * @returns A promise that resolves with the loaded data when the load is complete or null if not handled
+     */
+    loadBufferViewAsync?(context: string, bufferView: IBufferView): Nullable<Promise<ArrayBufferView>>;
+    /**
+     * Define this method to modify the default behavior when loading buffers.
+     * @param context The context when loading the asset
+     * @param buffer The glTF buffer property
+     * @param byteOffset The byte offset to load
+     * @param byteLength The byte length to load
+     * @returns A promise that resolves with the loaded data when the load is complete or null if not handled
+     */
+    loadBufferAsync?(context: string, buffer: IBuffer, byteOffset: number, byteLength: number): Nullable<Promise<ArrayBufferView>>;
+}

package/node_modules/@babylonjs/loaders/glTF/2.0/glTFLoaderExtension.js

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

package/node_modules/@babylonjs/loaders/glTF/2.0/glTFLoaderExtensionRegistry.d.ts

@@ -0,0 +1,25 @@
+import type { GLTFLoader } from "./glTFLoader.js";
+import type { IGLTFLoaderExtension } from "./glTFLoaderExtension.js";
+interface IRegisteredGLTFExtension {
+    isGLTFExtension: boolean;
+    factory: GLTFExtensionFactory;
+}
+export type GLTFExtensionFactory = (loader: GLTFLoader) => IGLTFLoaderExtension | Promise<IGLTFLoaderExtension>;
+/**
+ * All currently registered glTF 2.0 loader extensions.
+ */
+export declare const registeredGLTFExtensions: ReadonlyMap<string, Readonly<IRegisteredGLTFExtension>>;
+/**
+ * Registers a loader extension.
+ * @param name The name of the loader extension.
+ * @param isGLTFExtension If the loader extension is a glTF extension, then it will only be used for glTF files that use the corresponding glTF extension. Otherwise, it will be used for all loaded glTF files.
+ * @param factory The factory function that creates the loader extension.
+ */
+export declare function registerGLTFExtension(name: string, isGLTFExtension: boolean, factory: GLTFExtensionFactory): void;
+/**
+ * Unregisters a loader extension.
+ * @param name The name of the loader extension.
+ * @returns A boolean indicating whether the extension has been unregistered
+ */
+export declare function unregisterGLTFExtension(name: string): boolean;
+export {};

package/node_modules/@babylonjs/loaders/glTF/2.0/glTFLoaderExtensionRegistry.js

@@ -0,0 +1,32 @@
+import { Logger } from "@babylonjs/core/Misc/logger.js";
+const RegisteredGLTFExtensions = new Map();
+/**
+ * All currently registered glTF 2.0 loader extensions.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const registeredGLTFExtensions = RegisteredGLTFExtensions;
+/**
+ * Registers a loader extension.
+ * @param name The name of the loader extension.
+ * @param isGLTFExtension If the loader extension is a glTF extension, then it will only be used for glTF files that use the corresponding glTF extension. Otherwise, it will be used for all loaded glTF files.
+ * @param factory The factory function that creates the loader extension.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export function registerGLTFExtension(name, isGLTFExtension, factory) {
+    if (unregisterGLTFExtension(name)) {
+        Logger.Warn(`Extension with the name '${name}' already exists`);
+    }
+    RegisteredGLTFExtensions.set(name, {
+        isGLTFExtension,
+        factory,
+    });
+}
+/**
+ * Unregisters a loader extension.
+ * @param name The name of the loader extension.
+ * @returns A boolean indicating whether the extension has been unregistered
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export function unregisterGLTFExtension(name) {
+    return RegisteredGLTFExtensions.delete(name);
+}

package/node_modules/@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.d.ts

@@ -0,0 +1,262 @@
+import type { AnimationGroup } from "@babylonjs/core/Animations/animationGroup.js";
+import type { Skeleton } from "@babylonjs/core/Bones/skeleton.js";
+import type { Material } from "@babylonjs/core/Materials/material.js";
+import type { TransformNode } from "@babylonjs/core/Meshes/transformNode.js";
+import type { Buffer, VertexBuffer } from "@babylonjs/core/Buffers/buffer.js";
+import type { AbstractMesh } from "@babylonjs/core/Meshes/abstractMesh.js";
+import type { Mesh } from "@babylonjs/core/Meshes/mesh.js";
+import type { Camera } from "@babylonjs/core/Cameras/camera.js";
+import type { Light } from "@babylonjs/core/Lights/light.js";
+import type * as GLTF2 from "babylonjs-gltf2interface";
+/**
+ * Loader interface with an index field.
+ */
+export interface IArrayItem {
+    /**
+     * The index of this item in the array.
+     */
+    index: number;
+}
+/**
+ * Loader interface with additional members.
+ */
+export interface IAccessor extends GLTF2.IAccessor, IArrayItem {
+    /** @internal */
+    _data?: Promise<ArrayBufferView>;
+    /** @internal */
+    _babylonVertexBuffer?: {
+        [kind: string]: Promise<VertexBuffer>;
+    };
+}
+/**
+ * Loader interface with additional members.
+ */
+export interface IAnimationChannel extends GLTF2.IAnimationChannel, IArrayItem {
+}
+/** @internal */
+export interface _IAnimationSamplerData {
+    /** @internal */
+    input: Float32Array;
+    /** @internal */
+    interpolation: GLTF2.AnimationSamplerInterpolation;
+    /** @internal */
+    output: Float32Array;
+}
+/**
+ * Loader interface with additional members.
+ */
+export interface IAnimationSampler extends GLTF2.IAnimationSampler, IArrayItem {
+    /** @internal */
+    _data?: Promise<_IAnimationSamplerData>;
+}
+/**
+ * Loader interface with additional members.
+ */
+export interface IAnimation extends GLTF2.IAnimation, IArrayItem {
+    /** @internal */
+    channels: IAnimationChannel[];
+    /** @internal */
+    samplers: IAnimationSampler[];
+    /** @internal */
+    _babylonAnimationGroup?: AnimationGroup;
+}
+/**
+ * Loader interface with additional members.
+ */
+export interface IBuffer extends GLTF2.IBuffer, IArrayItem {
+    /** @internal */
+    _data?: Promise<ArrayBufferView>;
+}
+/**
+ * Loader interface with additional members.
+ */
+export interface IBufferView extends GLTF2.IBufferView, IArrayItem {
+    /** @internal */
+    _data?: Promise<ArrayBufferView>;
+    /** @internal */
+    _babylonBuffer?: Promise<Buffer>;
+}
+/**
+ * Loader interface with additional members.
+ */
+export interface ICamera extends GLTF2.ICamera, IArrayItem {
+    /** @internal */
+    _babylonCamera?: Camera;
+}
+/**
+ * Loader interface with additional members.
+ */
+export interface IImage extends GLTF2.IImage, IArrayItem {
+    /** @internal */
+    _data?: Promise<ArrayBufferView>;
+}
+/**
+ * Loader interface with additional members.
+ */
+export interface IMaterialNormalTextureInfo extends GLTF2.IMaterialNormalTextureInfo, ITextureInfo {
+}
+/**
+ * Loader interface with additional members.
+ */
+export interface IMaterialOcclusionTextureInfo extends GLTF2.IMaterialOcclusionTextureInfo, ITextureInfo {
+}
+/**
+ * Loader interface with additional members.
+ */
+export interface IMaterialPbrMetallicRoughness extends GLTF2.IMaterialPbrMetallicRoughness {
+    /** @internal */
+    baseColorTexture?: ITextureInfo;
+    /** @internal */
+    metallicRoughnessTexture?: ITextureInfo;
+}
+/**
+ * Loader interface with additional members.
+ */
+export interface IMaterial extends GLTF2.IMaterial, IArrayItem {
+    /** @internal */
+    pbrMetallicRoughness?: IMaterialPbrMetallicRoughness;
+    /** @internal */
+    normalTexture?: IMaterialNormalTextureInfo;
+    /** @internal */
+    occlusionTexture?: IMaterialOcclusionTextureInfo;
+    /** @internal */
+    emissiveTexture?: ITextureInfo;
+    /** @internal */
+    _data?: {
+        [babylonDrawMode: number]: {
+            babylonMaterial: Material;
+            babylonMeshes: AbstractMesh[];
+            promise: Promise<void>;
+        };
+    };
+}
+/**
+ * Loader interface with additional members.
+ */
+export interface IMesh extends GLTF2.IMesh, IArrayItem {
+    /** @internal */
+    primitives: IMeshPrimitive[];
+}
+/**
+ * Loader interface with additional members.
+ */
+export interface IMeshPrimitive extends GLTF2.IMeshPrimitive, IArrayItem {
+    /** @internal */
+    _instanceData?: {
+        babylonSourceMesh: Mesh;
+        promise: Promise<any>;
+    };
+}
+/**
+ * Loader interface with additional members.
+ */
+export interface INode extends GLTF2.INode, IArrayItem {
+    /** @internal */
+    parent?: INode;
+    /** @internal */
+    _babylonTransformNode?: TransformNode;
+    /** @internal */
+    _babylonTransformNodeForSkin?: TransformNode;
+    /** @internal */
+    _primitiveBabylonMeshes?: AbstractMesh[];
+    /** @internal */
+    _numMorphTargets?: number;
+    /** @internal */
+    _isJoint?: boolean;
+}
+/** @internal */
+export interface _ISamplerData {
+    /** @internal */
+    noMipMaps: boolean;
+    /** @internal */
+    samplingMode: number;
+    /** @internal */
+    wrapU: number;
+    /** @internal */
+    wrapV: number;
+}
+/**
+ * Loader interface with additional members.
+ */
+export interface ISampler extends GLTF2.ISampler, IArrayItem {
+    /** @internal */
+    _data?: _ISamplerData;
+}
+/**
+ * Loader interface with additional members.
+ */
+export interface IScene extends GLTF2.IScene, IArrayItem {
+}
+/**
+ * Loader interface with additional members.
+ */
+export interface ISkin extends GLTF2.ISkin, IArrayItem {
+    /** @internal */
+    _data?: {
+        babylonSkeleton: Skeleton;
+        promise: Promise<void>;
+    };
+}
+/**
+ * Loader interface with additional members.
+ */
+export interface ITexture extends GLTF2.ITexture, IArrayItem {
+    /** @internal */
+    _textureInfo: ITextureInfo;
+}
+/**
+ * Loader interface with additional members.
+ */
+export interface ITextureInfo extends GLTF2.ITextureInfo {
+    /** false or undefined if the texture holds color data (true if data are roughness, normal, ...) */
+    nonColorData?: boolean;
+}
+/**
+ * Loader interface with additional members.
+ */
+export interface IGLTF extends GLTF2.IGLTF {
+    /** @internal */
+    accessors?: IAccessor[];
+    /** @internal */
+    animations?: IAnimation[];
+    /** @internal */
+    buffers?: IBuffer[];
+    /** @internal */
+    bufferViews?: IBufferView[];
+    /** @internal */
+    cameras?: ICamera[];
+    /** @internal */
+    images?: IImage[];
+    /** @internal */
+    materials?: IMaterial[];
+    /** @internal */
+    meshes?: IMesh[];
+    /** @internal */
+    nodes?: INode[];
+    /** @internal */
+    samplers?: ISampler[];
+    /** @internal */
+    scenes?: IScene[];
+    /** @internal */
+    skins?: ISkin[];
+    /** @internal */
+    textures?: ITexture[];
+}
+/**
+ * Loader interface with additional members.
+ */
+/** @internal */
+export interface IKHRLightsPunctual_Light extends GLTF2.IKHRLightsPunctual_Light, IArrayItem {
+    /** @hidden */
+    _babylonLight?: Light;
+}
+/** @internal */
+export interface IEXTLightsIES_Light extends GLTF2.IEXTLightsIES_Light, IArrayItem {
+    /** @hidden */
+    _babylonLight?: Light;
+}
+/** @internal */
+export interface IEXTLightsArea_Light extends GLTF2.IEXTLightsArea_Light, IArrayItem {
+    /** @hidden */
+    _babylonLight?: Light;
+}

package/node_modules/@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces.js

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

package/node_modules/@babylonjs/loaders/glTF/2.0/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./glTFLoader.js";
+export * from "./glTFLoaderExtension.js";
+export * from "./glTFLoaderExtensionRegistry.js";
+export * from "./glTFLoaderInterfaces.js";
+export * from "./glTFLoaderAnimation.js";
+export * from "./openpbrMaterialLoadingAdapter.js";
+export * from "./pbrMaterialLoadingAdapter.js";
+export * from "./Extensions/index.js";

package/node_modules/@babylonjs/loaders/glTF/2.0/index.js

@@ -0,0 +1,9 @@
+/* eslint-disable @typescript-eslint/no-restricted-imports */
+export * from "./glTFLoader.js";
+export * from "./glTFLoaderExtension.js";
+export * from "./glTFLoaderExtensionRegistry.js";
+export * from "./glTFLoaderInterfaces.js";
+export * from "./glTFLoaderAnimation.js";
+export * from "./openpbrMaterialLoadingAdapter.js";
+export * from "./pbrMaterialLoadingAdapter.js";
+export * from "./Extensions/index.js";