@onerjs/serializers 8.23.1

package/glTF/2.0/Extensions/index.d.ts

@@ -0,0 +1,17 @@
+export * from "./EXT_mesh_gpu_instancing.js";
+export * from "./KHR_draco_mesh_compression.js";
+export * from "./KHR_lights_punctual.js";
+export * from "./KHR_materials_anisotropy.js";
+export * from "./KHR_materials_clearcoat.js";
+export * from "./KHR_materials_diffuse_transmission.js";
+export * from "./KHR_materials_dispersion.js";
+export * from "./KHR_materials_emissive_strength.js";
+export * from "./KHR_materials_ior.js";
+export * from "./KHR_materials_iridescence.js";
+export * from "./KHR_materials_sheen.js";
+export * from "./KHR_materials_specular.js";
+export * from "./KHR_materials_transmission.js";
+export * from "./KHR_materials_unlit.js";
+export * from "./KHR_materials_volume.js";
+export * from "./EXT_materials_diffuse_roughness.js";
+export * from "./KHR_texture_transform.js";

package/glTF/2.0/Extensions/index.js

@@ -0,0 +1,18 @@
+export * from "./EXT_mesh_gpu_instancing.js";
+export * from "./KHR_draco_mesh_compression.js";
+export * from "./KHR_lights_punctual.js";
+export * from "./KHR_materials_anisotropy.js";
+export * from "./KHR_materials_clearcoat.js";
+export * from "./KHR_materials_diffuse_transmission.js";
+export * from "./KHR_materials_dispersion.js";
+export * from "./KHR_materials_emissive_strength.js";
+export * from "./KHR_materials_ior.js";
+export * from "./KHR_materials_iridescence.js";
+export * from "./KHR_materials_sheen.js";
+export * from "./KHR_materials_specular.js";
+export * from "./KHR_materials_transmission.js";
+export * from "./KHR_materials_unlit.js";
+export * from "./KHR_materials_volume.js";
+export * from "./EXT_materials_diffuse_roughness.js";
+export * from "./KHR_texture_transform.js";
+//# sourceMappingURL=index.js.map

package/glTF/2.0/Extensions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../dev/serializers/src/glTF/2.0/Extensions/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sCAAsC,CAAC;AACrD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mCAAmC,CAAC;AAClD,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mCAAmC,CAAC;AAClD,cAAc,yBAAyB,CAAC","sourcesContent":["export * from \"./EXT_mesh_gpu_instancing\";\r\nexport * from \"./KHR_draco_mesh_compression\";\r\nexport * from \"./KHR_lights_punctual\";\r\nexport * from \"./KHR_materials_anisotropy\";\r\nexport * from \"./KHR_materials_clearcoat\";\r\nexport * from \"./KHR_materials_diffuse_transmission\";\r\nexport * from \"./KHR_materials_dispersion\";\r\nexport * from \"./KHR_materials_emissive_strength\";\r\nexport * from \"./KHR_materials_ior\";\r\nexport * from \"./KHR_materials_iridescence\";\r\nexport * from \"./KHR_materials_sheen\";\r\nexport * from \"./KHR_materials_specular\";\r\nexport * from \"./KHR_materials_transmission\";\r\nexport * from \"./KHR_materials_unlit\";\r\nexport * from \"./KHR_materials_volume\";\r\nexport * from \"./EXT_materials_diffuse_roughness\";\r\nexport * from \"./KHR_texture_transform\";\r\n"]}

package/glTF/2.0/bufferManager.d.ts

