@onerjs/serializers 8.28.6 → 8.28.8

package/glTF/2.0/glTFExporter2.d.ts

@@ -0,0 +1,113 @@
+import type { IBufferView, IAccessor, INode, IScene, IMesh, IMaterial, ITexture, IImage, ISampler, IAnimation, IMeshPrimitive, IGLTF, ITextureInfo, ISkin, ICamera, ImageMimeType } from "babylonjs-gltf2interface";
+import type { Nullable } from "@onerjs/core/types.js";
+import type { Node } from "@onerjs/core/node.js";
+import type { BaseTexture } from "@onerjs/core/Materials/Textures/baseTexture.js";
+import { Material } from "@onerjs/core/Materials/material.js";
+import type { Scene } from "@onerjs/core/scene.js";
+import type { IGLTFExporterExtensionV2 } from "./glTFExporterExtension.js";
+import { GLTFMaterialExporter } from "./glTFMaterialExporter.js";
+import type { IExportOptions } from "./glTFSerializer.js";
+import { GLTFData } from "./glTFData.js";
+import { BufferManager } from "./bufferManager.js";
+/** @internal */
+export declare class GLTFExporter {
+    readonly _glTF: IGLTF;
+    readonly _animations: IAnimation[];
+    readonly _accessors: IAccessor[];
+    readonly _bufferViews: IBufferView[];
+    readonly _cameras: ICamera[];
+    readonly _images: IImage[];
+    readonly _materials: IMaterial[];
+    readonly _meshes: IMesh[];
+    readonly _nodes: INode[];
+    readonly _samplers: ISampler[];
+    readonly _scenes: IScene[];
+    readonly _skins: ISkin[];
+    readonly _textures: ITexture[];
+    readonly _babylonScene: Scene;
+    readonly _imageData: {
+        [fileName: string]: {
+            data: ArrayBuffer;
+            mimeType: ImageMimeType;
+        };
+    };
+    /**
+     * Baked animation sample rate
+     */
+    private _animationSampleRate;
+    private readonly _options;
+    _shouldUseGlb: boolean;
+    readonly _materialExporter: GLTFMaterialExporter;
+    private readonly _extensions;
+    readonly _bufferManager: BufferManager;
+    private readonly _shouldExportNodeMap;
+    private readonly _nodeMap;
+    readonly _materialMap: Map<Material, number>;
+    private readonly _camerasMap;
+    private readonly _nodesCameraMap;
+    private readonly _skinMap;
+    private readonly _nodesSkinMap;
+    readonly _materialNeedsUVsSet: Set<Material>;
+    private static readonly _ExtensionNames;
+    private static readonly _ExtensionFactories;
+    private static readonly _ExtensionOrders;
+    private _ApplyExtension;
+    private _ApplyExtensions;
+    _extensionsPostExportNodeAsync(context: string, node: INode, babylonNode: Node, nodeMap: Map<Node, number>, convertToRightHanded: boolean): Promise<Nullable<INode>>;
+    _extensionsPostExportMaterialAsync(context: string, material: IMaterial, babylonMaterial: Material): Promise<Nullable<IMaterial>>;
+    /**
+     * Get additional textures for a material
+     * @param context The context when loading the asset
+     * @param material The glTF material
+     * @param babylonMaterial The Babylon.js material
+     * @returns List of additional textures
+     */
+    _extensionsPostExportMaterialAdditionalTexturesAsync(context: string, material: IMaterial, babylonMaterial: Material): Promise<BaseTexture[]>;
+    _extensionsPostExportTextures(context: string, textureInfo: ITextureInfo, babylonTexture: BaseTexture): void;
+    _extensionsPostExportMeshPrimitive(primitive: IMeshPrimitive): void;
+    _extensionsPreGenerateBinaryAsync(): Promise<void>;
+    private _forEachExtensions;
+    private _extensionsOnExporting;
+    private _loadExtensions;
+    constructor(babylonScene?: Nullable<Scene>, options?: IExportOptions);
+    dispose(): void;
+    get options(): Required<IExportOptions>;
+    static RegisterExtension(name: string, factory: (exporter: GLTFExporter) => IGLTFExporterExtensionV2, order?: number): void;
+    static UnregisterExtension(name: string): boolean;
+    private _generateJSON;
+    generateGLTFAsync(glTFPrefix: string): Promise<GLTFData>;
+    private _generateBinaryAsync;
+    /**
+     * Pads the number to a multiple of 4
+     * @param num number to pad
+     * @returns padded number
+     */
+    private _getPadding;
+    generateGLBAsync(glTFPrefix: string): Promise<GLTFData>;
+    private _setNodeTransformation;
+    private _setCameraTransformation;
+    private _listAvailableCameras;
+    private _exportAndAssignCameras;
+    private _listAvailableSkeletons;
+    private _exportAndAssignSkeletons;
+    private _exportSceneAsync;
+    private _shouldExportNode;
+    private _exportNodesAsync;
+    private _collectBuffers;
+    private _exportBuffers;
+    /**
+     * Processes a node to be exported to the glTF file
+     * @returns A promise that resolves once the node has been exported
+     * @internal
+     */
+    private _exportNodeAsync;
+    /**
+     * Creates a glTF node from a Babylon.js node. If skipped, returns null.
+     * @internal
+     */
+    private _createNodeAsync;
+    private _exportIndices;
+    private _exportVertexBuffer;
+    private _exportMaterialAsync;
+    private _exportMeshAsync;
+}