@@ -0,0 +1,68 @@
+import type { TypedArray } from "@babylonjs/core/types.js";
+import type { AccessorComponentType, AccessorType, IAccessor, IBufferView } from "babylonjs-gltf2interface";
+type TypedArrayForglTF = Exclude<TypedArray, Float64Array | BigInt64Array | BigUint64Array>;
+interface IPropertyWithBufferView {
+    bufferView?: number;
+}
+/**
+ * Utility class to centralize the management of binary data, bufferViews, and the objects that reference them.
+ * @internal
+ */
+export declare class BufferManager {
+    /**
+     * Maps a bufferView to its data
+     */
+    private _bufferViewToData;
+    /**
+     * Maps a bufferView to glTF objects that reference it via a "bufferView" property (e.g. accessors, images)
+     */
+    private _bufferViewToProperties;
+    /**
+     * Maps an accessor to its bufferView
+     */
+    private _accessorToBufferView;
+    /**
+     * Generates a binary buffer from the stored bufferViews. Also populates the bufferViews list.
+     * @param bufferViews The list of bufferViews to be populated while writing the binary
+     * @returns The binary buffer
+     */
+    generateBinary(bufferViews: IBufferView[]): Uint8Array;
+    /**
+     * Creates a buffer view based on the supplied arguments
+     * @param data a TypedArray to create the bufferView for
+     * @param byteStride byte distance between consecutive elements
+     * @returns bufferView for glTF
+     */
+    createBufferView(data: TypedArrayForglTF, byteStride?: number): IBufferView;
+    /**
+     * Creates an accessor based on the supplied arguments and assigns it to the bufferView
+     * @param bufferView The glTF bufferView referenced by this accessor
+     * @param type The type of the accessor
+     * @param componentType The datatype of components in the attribute
+     * @param count The number of attributes referenced by this accessor
+     * @param byteOffset The offset relative to the start of the bufferView in bytes
+     * @param minMax Minimum and maximum value of each component in this attribute
+     * @param normalized Specifies whether integer data values are normalized before usage
+     * @returns accessor for glTF
+     */
+    createAccessor(bufferView: IBufferView, type: AccessorType, componentType: AccessorComponentType, count: number, byteOffset?: number, minMax?: {
+        min: number[];
+        max: number[];
+    }, normalized?: boolean): IAccessor;
+    /**
+     * Assigns a bufferView to a glTF object that references it
+     * @param object The glTF object
+     * @param bufferView The bufferView to assign
+     */
+    setBufferView(object: IPropertyWithBufferView, bufferView: IBufferView): void;
+    /**
+     * Removes buffer view from the binary data, as well as from all its known references
+     * @param bufferView the bufferView to remove
+     */
+    removeBufferView(bufferView: IBufferView): void;
+    getBufferView(accessor: IAccessor): IBufferView;
+    getPropertiesWithBufferView(bufferView: IBufferView): IPropertyWithBufferView[];
+    getData(bufferView: IBufferView): TypedArrayForglTF;
+    private _verifyBufferView;
+}
+export {};

package/glTF/2.0/bufferManager.js

@@ -0,0 +1,154 @@
+import { DataWriter } from "./dataWriter.js";
+function GetHighestByteAlignment(byteLength) {
+    if (byteLength % 4 === 0) {
+        return 4;
+    }
+    if (byteLength % 2 === 0) {
+        return 2;
+    }
+    return 1;
+}
+/**
+ * Utility class to centralize the management of binary data, bufferViews, and the objects that reference them.
+ * @internal
+ */
+export class BufferManager {
+    constructor() {
+        /**
+         * Maps a bufferView to its data
+         */
+        this._bufferViewToData = new Map();
+        /**
+         * Maps a bufferView to glTF objects that reference it via a "bufferView" property (e.g. accessors, images)
+         */
+        this._bufferViewToProperties = new Map();
+        /**
+         * Maps an accessor to its bufferView
+         */
+        this._accessorToBufferView = new Map();
+    }
+    /**
+     * Generates a binary buffer from the stored bufferViews. Also populates the bufferViews list.
+     * @param bufferViews The list of bufferViews to be populated while writing the binary
+     * @returns The binary buffer
+     */
+    generateBinary(bufferViews) {
+        // Construct a DataWriter with the total byte length to prevent resizing
+        let totalByteLength = 0;
+        this._bufferViewToData.forEach((data) => {
+            totalByteLength += data.byteLength;
+        });
+        const dataWriter = new DataWriter(totalByteLength);
+        // Order the bufferViews in descending order of their alignment requirements
+        const orderedBufferViews = Array.from(this._bufferViewToData.keys()).sort((a, b) => GetHighestByteAlignment(b.byteLength) - GetHighestByteAlignment(a.byteLength));
+        // Fill in the bufferViews list and missing bufferView index references while writing the binary
+        for (const bufferView of orderedBufferViews) {
+            bufferView.byteOffset = dataWriter.byteOffset;
+            bufferViews.push(bufferView);
+            const bufferViewIndex = bufferViews.length - 1;
+            const properties = this.getPropertiesWithBufferView(bufferView);
+            for (const object of properties) {
+                object.bufferView = bufferViewIndex;
+            }
+            dataWriter.writeTypedArray(this._bufferViewToData.get(bufferView));
+            this._bufferViewToData.delete(bufferView); // Try to free up memory ASAP
+        }
+        return dataWriter.getOutputData();
+    }
+    /**
+     * Creates a buffer view based on the supplied arguments
+     * @param data a TypedArray to create the bufferView for
+     * @param byteStride byte distance between consecutive elements
+     * @returns bufferView for glTF
+     */
+    createBufferView(data, byteStride) {
+        const bufferView = {
+            buffer: 0,
+            byteOffset: undefined, // byteOffset will be set later, when we write the binary and decide bufferView ordering
+            byteLength: data.byteLength,
+            byteStride: byteStride,
+        };
+        this._bufferViewToData.set(bufferView, data);
+        return bufferView;
+    }
+    /**
+     * Creates an accessor based on the supplied arguments and assigns it to the bufferView
+     * @param bufferView The glTF bufferView referenced by this accessor
+     * @param type The type of the accessor
+     * @param componentType The datatype of components in the attribute
+     * @param count The number of attributes referenced by this accessor
+     * @param byteOffset The offset relative to the start of the bufferView in bytes
+     * @param minMax Minimum and maximum value of each component in this attribute
+     * @param normalized Specifies whether integer data values are normalized before usage
+     * @returns accessor for glTF
+     */
+    createAccessor(bufferView, type, componentType, count, byteOffset, minMax, normalized) {
+        this._verifyBufferView(bufferView);
+        const accessor = {
+            bufferView: undefined, // bufferView will be set to a real index later, once we write the binary and decide bufferView ordering
+            componentType: componentType,
+            count: count,
+            type: type,
+            min: minMax?.min,
+            max: minMax?.max,
+            normalized: normalized,
+            byteOffset: byteOffset,
+        };
+        this.setBufferView(accessor, bufferView);
+        this._accessorToBufferView.set(accessor, bufferView);
+        return accessor;
+    }
+    /**
+     * Assigns a bufferView to a glTF object that references it
+     * @param object The glTF object
+     * @param bufferView The bufferView to assign
+     */
+    setBufferView(object, bufferView) {
+        this._verifyBufferView(bufferView);
+        const properties = this.getPropertiesWithBufferView(bufferView);
+        properties.push(object);
+    }
+    /**
+     * Removes buffer view from the binary data, as well as from all its known references
+     * @param bufferView the bufferView to remove
+     */
+    removeBufferView(bufferView) {
+        const properties = this.getPropertiesWithBufferView(bufferView);
+        for (const object of properties) {
+            if (object.bufferView !== undefined) {
+                delete object.bufferView;
+            }
+        }
+        this._bufferViewToData.delete(bufferView);
+        this._bufferViewToProperties.delete(bufferView);
+        this._accessorToBufferView.forEach((bv, accessor) => {
+            if (bv === bufferView) {
+                // Additionally, remove byteOffset from accessor referencing this bufferView
+                if (accessor.byteOffset !== undefined) {
+                    delete accessor.byteOffset;
+                }
+                this._accessorToBufferView.delete(accessor);
+            }
+        });
+    }
+    getBufferView(accessor) {
+        const bufferView = this._accessorToBufferView.get(accessor);
+        this._verifyBufferView(bufferView);
+        return bufferView;
+    }
+    getPropertiesWithBufferView(bufferView) {
+        this._verifyBufferView(bufferView);
+        this._bufferViewToProperties.set(bufferView, this._bufferViewToProperties.get(bufferView) ?? []);
+        return this._bufferViewToProperties.get(bufferView);
+    }
+    getData(bufferView) {
+        this._verifyBufferView(bufferView);
+        return this._bufferViewToData.get(bufferView);
+    }
+    _verifyBufferView(bufferView) {
+        if (bufferView === undefined || !this._bufferViewToData.has(bufferView)) {
+            throw new Error(`BufferView ${bufferView} not found in BufferManager.`);
+        }
+    }
+}
+//# sourceMappingURL=bufferManager.js.map

package/glTF/2.0/bufferManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bufferManager.js","sourceRoot":"","sources":["../../../../../dev/serializers/src/glTF/2.0/bufferManager.ts"],"names":[],"mappings":"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","sourcesContent":["import type { TypedArray } from \"core/types\";\nimport type { AccessorComponentType, AccessorType, IAccessor, IBufferView } from \"babylonjs-gltf2interface\";\nimport { DataWriter } from \"./dataWriter\";\n\ntype TypedArrayForglTF = Exclude<TypedArray, Float64Array | BigInt64Array | BigUint64Array>;\n\ninterface IPropertyWithBufferView {\n    bufferView?: number;\n}\n\nfunction GetHighestByteAlignment(byteLength: number): number {\n    if (byteLength % 4 === 0) {\n        return 4;\n    }\n    if (byteLength % 2 === 0) {\n        return 2;\n    }\n    return 1;\n}\n\n/**\n * Utility class to centralize the management of binary data, bufferViews, and the objects that reference them.\n * @internal\n */\nexport class BufferManager {\n    /**\n     * Maps a bufferView to its data\n     */\n    private _bufferViewToData: Map<IBufferView, TypedArrayForglTF> = new Map<IBufferView, TypedArrayForglTF>();\n\n    /**\n     * Maps a bufferView to glTF objects that reference it via a \"bufferView\" property (e.g. accessors, images)\n     */\n    private _bufferViewToProperties: Map<IBufferView, IPropertyWithBufferView[]> = new Map<IBufferView, IPropertyWithBufferView[]>();\n\n    /**\n     * Maps an accessor to its bufferView\n     */\n    private _accessorToBufferView: Map<IAccessor, IBufferView> = new Map<IAccessor, IBufferView>();\n\n    /**\n     * Generates a binary buffer from the stored bufferViews. Also populates the bufferViews list.\n     * @param bufferViews The list of bufferViews to be populated while writing the binary\n     * @returns The binary buffer\n     */\n    public generateBinary(bufferViews: IBufferView[]): Uint8Array {\n        // Construct a DataWriter with the total byte length to prevent resizing\n        let totalByteLength = 0;\n        this._bufferViewToData.forEach((data) => {\n            totalByteLength += data.byteLength;\n        });\n        const dataWriter = new DataWriter(totalByteLength);\n\n        // Order the bufferViews in descending order of their alignment requirements\n        const orderedBufferViews = Array.from(this._bufferViewToData.keys()).sort((a, b) => GetHighestByteAlignment(b.byteLength) - GetHighestByteAlignment(a.byteLength));\n\n        // Fill in the bufferViews list and missing bufferView index references while writing the binary\n        for (const bufferView of orderedBufferViews) {\n            bufferView.byteOffset = dataWriter.byteOffset;\n            bufferViews.push(bufferView);\n\n            const bufferViewIndex = bufferViews.length - 1;\n            const properties = this.getPropertiesWithBufferView(bufferView);\n            for (const object of properties) {\n                object.bufferView = bufferViewIndex;\n            }\n\n            dataWriter.writeTypedArray(this._bufferViewToData.get(bufferView)!);\n\n            this._bufferViewToData.delete(bufferView); // Try to free up memory ASAP\n        }\n\n        return dataWriter.getOutputData();\n    }\n\n    /**\n     * Creates a buffer view based on the supplied arguments\n     * @param data a TypedArray to create the bufferView for\n     * @param byteStride byte distance between consecutive elements\n     * @returns bufferView for glTF\n     */\n    public createBufferView(data: TypedArrayForglTF, byteStride?: number): IBufferView {\n        const bufferView: IBufferView = {\n            buffer: 0,\n            byteOffset: undefined, // byteOffset will be set later, when we write the binary and decide bufferView ordering\n            byteLength: data.byteLength,\n            byteStride: byteStride,\n        };\n        this._bufferViewToData.set(bufferView, data);\n        return bufferView;\n    }\n\n    /**\n     * Creates an accessor based on the supplied arguments and assigns it to the bufferView\n     * @param bufferView The glTF bufferView referenced by this accessor\n     * @param type The type of the accessor\n     * @param componentType The datatype of components in the attribute\n     * @param count The number of attributes referenced by this accessor\n     * @param byteOffset The offset relative to the start of the bufferView in bytes\n     * @param minMax Minimum and maximum value of each component in this attribute\n     * @param normalized Specifies whether integer data values are normalized before usage\n     * @returns accessor for glTF\n     */\n    public createAccessor(\n        bufferView: IBufferView,\n        type: AccessorType,\n        componentType: AccessorComponentType,\n        count: number,\n        byteOffset?: number,\n        minMax?: { min: number[]; max: number[] },\n        normalized?: boolean\n    ): IAccessor {\n        this._verifyBufferView(bufferView);\n        const accessor: IAccessor = {\n            bufferView: undefined, // bufferView will be set to a real index later, once we write the binary and decide bufferView ordering\n            componentType: componentType,\n            count: count,\n            type: type,\n            min: minMax?.min,\n            max: minMax?.max,\n            normalized: normalized,\n            byteOffset: byteOffset,\n        };\n        this.setBufferView(accessor, bufferView);\n        this._accessorToBufferView.set(accessor, bufferView);\n        return accessor;\n    }\n\n    /**\n     * Assigns a bufferView to a glTF object that references it\n     * @param object The glTF object\n     * @param bufferView The bufferView to assign\n     */\n    public setBufferView(object: IPropertyWithBufferView, bufferView: IBufferView) {\n        this._verifyBufferView(bufferView);\n        const properties = this.getPropertiesWithBufferView(bufferView);\n        properties.push(object);\n    }\n\n    /**\n     * Removes buffer view from the binary data, as well as from all its known references\n     * @param bufferView the bufferView to remove\n     */\n    public removeBufferView(bufferView: IBufferView): void {\n        const properties = this.getPropertiesWithBufferView(bufferView);\n        for (const object of properties) {\n            if (object.bufferView !== undefined) {\n                delete object.bufferView;\n            }\n        }\n\n        this._bufferViewToData.delete(bufferView);\n        this._bufferViewToProperties.delete(bufferView);\n        this._accessorToBufferView.forEach((bv, accessor) => {\n            if (bv === bufferView) {\n                // Additionally, remove byteOffset from accessor referencing this bufferView\n                if (accessor.byteOffset !== undefined) {\n                    delete accessor.byteOffset;\n                }\n                this._accessorToBufferView.delete(accessor);\n            }\n        });\n    }\n\n    public getBufferView(accessor: IAccessor): IBufferView {\n        const bufferView = this._accessorToBufferView.get(accessor);\n        this._verifyBufferView(bufferView);\n        return bufferView!;\n    }\n\n    public getPropertiesWithBufferView(bufferView: IBufferView): IPropertyWithBufferView[] {\n        this._verifyBufferView(bufferView);\n        this._bufferViewToProperties.set(bufferView, this._bufferViewToProperties.get(bufferView) ?? []);\n        return this._bufferViewToProperties.get(bufferView)!;\n    }\n\n    public getData(bufferView: IBufferView): TypedArrayForglTF {\n        this._verifyBufferView(bufferView);\n        return this._bufferViewToData.get(bufferView)!;\n    }\n\n    private _verifyBufferView(bufferView?: IBufferView): void {\n        if (bufferView === undefined || !this._bufferViewToData.has(bufferView)) {\n            throw new Error(`BufferView ${bufferView} not found in BufferManager.`);\n        }\n    }\n}\n"]}

package/glTF/2.0/dataWriter.d.ts

@@ -0,0 +1,20 @@
+import type { TypedArray } from "@babylonjs/core/types.js";
+/** @internal */
+export declare class DataWriter {
+    private _data;
+    private _dataView;
+    private _byteOffset;
+    writeTypedArray(value: Exclude<TypedArray, BigInt64Array | BigUint64Array>): void;
+    constructor(byteLength: number);
+    get byteOffset(): number;
+    getOutputData(): Uint8Array;
+    writeUInt8(value: number): void;
+    writeInt8(value: number): void;
+    writeInt16(entry: number): void;
+    writeUInt16(value: number): void;
+    writeInt32(entry: number): void;
+    writeUInt32(value: number): void;
+    writeFloat32(value: number): void;
+    writeFloat64(value: number): void;
+    private _checkGrowBuffer;
+}

package/glTF/2.0/dataWriter.js

@@ -0,0 +1,83 @@
+const TypedArrayToWriteMethod = new Map([
+    [Int8Array, (d, b, v) => d.setInt8(b, v)],
+    [Uint8Array, (dv, bo, v) => dv.setUint8(bo, v)],
+    [Uint8ClampedArray, (dv, bo, v) => dv.setUint8(bo, v)],
+    [Int16Array, (dv, bo, v) => dv.setInt16(bo, v, true)],
+    [Uint16Array, (dv, bo, v) => dv.setUint16(bo, v, true)],
+    [Int32Array, (dv, bo, v) => dv.setInt32(bo, v, true)],
+    [Uint32Array, (dv, bo, v) => dv.setUint32(bo, v, true)],
+    [Float32Array, (dv, bo, v) => dv.setFloat32(bo, v, true)],
+    [Float64Array, (dv, bo, v) => dv.setFloat64(bo, v, true)],
+]);
+/** @internal */
+export class DataWriter {
+    writeTypedArray(value) {
+        this._checkGrowBuffer(value.byteLength);
+        const setMethod = TypedArrayToWriteMethod.get(value.constructor);
+        for (let i = 0; i < value.length; i++) {
+            setMethod(this._dataView, this._byteOffset, value[i]);
+            this._byteOffset += value.BYTES_PER_ELEMENT;
+        }
+    }
+    constructor(byteLength) {
+        this._data = new Uint8Array(byteLength);
+        this._dataView = new DataView(this._data.buffer);
+        this._byteOffset = 0;
+    }
+    get byteOffset() {
+        return this._byteOffset;
+    }
+    getOutputData() {
+        return new Uint8Array(this._data.buffer, 0, this._byteOffset);
+    }
+    writeUInt8(value) {
+        this._checkGrowBuffer(1);
+        this._dataView.setUint8(this._byteOffset, value);
+        this._byteOffset++;
+    }
+    writeInt8(value) {
+        this._checkGrowBuffer(1);
+        this._dataView.setInt8(this._byteOffset, value);
+        this._byteOffset++;
+    }
+    writeInt16(entry) {
+        this._checkGrowBuffer(2);
+        this._dataView.setInt16(this._byteOffset, entry, true);
+        this._byteOffset += 2;
+    }
+    writeUInt16(value) {
+        this._checkGrowBuffer(2);
+        this._dataView.setUint16(this._byteOffset, value, true);
+        this._byteOffset += 2;
+    }
+    writeInt32(entry) {
+        this._checkGrowBuffer(4);
+        this._dataView.setInt32(this._byteOffset, entry, true);
+        this._byteOffset += 4;
+    }
+    writeUInt32(value) {
+        this._checkGrowBuffer(4);
+        this._dataView.setUint32(this._byteOffset, value, true);
+        this._byteOffset += 4;
+    }
+    writeFloat32(value) {
+        this._checkGrowBuffer(4);
+        this._dataView.setFloat32(this._byteOffset, value, true);
+        this._byteOffset += 4;
+    }
+    writeFloat64(value) {
+        this._checkGrowBuffer(8);
+        this._dataView.setFloat64(this._byteOffset, value, true);
+        this._byteOffset += 8;
+    }
+    _checkGrowBuffer(byteLength) {
+        const newByteLength = this.byteOffset + byteLength;
+        if (newByteLength > this._data.byteLength) {
+            const newData = new Uint8Array(newByteLength * 2);
+            newData.set(this._data);
+            this._data = newData;
+            this._dataView = new DataView(this._data.buffer);
+        }
+    }
+}
+//# sourceMappingURL=dataWriter.js.map

package/glTF/2.0/dataWriter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataWriter.js","sourceRoot":"","sources":["../../../../../dev/serializers/src/glTF/2.0/dataWriter.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/naming-convention */\r\n/* eslint-disable babylonjs/available */\r\nimport type { TypedArray } from \"core/types\";\r\n\r\nconst TypedArrayToWriteMethod = new Map<Function, (dataView: DataView, byteOffset: number, value: number) => void>([\r\n    [Int8Array, (d, b, v) => d.setInt8(b, v)],\r\n    [Uint8Array, (dv, bo, v) => dv.setUint8(bo, v)],\r\n    [Uint8ClampedArray, (dv, bo, v) => dv.setUint8(bo, v)],\r\n    [Int16Array, (dv, bo, v) => dv.setInt16(bo, v, true)],\r\n    [Uint16Array, (dv, bo, v) => dv.setUint16(bo, v, true)],\r\n    [Int32Array, (dv, bo, v) => dv.setInt32(bo, v, true)],\r\n    [Uint32Array, (dv, bo, v) => dv.setUint32(bo, v, true)],\r\n    [Float32Array, (dv, bo, v) => dv.setFloat32(bo, v, true)],\r\n    [Float64Array, (dv, bo, v) => dv.setFloat64(bo, v, true)],\r\n]);\r\n\r\n/** @internal */\r\nexport class DataWriter {\r\n    private _data: Uint8Array;\r\n    private _dataView: DataView;\r\n    private _byteOffset: number;\r\n\r\n    public writeTypedArray(value: Exclude<TypedArray, BigInt64Array | BigUint64Array>): void {\r\n        this._checkGrowBuffer(value.byteLength);\r\n        const setMethod = TypedArrayToWriteMethod.get(value.constructor)!;\r\n        for (let i = 0; i < value.length; i++) {\r\n            setMethod(this._dataView, this._byteOffset, value[i]);\r\n            this._byteOffset += value.BYTES_PER_ELEMENT;\r\n        }\r\n    }\r\n\r\n    public constructor(byteLength: number) {\r\n        this._data = new Uint8Array(byteLength);\r\n        this._dataView = new DataView(this._data.buffer);\r\n        this._byteOffset = 0;\r\n    }\r\n\r\n    public get byteOffset(): number {\r\n        return this._byteOffset;\r\n    }\r\n\r\n    public getOutputData(): Uint8Array {\r\n        return new Uint8Array(this._data.buffer, 0, this._byteOffset);\r\n    }\r\n\r\n    public writeUInt8(value: number): void {\r\n        this._checkGrowBuffer(1);\r\n        this._dataView.setUint8(this._byteOffset, value);\r\n        this._byteOffset++;\r\n    }\r\n\r\n    public writeInt8(value: number): void {\r\n        this._checkGrowBuffer(1);\r\n        this._dataView.setInt8(this._byteOffset, value);\r\n        this._byteOffset++;\r\n    }\r\n\r\n    public writeInt16(entry: number): void {\r\n        this._checkGrowBuffer(2);\r\n        this._dataView.setInt16(this._byteOffset, entry, true);\r\n        this._byteOffset += 2;\r\n    }\r\n\r\n    public writeUInt16(value: number): void {\r\n        this._checkGrowBuffer(2);\r\n        this._dataView.setUint16(this._byteOffset, value, true);\r\n        this._byteOffset += 2;\r\n    }\r\n\r\n    public writeInt32(entry: number): void {\r\n        this._checkGrowBuffer(4);\r\n        this._dataView.setInt32(this._byteOffset, entry, true);\r\n        this._byteOffset += 4;\r\n    }\r\n\r\n    public writeUInt32(value: number): void {\r\n        this._checkGrowBuffer(4);\r\n        this._dataView.setUint32(this._byteOffset, value, true);\r\n        this._byteOffset += 4;\r\n    }\r\n\r\n    public writeFloat32(value: number): void {\r\n        this._checkGrowBuffer(4);\r\n        this._dataView.setFloat32(this._byteOffset, value, true);\r\n        this._byteOffset += 4;\r\n    }\r\n\r\n    public writeFloat64(value: number): void {\r\n        this._checkGrowBuffer(8);\r\n        this._dataView.setFloat64(this._byteOffset, value, true);\r\n        this._byteOffset += 8;\r\n    }\r\n\r\n    private _checkGrowBuffer(byteLength: number): void {\r\n        const newByteLength = this.byteOffset + byteLength;\r\n        if (newByteLength > this._data.byteLength) {\r\n            const newData = new Uint8Array(newByteLength * 2);\r\n            newData.set(this._data);\r\n            this._data = newData;\r\n            this._dataView = new DataView(this._data.buffer);\r\n        }\r\n    }\r\n}\r\n"]}

package/glTF/2.0/glTFAnimation.d.ts

@@ -0,0 +1,191 @@
+import type { IAnimation, INode, IBufferView, IAccessor } from "babylonjs-gltf2interface";
+import { AnimationSamplerInterpolation, AnimationChannelTargetPath, AccessorType } from "babylonjs-gltf2interface";
+import type { Node } from "@babylonjs/core/node.js";
+import type { Nullable } from "@babylonjs/core/types.js";
+import { Animation } from "@babylonjs/core/Animations/animation.js";
+import type { Scene } from "@babylonjs/core/scene.js";
+import type { BufferManager } from "./bufferManager.js";
+/**
+ * @internal
+ * Interface to store animation data.
+ */
+export interface _IAnimationData {
+    /**
+     * Keyframe data.
+     */
+    inputs: number[];
+    /**
+     * Value data.
+     */
+    outputs: number[][];
+    /**
+     * Animation interpolation data.
+     */
+    samplerInterpolation: AnimationSamplerInterpolation;
+    /**
+     * Minimum keyframe value.
+     */
+    inputsMin: number;
+    /**
+     * Maximum keyframe value.
+     */
+    inputsMax: number;
+}
+/**
+ * @internal
+ */
+export interface _IAnimationInfo {
+    /**
+     * The target channel for the animation
+     */
+    animationChannelTargetPath: AnimationChannelTargetPath;
+    /**
+     * The glTF accessor type for the data.
+     */
+    dataAccessorType: AccessorType.VEC3 | AccessorType.VEC4 | AccessorType.SCALAR;
+    /**
+     * Specifies if quaternions should be used.
+     */
+    useQuaternion: boolean;
+}
+/**
+ * @internal
+ * Utility class for generating glTF animation data from BabylonJS.
+ */
+export declare class _GLTFAnimation {
+    /**
+     * Determine if a node is transformable - ie has properties it should be part of animation of transformation.
+     * @param babylonNode the node to test
+     * @returns true if can be animated, false otherwise. False if the parameter is null or undefined.
+     */
+    private static _IsTransformable;
+    /**
+     * @ignore
+     *
+     * Creates glTF channel animation from BabylonJS animation.
+     * @param babylonTransformNode - BabylonJS mesh.
+     * @param animation - animation.
+     * @param animationChannelTargetPath - The target animation channel.
+     * @param useQuaternion - Specifies if quaternions are used.
+     * @returns nullable IAnimationData
+     */
+    static _CreateNodeAnimation(babylonTransformNode: Node, animation: Animation, animationChannelTargetPath: AnimationChannelTargetPath, useQuaternion: boolean, animationSampleRate: number): Nullable<_IAnimationData>;
+    private static _DeduceAnimationInfo;
+    /**
+     * @ignore
+     * Create node animations from the transform node animations
+     * @param babylonNode
+     * @param runtimeGLTFAnimation
+     * @param idleGLTFAnimations
+     * @param nodeMap
+     * @param nodes
+     * @param bufferManager
+     * @param bufferViews
+     * @param accessors
+     * @param animationSampleRate
+     */
+    static _CreateNodeAnimationFromNodeAnimations(babylonNode: Node, runtimeGLTFAnimation: IAnimation, idleGLTFAnimations: IAnimation[], nodeMap: Map<Node, number>, nodes: INode[], bufferManager: BufferManager, bufferViews: IBufferView[], accessors: IAccessor[], animationSampleRate: number, useRightHanded: boolean, shouldExportAnimation?: (animation: Animation) => boolean): void;
+    /**
+     * @ignore
+     * Create individual morph animations from the mesh's morph target animation tracks
+     * @param babylonNode
+     * @param runtimeGLTFAnimation
+     * @param idleGLTFAnimations
+     * @param nodeMap
+     * @param nodes
+     * @param bufferManager
+     * @param bufferViews
+     * @param accessors
+     * @param animationSampleRate
+     */
+    static _CreateMorphTargetAnimationFromMorphTargetAnimations(babylonNode: Node, runtimeGLTFAnimation: IAnimation, idleGLTFAnimations: IAnimation[], nodeMap: Map<Node, number>, nodes: INode[], bufferManager: BufferManager, bufferViews: IBufferView[], accessors: IAccessor[], animationSampleRate: number, useRightHanded: boolean, shouldExportAnimation?: (animation: Animation) => boolean): void;
+    /**
+     * @internal
+     * Create node and morph animations from the animation groups
+     * @param babylonScene
+     * @param glTFAnimations
+     * @param nodeMap
+     * @param nodes
+     * @param bufferManager
+     * @param bufferViews
+     * @param accessors
+     * @param animationSampleRate
+     */
+    static _CreateNodeAndMorphAnimationFromAnimationGroups(babylonScene: Scene, glTFAnimations: IAnimation[], nodeMap: Map<Node, number>, bufferManager: BufferManager, bufferViews: IBufferView[], accessors: IAccessor[], animationSampleRate: number, leftHandedNodes: Set<Node>, shouldExportAnimation?: (animation: Animation) => boolean): void;
+    private static _AddAnimation;
+    /**
+     * Create a baked animation
+     * @param babylonTransformNode BabylonJS mesh
+     * @param animation BabylonJS animation corresponding to the BabylonJS mesh
+     * @param animationChannelTargetPath animation target channel
+     * @param minFrame minimum animation frame
+     * @param maxFrame maximum animation frame
+     * @param fps frames per second of the animation
+     * @param sampleRate
+     * @param inputs input key frames of the animation
+     * @param outputs output key frame data of the animation
+     * @param minMaxFrames
+     * @param minMaxFrames.min
+     * @param minMaxFrames.max
+     * @param useQuaternion specifies if quaternions should be used
+     */
+    private static _CreateBakedAnimation;
+    private static _ConvertFactorToVector3OrQuaternion;
+    private static _SetInterpolatedValue;
+    /**
+     * Creates linear animation from the animation key frames
+     * @param babylonTransformNode BabylonJS mesh
+     * @param animation BabylonJS animation
+     * @param animationChannelTargetPath The target animation channel
+     * @param inputs Array to store the key frame times
+     * @param outputs Array to store the key frame data
+     * @param useQuaternion Specifies if quaternions are used in the animation
+     */
+    private static _CreateLinearOrStepAnimation;
+    /**
+     * Creates cubic spline animation from the animation key frames
+     * @param babylonTransformNode BabylonJS mesh
+     * @param animation BabylonJS animation
+     * @param animationChannelTargetPath The target animation channel
+     * @param inputs Array to store the key frame times
+     * @param outputs Array to store the key frame data
+     * @param useQuaternion Specifies if quaternions are used in the animation
+     */
+    private static _CreateCubicSplineAnimation;
+    private static _GetBasePositionRotationOrScale;
+    /**
+     * Adds a key frame value
+     * @param keyFrame
+     * @param animation
+     * @param outputs
+     * @param animationChannelTargetPath
+     * @param babylonTransformNode
+     * @param useQuaternion
+     */
+    private static _AddKeyframeValue;
+    /**
+     * @internal
+     * Determine the interpolation based on the key frames
+     * @param keyFrames
+     * @param animationChannelTargetPath
+     * @param useQuaternion
+     */
+    private static _DeduceInterpolation;
+    /**
+     * Adds an input tangent or output tangent to the output data
+     * If an input tangent or output tangent is missing, it uses the zero vector or zero quaternion
+     * @param tangentType Specifies which type of tangent to handle (inTangent or outTangent)
+     * @param outputs The animation data by keyframe
+     * @param animationChannelTargetPath The target animation channel
+     * @param interpolation The interpolation type
+     * @param keyFrame The key frame with the animation data
+     * @param useQuaternion Specifies if quaternions are used
+     */
+    private static _AddSplineTangent;
+    /**
+     * Get the minimum and maximum key frames' frame values
+     * @param keyFrames animation key frames
+     * @returns the minimum and maximum key frame value
+     */
+    private static _CalculateMinMaxKeyFrames;
+}