@babylonjs/core 6.33.2 → 6.34.0-alpha.0

package/esm/Engines/Extensions/cubeTexture/cubeTexture.base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cubeTexture.base.js","sourceRoot":"","sources":["../../../../../../../dev/core/src/esm/Engines/Extensions/cubeTexture/cubeTexture.base.ts"],"names":[],"mappings":"","sourcesContent":["import type { RenderTargetWrapper } from \"core/Engines/renderTargetWrapper\";\r\nimport type { InternalTexture } from \"core/Materials/Textures/internalTexture\";\r\nimport type { DepthTextureCreationOptions } from \"core/Materials/Textures/textureCreationOptions\";\r\nimport type { Scene } from \"core/scene\";\r\nimport type { Nullable } from \"core/types\";\r\nimport type { IBaseEnginePublic } from \"../../engine.base\";\r\n\r\nexport interface ICubeTextureEngineExtension {\r\n    /**\r\n     * Creates a depth stencil cube texture.\r\n     * This is only available in WebGL 2.\r\n     * @param size The size of face edge in the cube texture.\r\n     * @param options The options defining the cube texture.\r\n     * @param rtWrapper The render target wrapper for which the depth/stencil texture must be created\r\n     * @returns The cube texture\r\n     */\r\n    _createDepthStencilCubeTexture(engineState: IBaseEnginePublic, size: number, options: DepthTextureCreationOptions, rtWrapper: RenderTargetWrapper): InternalTexture;\r\n\r\n    /**\r\n     * Creates a cube texture\r\n     * @param rootUrl defines the url where the files to load is located\r\n     * @param scene defines the current scene\r\n     * @param files defines the list of files to load (1 per face)\r\n     * @param noMipmap defines a boolean indicating that no mipmaps shall be generated (false by default)\r\n     * @param onLoad defines an optional callback raised when the texture is loaded\r\n     * @param onError defines an optional callback raised if there is an issue to load the texture\r\n     * @param format defines the format of the data\r\n     * @param forcedExtension defines the extension to use to pick the right loader\r\n     * @param createPolynomials if a polynomial sphere should be created for the cube texture\r\n     * @param lodScale defines the scale applied to environment texture. This manages the range of LOD level used for IBL according to the roughness\r\n     * @param lodOffset defines the offset applied to environment texture. This manages first LOD level used for IBL according to the roughness\r\n     * @param fallback defines texture to use while falling back when (compressed) texture file not found.\r\n     * @param loaderOptions options to be passed to the loader\r\n     * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).\r\n     * @returns the cube texture as an InternalTexture\r\n     */\r\n    createCubeTexture(\r\n        engineState: IBaseEnginePublic,\r\n        rootUrl: string,\r\n        scene: Nullable<Scene>,\r\n        files: Nullable<string[]>,\r\n        noMipmap: boolean | undefined,\r\n        onLoad: Nullable<(data?: any) => void>,\r\n        onError: Nullable<(message?: string, exception?: any) => void>,\r\n        format: number | undefined,\r\n        forcedExtension: any,\r\n        createPolynomials: boolean,\r\n        lodScale: number,\r\n        lodOffset: number,\r\n        fallback: Nullable<InternalTexture>,\r\n        loaderOptions: any,\r\n        useSRGBBuffer: boolean\r\n    ): InternalTexture;\r\n\r\n    /**\r\n     * Creates a cube texture\r\n     * @param rootUrl defines the url where the files to load is located\r\n     * @param scene defines the current scene\r\n     * @param files defines the list of files to load (1 per face)\r\n     * @param noMipmap defines a boolean indicating that no mipmaps shall be generated (false by default)\r\n     * @param onLoad defines an optional callback raised when the texture is loaded\r\n     * @param onError defines an optional callback raised if there is an issue to load the texture\r\n     * @param format defines the format of the data\r\n     * @param forcedExtension defines the extension to use to pick the right loader\r\n     * @returns the cube texture as an InternalTexture\r\n     */\r\n    createCubeTexture(\r\n        engineState: IBaseEnginePublic,\r\n        rootUrl: string,\r\n        scene: Nullable<Scene>,\r\n        files: Nullable<string[]>,\r\n        noMipmap: boolean,\r\n        onLoad: Nullable<(data?: any) => void>,\r\n        onError: Nullable<(message?: string, exception?: any) => void>,\r\n        format: number | undefined,\r\n        forcedExtension: any\r\n    ): InternalTexture;\r\n\r\n    /**\r\n     * Creates a cube texture\r\n     * @param rootUrl defines the url where the files to load is located\r\n     * @param scene defines the current scene\r\n     * @param files defines the list of files to load (1 per face)\r\n     * @param noMipmap defines a boolean indicating that no mipmaps shall be generated (false by default)\r\n     * @param onLoad defines an optional callback raised when the texture is loaded\r\n     * @param onError defines an optional callback raised if there is an issue to load the texture\r\n     * @param format defines the format of the data\r\n     * @param forcedExtension defines the extension to use to pick the right loader\r\n     * @param createPolynomials if a polynomial sphere should be created for the cube texture\r\n     * @param lodScale defines the scale applied to environment texture. This manages the range of LOD level used for IBL according to the roughness\r\n     * @param lodOffset defines the offset applied to environment texture. This manages first LOD level used for IBL according to the roughness\r\n     * @returns the cube texture as an InternalTexture\r\n     */\r\n    createCubeTexture(\r\n        engineState: IBaseEnginePublic,\r\n        rootUrl: string,\r\n        scene: Nullable<Scene>,\r\n        files: Nullable<string[]>,\r\n        noMipmap: boolean,\r\n        onLoad: Nullable<(data?: any) => void>,\r\n        onError: Nullable<(message?: string, exception?: any) => void>,\r\n        format: number | undefined,\r\n        forcedExtension: any,\r\n        createPolynomials: boolean,\r\n        lodScale: number,\r\n        lodOffset: number\r\n    ): InternalTexture;\r\n\r\n    /** @internal */\r\n    createCubeTextureBase(\r\n        engineState: IBaseEnginePublic,\r\n        rootUrl: string,\r\n        scene: Nullable<Scene>,\r\n        files: Nullable<string[]>,\r\n        noMipmap: boolean | undefined,\r\n        onLoad: Nullable<(data?: any) => void>,\r\n        onError: Nullable<(message?: string, exception?: any) => void>,\r\n        format: number | undefined,\r\n        forcedExtension: any,\r\n        createPolynomials: boolean,\r\n        lodScale: number,\r\n        lodOffset: number,\r\n        fallback: Nullable<InternalTexture>,\r\n        beforeLoadCubeDataCallback: Nullable<(texture: InternalTexture, data: ArrayBufferView | ArrayBufferView[]) => void>,\r\n        imageHandler: Nullable<(texture: InternalTexture, imgs: HTMLImageElement[] | ImageBitmap[]) => void>,\r\n        useSRGBBuffer: boolean\r\n    ): InternalTexture;\r\n\r\n    /** @internal */\r\n    _partialLoadFile(\r\n        engineState: IBaseEnginePublic,\r\n        url: string,\r\n        index: number,\r\n        loadedFiles: ArrayBuffer[],\r\n        onfinish: (files: ArrayBuffer[]) => void,\r\n        onErrorCallBack: Nullable<(message?: string, exception?: any) => void>\r\n    ): void;\r\n\r\n    /** @internal */\r\n    _cascadeLoadFiles(\r\n        engineState: IBaseEnginePublic,\r\n        scene: Nullable<Scene>,\r\n        onfinish: (images: ArrayBuffer[]) => void,\r\n        files: string[],\r\n        onError: Nullable<(message?: string, exception?: any) => void>\r\n    ): void;\r\n\r\n    /** @internal */\r\n    _cascadeLoadImgs(\r\n        engineState: IBaseEnginePublic,\r\n        scene: Nullable<Scene>,\r\n        texture: InternalTexture,\r\n        onfinish: Nullable<(texture: InternalTexture, images: HTMLImageElement[] | ImageBitmap[]) => void>,\r\n        files: string[],\r\n        onError: Nullable<(message?: string, exception?: any) => void>,\r\n        mimeType?: string\r\n    ): void;\r\n\r\n    /** @internal */\r\n    _partialLoadImg(\r\n        engineState: IBaseEnginePublic,\r\n        url: string,\r\n        index: number,\r\n        loadedImages: HTMLImageElement[] | ImageBitmap[],\r\n        scene: Nullable<Scene>,\r\n        texture: InternalTexture,\r\n        onfinish: Nullable<(texture: InternalTexture, images: HTMLImageElement[] | ImageBitmap[]) => void>,\r\n        onErrorCallBack: Nullable<(message?: string, exception?: any) => void>,\r\n        mimeType?: string\r\n    ): void;\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    _setCubeMapTextureParams(engineState: IBaseEnginePublic, texture: InternalTexture, loadMipmap: boolean, maxLevel?: number): void;\r\n}\r\n"]}

package/esm/Engines/Extensions/debugging/debugging.base.d.ts

@@ -0,0 +1,11 @@
+import type { IBaseEnginePublic } from "../../engine.base";
+export interface IDebuggingEngineExtension {
+    /** @internal */
+    _debugPushGroup(engineState: IBaseEnginePublic, groupName: string, targetObject?: number): void;
+    /** @internal */
+    _debugPopGroup(engineState: IBaseEnginePublic, targetObject?: number): void;
+    /** @internal */
+    _debugInsertMarker(engineState: IBaseEnginePublic, text: string, targetObject?: number): void;
+    /** @internal */
+    _debugFlushPendingCommands(engineState: IBaseEnginePublic): void;
+}

package/esm/Engines/Extensions/debugging/debugging.base.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=debugging.base.js.map

package/esm/Engines/Extensions/debugging/debugging.base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debugging.base.js","sourceRoot":"","sources":["../../../../../../../dev/core/src/esm/Engines/Extensions/debugging/debugging.base.ts"],"names":[],"mappings":"","sourcesContent":["import type { IBaseEnginePublic } from \"../../engine.base\";\r\n\r\nexport interface IDebuggingEngineExtension {\r\n    /** @internal */\r\n    _debugPushGroup(engineState: IBaseEnginePublic, groupName: string, targetObject?: number): void;\r\n\r\n    /** @internal */\r\n    _debugPopGroup(engineState: IBaseEnginePublic, targetObject?: number): void;\r\n\r\n    /** @internal */\r\n    _debugInsertMarker(engineState: IBaseEnginePublic, text: string, targetObject?: number): void;\r\n\r\n    /** @internal */\r\n    _debugFlushPendingCommands(engineState: IBaseEnginePublic): void;\r\n}\r\n"]}

package/esm/Engines/Extensions/dynamicBuffer/dynamicBuffer.base.d.ts

@@ -0,0 +1,20 @@
+import type { DataBuffer } from "../../../../Buffers/dataBuffer.js";
+import type { DataArray, IndicesArray } from "../../../../types.js";
+import type { IBaseEnginePublic } from "../../engine.base";
+export interface IDynamicBufferEngineExtension {
+    /**
+     * Update a dynamic index buffer
+     * @param indexBuffer defines the target index buffer
+     * @param indices defines the data to update
+     * @param offset defines the offset in the target index buffer where update should start
+     */
+    updateDynamicIndexBuffer(engineState: IBaseEnginePublic, indexBuffer: DataBuffer, indices: IndicesArray, offset?: number): void;
+    /**
+     * Updates a dynamic vertex buffer.
+     * @param vertexBuffer the vertex buffer to update
+     * @param data the data used to update the vertex buffer
+     * @param byteOffset the byte offset of the data
+     * @param byteLength the byte length of the data
+     */
+    updateDynamicVertexBuffer(engineState: IBaseEnginePublic, vertexBuffer: DataBuffer, data: DataArray, byteOffset?: number, byteLength?: number): void;
+}

package/esm/Engines/Extensions/dynamicBuffer/dynamicBuffer.base.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dynamicBuffer.base.js.map

package/esm/Engines/Extensions/dynamicBuffer/dynamicBuffer.base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamicBuffer.base.js","sourceRoot":"","sources":["../../../../../../../dev/core/src/esm/Engines/Extensions/dynamicBuffer/dynamicBuffer.base.ts"],"names":[],"mappings":"","sourcesContent":["import type { DataBuffer } from \"core/Buffers/dataBuffer\";\r\nimport type { DataArray, IndicesArray } from \"core/types\";\r\nimport type { IBaseEnginePublic } from \"../../engine.base\";\r\n\r\nexport interface IDynamicBufferEngineExtension {\r\n    /**\r\n     * Update a dynamic index buffer\r\n     * @param indexBuffer defines the target index buffer\r\n     * @param indices defines the data to update\r\n     * @param offset defines the offset in the target index buffer where update should start\r\n     */\r\n    updateDynamicIndexBuffer(engineState: IBaseEnginePublic, indexBuffer: DataBuffer, indices: IndicesArray, offset?: number): void;\r\n\r\n    /**\r\n     * Updates a dynamic vertex buffer.\r\n     * @param vertexBuffer the vertex buffer to update\r\n     * @param data the data used to update the vertex buffer\r\n     * @param byteOffset the byte offset of the data\r\n     * @param byteLength the byte length of the data\r\n     */\r\n    updateDynamicVertexBuffer(engineState: IBaseEnginePublic, vertexBuffer: DataBuffer, data: DataArray, byteOffset?: number, byteLength?: number): void;\r\n}\r\n"]}

package/esm/Engines/Extensions/dynamicTexture/dynamicTexture.base.d.ts

@@ -0,0 +1,26 @@
+import type { InternalTexture } from "../../../../Materials/Textures/internalTexture.js";
+import type { ICanvas } from "../../../../Engines/ICanvas.js";
+import type { Nullable } from "../../../../types.js";
+import type { IBaseEnginePublic } from "../../engine.base";
+export interface IDynamicTextureEngineExtension {
+    /**
+     * Creates a dynamic texture
+     * @param width defines the width of the texture
+     * @param height defines the height of the texture
+     * @param generateMipMaps defines if the engine should generate the mip levels
+     * @param samplingMode defines the required sampling mode (Texture.NEAREST_SAMPLINGMODE by default)
+     * @returns the dynamic texture inside an InternalTexture
+     */
+    createDynamicTexture(engineState: IBaseEnginePublic, width: number, height: number, generateMipMaps: boolean, samplingMode: number): InternalTexture;
+    /**
+     * Update the content of a dynamic texture
+     * @param texture defines the texture to update
+     * @param source defines the source containing the data
+     * @param invertY defines if data must be stored with Y axis inverted
+     * @param premulAlpha defines if alpha is stored as premultiplied
+     * @param format defines the format of the data
+     * @param forceBindTexture if the texture should be forced to be bound eg. after a graphics context loss (Default: false)
+     * @param allowGPUOptimization true to allow some specific GPU optimizations (subject to engine feature "allowGPUOptimizationsForGUI" being true)
+     */
+    updateDynamicTexture(engineState: IBaseEnginePublic, texture: Nullable<InternalTexture>, source: ImageBitmap | ImageData | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | OffscreenCanvas | ICanvas, invertY?: boolean, premulAlpha?: boolean, format?: number, forceBindTexture?: boolean, allowGPUOptimization?: boolean): void;
+}

package/esm/Engines/Extensions/dynamicTexture/dynamicTexture.base.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dynamicTexture.base.js.map

package/esm/Engines/Extensions/dynamicTexture/dynamicTexture.base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamicTexture.base.js","sourceRoot":"","sources":["../../../../../../../dev/core/src/esm/Engines/Extensions/dynamicTexture/dynamicTexture.base.ts"],"names":[],"mappings":"","sourcesContent":["import type { InternalTexture } from \"core/Materials/Textures/internalTexture\";\r\nimport type { ICanvas } from \"core/Engines/ICanvas\";\r\nimport type { Nullable } from \"core/types\";\r\nimport type { IBaseEnginePublic } from \"../../engine.base\";\r\n\r\nexport interface IDynamicTextureEngineExtension {\r\n    /**\r\n     * Creates a dynamic texture\r\n     * @param width defines the width of the texture\r\n     * @param height defines the height of the texture\r\n     * @param generateMipMaps defines if the engine should generate the mip levels\r\n     * @param samplingMode defines the required sampling mode (Texture.NEAREST_SAMPLINGMODE by default)\r\n     * @returns the dynamic texture inside an InternalTexture\r\n     */\r\n    createDynamicTexture(engineState: IBaseEnginePublic, width: number, height: number, generateMipMaps: boolean, samplingMode: number): InternalTexture;\r\n\r\n    /**\r\n     * Update the content of a dynamic texture\r\n     * @param texture defines the texture to update\r\n     * @param source defines the source containing the data\r\n     * @param invertY defines if data must be stored with Y axis inverted\r\n     * @param premulAlpha defines if alpha is stored as premultiplied\r\n     * @param format defines the format of the data\r\n     * @param forceBindTexture if the texture should be forced to be bound eg. after a graphics context loss (Default: false)\r\n     * @param allowGPUOptimization true to allow some specific GPU optimizations (subject to engine feature \"allowGPUOptimizationsForGUI\" being true)\r\n     */\r\n    updateDynamicTexture(\r\n        engineState: IBaseEnginePublic,\r\n        texture: Nullable<InternalTexture>,\r\n        source: ImageBitmap | ImageData | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | OffscreenCanvas | ICanvas,\r\n        invertY?: boolean,\r\n        premulAlpha?: boolean,\r\n        format?: number,\r\n        forceBindTexture?: boolean,\r\n        allowGPUOptimization?: boolean\r\n    ): void;\r\n}\r\n"]}

package/esm/Engines/Extensions/engine.extensions.d.ts

@@ -0,0 +1,67 @@
+import type { IBaseEnginePublic } from "../engine.base";
+import type { ICubeTextureEngineExtension } from "./cubeTexture/cubeTexture.base";
+import type { IRawTextureEngineExtension } from "./rawTexture/engine.rawTexture.base";
+import type { IMultiRenderEngineExtension } from "./multiRender/multiRender.base";
+import type { IRenderTargetEngineExtension } from "./renderTarget/renderTarget.base";
+import type { ITransformFeedbackEngineExtension } from "./transformFeedback/engine.transformFeedback.base";
+import type { IAlphaEngineExtension } from "./alpha/alpha.base";
+import type { IDynamicBufferEngineExtension } from "./dynamicBuffer/dynamicBuffer.base";
+import type { IQueryEngineExtension } from "./query/query.base";
+import type { IDynamicTextureEngineExtension } from "./dynamicTexture/dynamicTexture.base";
+import type { IViewsEngineExtension } from "./views/views.base";
+import type { IMultiviewEngineExtension } from "./multiview/multiview.base";
+import type { IReadTextureEngineExtension } from "./readTexture/readTexture.base";
+import type { IRenderTargetCubeEngineExtension } from "./renderTargetCube/renderTargetCube.base";
+import type { ITextureSelectorEngineExtension } from "./textureSelector/textureSelector.base";
+import type { IUniformBufferEngineExtension } from "./uniformBuffer/uniformBuffer.base";
+import type { IVideoTextureEngineExtension } from "./videoTexture/videoTexture.base";
+export declare const enum EngineExtensions {
+    RAW_TEXTURE = 0,
+    TRANSFORM_FEEDBACK = 1,
+    RENDER_TARGET = 2,
+    MULTI_RENDER = 3,
+    CUBE_TEXTURE = 4,
+    ALPHA = 5,
+    QUERY = 6,
+    DYNAMIC_BUFFER = 7,
+    DYNAMIC_TEXTURE = 8,
+    VIEWS = 9,
+    MULTIVIEW = 10,
+    READ_TEXTURE = 11,
+    RENDER_TARGET_CUBE = 12,
+    TEXTURE_SELECTOR = 13,
+    UNIFORM_BUFFER = 14,
+    VIDEO_TEXTURE = 15
+}
+export interface IBaseEngineExtension {
+    extensionState: any;
+    initExtension(): void;
+}
+export interface IEngineExtensions {
+    [EngineExtensions.RAW_TEXTURE]?: IRawTextureEngineExtension;
+    [EngineExtensions.TRANSFORM_FEEDBACK]?: ITransformFeedbackEngineExtension;
+    [EngineExtensions.RENDER_TARGET]?: IRenderTargetEngineExtension;
+    [EngineExtensions.MULTI_RENDER]?: IMultiRenderEngineExtension;
+    [EngineExtensions.CUBE_TEXTURE]?: ICubeTextureEngineExtension;
+    [EngineExtensions.ALPHA]?: IAlphaEngineExtension;
+    [EngineExtensions.QUERY]?: IQueryEngineExtension;
+    [EngineExtensions.DYNAMIC_BUFFER]?: IDynamicBufferEngineExtension;
+    [EngineExtensions.DYNAMIC_TEXTURE]?: IDynamicTextureEngineExtension;
+    [EngineExtensions.VIEWS]?: IViewsEngineExtension;
+    [EngineExtensions.MULTIVIEW]?: IMultiviewEngineExtension;
+    [EngineExtensions.READ_TEXTURE]?: IReadTextureEngineExtension;
+    [EngineExtensions.RENDER_TARGET_CUBE]?: IRenderTargetCubeEngineExtension;
+    [EngineExtensions.TEXTURE_SELECTOR]?: ITextureSelectorEngineExtension;
+    [EngineExtensions.UNIFORM_BUFFER]?: IUniformBufferEngineExtension;
+    [EngineExtensions.VIDEO_TEXTURE]?: IVideoTextureEngineExtension;
+}
+export type IEngineExtension = IEngineExtensions[EngineExtensions];
+export declare function getEngineExtensions(engineState: IBaseEnginePublic): IEngineExtensions;
+export declare function getEngineExtension<K extends keyof IEngineExtensions>(engineState: IBaseEnginePublic, type: K): IEngineExtensions[K];
+export declare function loadExtension<K extends keyof IEngineExtensions>(type: K, extension: IEngineExtensions[K], engineType?: string): IEngineExtensions[K];
+export declare function setExtension<K extends keyof IEngineExtensions, T extends IBaseEnginePublic>(engineState: T, type: K, extension: IEngineExtensions[K]): void;
+/**
+ * Augment an engine state with the extensions tht are already loaded
+ * @param engineState the engine state to augment
+ */
+export declare function augmentEngineStateWithExtensions(engineState: IBaseEnginePublic): void;

package/esm/Engines/Extensions/engine.extensions.js

@@ -0,0 +1,49 @@
+/* eslint-disable jsdoc/require-jsdoc */
+import { augmentEngineState } from "../engine.adapters.js";
+const loadedExtensions = {};
+/**
+ * this array stores engine extensions base on the engine unique id
+ */
+const engineExtensions = [];
+export function getEngineExtensions(engineState) {
+    engineExtensions[engineState.uniqueId] = engineExtensions[engineState.uniqueId] || {};
+    return engineExtensions[engineState.uniqueId];
+}
+export function getEngineExtension(engineState, type) {
+    try {
+        return getEngineExtensions(engineState)[type];
+    }
+    catch (e) {
+        throw new Error(`Extension ${type} is not available`);
+    }
+}
+export function loadExtension(type, extension, engineType = "WebGL" /* WebGL | WebGPU */) {
+    loadedExtensions[engineType] = loadedExtensions[engineType] || {};
+    loadedExtensions[engineType][type] = extension;
+    return extension;
+}
+export function setExtension(engineState, type, extension) {
+    const extensions = getEngineExtensions(engineState);
+    // the any cast is required to avoid TS error when setting the extension
+    extensions[type] = extension;
+    // augment the engine state with these functions
+    // casted to any, as this is a legacy solution and is not part of the engine interface
+    augmentEngineState(engineState, extension);
+    if (!loadedExtensions[type]) {
+        loadExtension(type, extension, engineState.name);
+    }
+}
+/**
+ * Augment an engine state with the extensions tht are already loaded
+ * @param engineState the engine state to augment
+ */
+export function augmentEngineStateWithExtensions(engineState) {
+    const engineType = engineState.name;
+    // augment the engine state with these functions
+    // casted to any, as this is a legacy solution and is not part of the engine interface
+    const extensionsTypeArray = Object.keys(loadedExtensions[engineType]);
+    for (const extension of extensionsTypeArray) {
+        setExtension(engineState, extension, loadedExtensions[engineType][extension]);
+    }
+}
+//# sourceMappingURL=engine.extensions.js.map

package/esm/Engines/Extensions/engine.extensions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.extensions.js","sourceRoot":"","sources":["../../../../../../dev/core/src/esm/Engines/Extensions/engine.extensions.ts"],"names":[],"mappings":"AAAA,wCAAwC;AACxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAgExD,MAAM,gBAAgB,GAAyC,EAAE,CAAC;AAElE;;GAEG;AACH,MAAM,gBAAgB,GAAwB,EAAE,CAAC;AAEjD,MAAM,UAAU,mBAAmB,CAAC,WAA8B;IAC9D,gBAAgB,CAAC,WAAW,CAAC,QAAQ,CAAC,GAAG,gBAAgB,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAK,EAAwB,CAAC;IAC7G,OAAO,gBAAgB,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;AAClD,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAoC,WAA8B,EAAE,IAAO;IACzG,IAAI;QACA,OAAO,mBAAmB,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,CAAC;KACjD;IAAC,OAAO,CAAC,EAAE;QACR,MAAM,IAAI,KAAK,CAAC,aAAa,IAAI,mBAAmB,CAAC,CAAC;KACzD;AACL,CAAC;AAED,MAAM,UAAU,aAAa,CACzB,IAAO,EACP,SAA+B,EAC/B,aAAqB,OAAO,CAAC,oBAAoB;IAEjD,gBAAgB,CAAC,UAAU,CAAC,GAAG,gBAAgB,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;IAClE,gBAAgB,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;IAC/C,OAAO,SAAS,CAAC;AACrB,CAAC;AAED,MAAM,UAAU,YAAY,CAAiE,WAAc,EAAE,IAAO,EAAE,SAA+B;IACjJ,MAAM,UAAU,GAAG,mBAAmB,CAAC,WAAW,CAAC,CAAC;IACpD,wEAAwE;IACxE,UAAU,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;IAC7B,gDAAgD;IAChD,sFAAsF;IACtF,kBAAkB,CAAC,WAAkB,EAAE,SAAgB,CAAC,CAAC;IAEzD,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE;QACzB,aAAa,CAAC,IAAI,EAAE,SAAS,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC;KACpD;AACL,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,gCAAgC,CAAC,WAA8B;IAC3E,MAAM,UAAU,GAAG,WAAW,CAAC,IAAI,CAAC;IACpC,gDAAgD;IAChD,sFAAsF;IACtF,MAAM,mBAAmB,GAAG,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAkC,CAAC;IACvG,KAAK,MAAM,SAAS,IAAI,mBAAmB,EAAE;QACzC,YAAY,CAAC,WAAW,EAAE,SAAS,EAAE,gBAAgB,CAAC,UAAU,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;KACjF;AACL,CAAC","sourcesContent":["/* eslint-disable jsdoc/require-jsdoc */\r\nimport { augmentEngineState } from \"../engine.adapters\";\r\nimport type { IBaseEnginePublic } from \"../engine.base\";\r\nimport type { ICubeTextureEngineExtension } from \"./cubeTexture/cubeTexture.base\";\r\nimport type { IRawTextureEngineExtension } from \"./rawTexture/engine.rawTexture.base\";\r\nimport type { IMultiRenderEngineExtension } from \"./multiRender/multiRender.base\";\r\nimport type { IRenderTargetEngineExtension } from \"./renderTarget/renderTarget.base\";\r\nimport type { ITransformFeedbackEngineExtension } from \"./transformFeedback/engine.transformFeedback.base\";\r\nimport type { IAlphaEngineExtension } from \"./alpha/alpha.base\";\r\nimport type { IDynamicBufferEngineExtension } from \"./dynamicBuffer/dynamicBuffer.base\";\r\nimport type { IQueryEngineExtension } from \"./query/query.base\";\r\nimport type { IDynamicTextureEngineExtension } from \"./dynamicTexture/dynamicTexture.base\";\r\nimport type { IViewsEngineExtension } from \"./views/views.base\";\r\nimport type { IMultiviewEngineExtension } from \"./multiview/multiview.base\";\r\nimport type { IReadTextureEngineExtension } from \"./readTexture/readTexture.base\";\r\nimport type { IRenderTargetCubeEngineExtension } from \"./renderTargetCube/renderTargetCube.base\";\r\nimport type { ITextureSelectorEngineExtension } from \"./textureSelector/textureSelector.base\";\r\nimport type { IUniformBufferEngineExtension } from \"./uniformBuffer/uniformBuffer.base\";\r\nimport type { IVideoTextureEngineExtension } from \"./videoTexture/videoTexture.base\";\r\n\r\nexport const enum EngineExtensions {\r\n    RAW_TEXTURE = 0,\r\n    TRANSFORM_FEEDBACK = 1,\r\n    RENDER_TARGET = 2,\r\n    MULTI_RENDER = 3,\r\n    CUBE_TEXTURE = 4,\r\n    ALPHA = 5,\r\n    QUERY = 6,\r\n    DYNAMIC_BUFFER = 7,\r\n    DYNAMIC_TEXTURE = 8,\r\n    VIEWS = 9,\r\n    MULTIVIEW = 10,\r\n    READ_TEXTURE = 11,\r\n    RENDER_TARGET_CUBE = 12,\r\n    TEXTURE_SELECTOR = 13,\r\n    UNIFORM_BUFFER = 14,\r\n    VIDEO_TEXTURE = 15,\r\n}\r\n\r\nexport interface IBaseEngineExtension {\r\n    extensionState: any;\r\n    initExtension(): void;\r\n}\r\n\r\nexport interface IEngineExtensions {\r\n    [EngineExtensions.RAW_TEXTURE]?: IRawTextureEngineExtension;\r\n    [EngineExtensions.TRANSFORM_FEEDBACK]?: ITransformFeedbackEngineExtension;\r\n    [EngineExtensions.RENDER_TARGET]?: IRenderTargetEngineExtension;\r\n    [EngineExtensions.MULTI_RENDER]?: IMultiRenderEngineExtension;\r\n    [EngineExtensions.CUBE_TEXTURE]?: ICubeTextureEngineExtension;\r\n    [EngineExtensions.ALPHA]?: IAlphaEngineExtension;\r\n    [EngineExtensions.QUERY]?: IQueryEngineExtension;\r\n    [EngineExtensions.DYNAMIC_BUFFER]?: IDynamicBufferEngineExtension;\r\n    [EngineExtensions.DYNAMIC_TEXTURE]?: IDynamicTextureEngineExtension;\r\n    [EngineExtensions.VIEWS]?: IViewsEngineExtension;\r\n    [EngineExtensions.MULTIVIEW]?: IMultiviewEngineExtension;\r\n    [EngineExtensions.READ_TEXTURE]?: IReadTextureEngineExtension;\r\n    [EngineExtensions.RENDER_TARGET_CUBE]?: IRenderTargetCubeEngineExtension;\r\n    [EngineExtensions.TEXTURE_SELECTOR]?: ITextureSelectorEngineExtension;\r\n    [EngineExtensions.UNIFORM_BUFFER]?: IUniformBufferEngineExtension;\r\n    [EngineExtensions.VIDEO_TEXTURE]?: IVideoTextureEngineExtension;\r\n}\r\n\r\nexport type IEngineExtension = IEngineExtensions[EngineExtensions];\r\n\r\nconst loadedExtensions: { [key: string]: IEngineExtensions } = {};\r\n\r\n/**\r\n * this array stores engine extensions base on the engine unique id\r\n */\r\nconst engineExtensions: IEngineExtensions[] = [];\r\n\r\nexport function getEngineExtensions(engineState: IBaseEnginePublic): IEngineExtensions {\r\n    engineExtensions[engineState.uniqueId] = engineExtensions[engineState.uniqueId] || ({} as IEngineExtensions);\r\n    return engineExtensions[engineState.uniqueId];\r\n}\r\n\r\nexport function getEngineExtension<K extends keyof IEngineExtensions>(engineState: IBaseEnginePublic, type: K): IEngineExtensions[K] {\r\n    try {\r\n        return getEngineExtensions(engineState)[type];\r\n    } catch (e) {\r\n        throw new Error(`Extension ${type} is not available`);\r\n    }\r\n}\r\n\r\nexport function loadExtension<K extends keyof IEngineExtensions>(\r\n    type: K,\r\n    extension: IEngineExtensions[K],\r\n    engineType: string = \"WebGL\" /* WebGL | WebGPU */\r\n): IEngineExtensions[K] {\r\n    loadedExtensions[engineType] = loadedExtensions[engineType] || {};\r\n    loadedExtensions[engineType][type] = extension;\r\n    return extension;\r\n}\r\n\r\nexport function setExtension<K extends keyof IEngineExtensions, T extends IBaseEnginePublic>(engineState: T, type: K, extension: IEngineExtensions[K]) {\r\n    const extensions = getEngineExtensions(engineState);\r\n    // the any cast is required to avoid TS error when setting the extension\r\n    extensions[type] = extension;\r\n    // augment the engine state with these functions\r\n    // casted to any, as this is a legacy solution and is not part of the engine interface\r\n    augmentEngineState(engineState as any, extension as any);\r\n\r\n    if (!loadedExtensions[type]) {\r\n        loadExtension(type, extension, engineState.name);\r\n    }\r\n}\r\n\r\n/**\r\n * Augment an engine state with the extensions tht are already loaded\r\n * @param engineState the engine state to augment\r\n */\r\nexport function augmentEngineStateWithExtensions(engineState: IBaseEnginePublic) {\r\n    const engineType = engineState.name;\r\n    // augment the engine state with these functions\r\n    // casted to any, as this is a legacy solution and is not part of the engine interface\r\n    const extensionsTypeArray = Object.keys(loadedExtensions[engineType]) as unknown as EngineExtensions[];\r\n    for (const extension of extensionsTypeArray) {\r\n        setExtension(engineState, extension, loadedExtensions[engineType][extension]);\r\n    }\r\n}\r\n"]}

package/esm/Engines/Extensions/externalTexture/externalTexture.base.d.ts

@@ -0,0 +1,16 @@
+import type { ExternalTexture } from "../../../../Materials/Textures/externalTexture.js";
+import type { Nullable } from "../../../../types.js";
+export interface IExternalTextureEngineExtension {
+    /**
+     * Creates an external texture
+     * @param video video element
+     * @returns the external texture, or null if external textures are not supported by the engine
+     */
+    createExternalTexture(video: HTMLVideoElement): Nullable<ExternalTexture>;
+    /**
+     * Sets an internal texture to the according uniform.
+     * @param name The name of the uniform in the effect
+     * @param texture The texture to apply
+     */
+    setExternalTexture(name: string, texture: Nullable<ExternalTexture>): void;
+}

package/esm/Engines/Extensions/externalTexture/externalTexture.base.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=externalTexture.base.js.map

package/esm/Engines/Extensions/externalTexture/externalTexture.base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"externalTexture.base.js","sourceRoot":"","sources":["../../../../../../../dev/core/src/esm/Engines/Extensions/externalTexture/externalTexture.base.ts"],"names":[],"mappings":"","sourcesContent":["import type { ExternalTexture } from \"core/Materials/Textures/externalTexture\";\r\nimport type { Nullable } from \"core/types\";\r\n\r\nexport interface IExternalTextureEngineExtension {\r\n    /**\r\n     * Creates an external texture\r\n     * @param video video element\r\n     * @returns the external texture, or null if external textures are not supported by the engine\r\n     */\r\n    createExternalTexture(video: HTMLVideoElement): Nullable<ExternalTexture>;\r\n\r\n    /**\r\n     * Sets an internal texture to the according uniform.\r\n     * @param name The name of the uniform in the effect\r\n     * @param texture The texture to apply\r\n     */\r\n    setExternalTexture(name: string, texture: Nullable<ExternalTexture>): void;\r\n}\r\n"]}

package/esm/Engines/Extensions/multiRender/multiRender.base.d.ts

@@ -0,0 +1,54 @@
+import type { RenderTargetWrapper } from "../../../../Engines/renderTargetWrapper.js";
+import type { IMultiRenderTargetOptions } from "../../../../Materials/Textures/multiRenderTarget.js";
+import type { TextureSize } from "../../../../Materials/Textures/textureCreationOptions.js";
+import type { Nullable } from "../../../../types.js";
+import type { IBaseEnginePublic } from "../../engine.base";
+export interface IMultiRenderEngineExtension {
+    /**
+     * Unbind a list of render target textures from the webGL context
+     * This is used only when drawBuffer extension or webGL2 are active
+     * @param rtWrapper defines the render target wrapper to unbind
+     * @param disableGenerateMipMaps defines a boolean indicating that mipmaps must not be generated
+     * @param onBeforeUnbind defines a function which will be called before the effective unbind
+     */
+    unBindMultiColorAttachmentFramebuffer(engineState: IBaseEnginePublic, rtWrapper: RenderTargetWrapper, disableGenerateMipMaps: boolean, onBeforeUnbind?: () => void): void;
+    /**
+     * Create a multi render target texture
+     * @see https://doc.babylonjs.com/setup/support/webGL2#multiple-render-target
+     * @param size defines the size of the texture
+     * @param options defines the creation options
+     * @param initializeBuffers if set to true, the engine will make an initializing call of drawBuffers
+     * @returns a new render target wrapper ready to render textures
+     */
+    createMultipleRenderTarget(engineState: IBaseEnginePublic, size: TextureSize, options: IMultiRenderTargetOptions, initializeBuffers?: boolean): RenderTargetWrapper;
+    /**
+     * Update the sample count for a given multiple render target texture
+     * @see https://doc.babylonjs.com/setup/support/webGL2#multisample-render-targets
+     * @param rtWrapper defines the render target wrapper to update
+     * @param samples defines the sample count to set
+     * @param initializeBuffers if set to true, the engine will make an initializing call of drawBuffers
+     * @returns the effective sample count (could be 0 if multisample render targets are not supported)
+     */
+    updateMultipleRenderTargetTextureSampleCount(engineState: IBaseEnginePublic, rtWrapper: Nullable<RenderTargetWrapper>, samples: number, initializeBuffers?: boolean): number;
+    /**
+     * Select a subsets of attachments to draw to.
+     * @param attachments gl attachments
+     */
+    bindAttachments(engineState: IBaseEnginePublic, attachments: number[]): void;
+    /**
+     * Creates a layout object to draw/clear on specific textures in a MRT
+     * @param textureStatus textureStatus[i] indicates if the i-th is active
+     * @returns A layout to be fed to the engine, calling `bindAttachments`.
+     */
+    buildTextureLayout(engineState: IBaseEnginePublic, textureStatus: boolean[]): number[];
+    /**
+     * Restores the webgl state to only draw on the main color attachment
+     * when the frame buffer associated is the canvas frame buffer
+     */
+    restoreSingleAttachment(engineState: IBaseEnginePublic): void;
+    /**
+     * Restores the webgl state to only draw on the main color attachment
+     * when the frame buffer associated is not the canvas frame buffer
+     */
+    restoreSingleAttachmentForRenderTarget(engineState: IBaseEnginePublic): void;
+}

package/esm/Engines/Extensions/multiRender/multiRender.base.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=multiRender.base.js.map

package/esm/Engines/Extensions/multiRender/multiRender.base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiRender.base.js","sourceRoot":"","sources":["../../../../../../../dev/core/src/esm/Engines/Extensions/multiRender/multiRender.base.ts"],"names":[],"mappings":"","sourcesContent":["import type { RenderTargetWrapper } from \"core/Engines/renderTargetWrapper\";\r\nimport type { IMultiRenderTargetOptions } from \"core/Materials/Textures/multiRenderTarget\";\r\nimport type { TextureSize } from \"core/Materials/Textures/textureCreationOptions\";\r\nimport type { Nullable } from \"core/types\";\r\nimport type { IBaseEnginePublic } from \"../../engine.base\";\r\n\r\nexport interface IMultiRenderEngineExtension {\r\n    /**\r\n     * Unbind a list of render target textures from the webGL context\r\n     * This is used only when drawBuffer extension or webGL2 are active\r\n     * @param rtWrapper defines the render target wrapper to unbind\r\n     * @param disableGenerateMipMaps defines a boolean indicating that mipmaps must not be generated\r\n     * @param onBeforeUnbind defines a function which will be called before the effective unbind\r\n     */\r\n    unBindMultiColorAttachmentFramebuffer(engineState: IBaseEnginePublic, rtWrapper: RenderTargetWrapper, disableGenerateMipMaps: boolean, onBeforeUnbind?: () => void): void;\r\n\r\n    /**\r\n     * Create a multi render target texture\r\n     * @see https://doc.babylonjs.com/setup/support/webGL2#multiple-render-target\r\n     * @param size defines the size of the texture\r\n     * @param options defines the creation options\r\n     * @param initializeBuffers if set to true, the engine will make an initializing call of drawBuffers\r\n     * @returns a new render target wrapper ready to render textures\r\n     */\r\n    createMultipleRenderTarget(engineState: IBaseEnginePublic, size: TextureSize, options: IMultiRenderTargetOptions, initializeBuffers?: boolean): RenderTargetWrapper;\r\n\r\n    /**\r\n     * Update the sample count for a given multiple render target texture\r\n     * @see https://doc.babylonjs.com/setup/support/webGL2#multisample-render-targets\r\n     * @param rtWrapper defines the render target wrapper to update\r\n     * @param samples defines the sample count to set\r\n     * @param initializeBuffers if set to true, the engine will make an initializing call of drawBuffers\r\n     * @returns the effective sample count (could be 0 if multisample render targets are not supported)\r\n     */\r\n    updateMultipleRenderTargetTextureSampleCount(engineState: IBaseEnginePublic, rtWrapper: Nullable<RenderTargetWrapper>, samples: number, initializeBuffers?: boolean): number;\r\n\r\n    /**\r\n     * Select a subsets of attachments to draw to.\r\n     * @param attachments gl attachments\r\n     */\r\n    bindAttachments(engineState: IBaseEnginePublic, attachments: number[]): void;\r\n\r\n    /**\r\n     * Creates a layout object to draw/clear on specific textures in a MRT\r\n     * @param textureStatus textureStatus[i] indicates if the i-th is active\r\n     * @returns A layout to be fed to the engine, calling `bindAttachments`.\r\n     */\r\n    buildTextureLayout(engineState: IBaseEnginePublic, textureStatus: boolean[]): number[];\r\n\r\n    /**\r\n     * Restores the webgl state to only draw on the main color attachment\r\n     * when the frame buffer associated is the canvas frame buffer\r\n     */\r\n    restoreSingleAttachment(engineState: IBaseEnginePublic): void;\r\n\r\n    /**\r\n     * Restores the webgl state to only draw on the main color attachment\r\n     * when the frame buffer associated is not the canvas frame buffer\r\n     */\r\n    restoreSingleAttachmentForRenderTarget(engineState: IBaseEnginePublic): void;\r\n}\r\n"]}

package/esm/Engines/Extensions/multiview/multiview.base.d.ts

@@ -0,0 +1,67 @@
+import type { RenderTargetWrapper } from "../../../../Engines/renderTargetWrapper.js";
+import type { IBaseEnginePublic } from "../../engine.base";
+import { Camera } from "../../../../Cameras/camera.js";
+import type { RenderTargetTexture } from "../../../../Materials/Textures/renderTargetTexture.js";
+import { UniformBuffer } from "../../../../Materials/uniformBuffer.js";
+import { Matrix } from "../../../../Maths/math.vector.js";
+import type { Nullable } from "../../../../types.js";
+export interface IMultiviewEngineExtension {
+    /**
+     * Creates a new multiview render target
+     * @param width defines the width of the texture
+     * @param height defines the height of the texture
+     * @returns the created multiview render target wrapper
+     */
+    createMultiviewRenderTargetTexture(engineState: IBaseEnginePublic, width: number, height: number, colorTexture?: WebGLTexture, depthStencilTexture?: WebGLTexture): RenderTargetWrapper;
+    /**
+     * Binds a multiview render target wrapper to be drawn to
+     * @param multiviewTexture render target wrapper to bind
+     */
+    bindMultiviewFramebuffer(engineState: IBaseEnginePublic, multiviewTexture: RenderTargetWrapper): void;
+    /**
+     * Binds a Space Warp render target wrapper to be drawn to
+     * @param spaceWarpTexture render target wrapper to bind
+     */
+    bindSpaceWarpFramebuffer(engineState: IBaseEnginePublic, spaceWarpTexture: RenderTargetWrapper): void;
+}
+declare module "core/Cameras/camera.js" {
+    interface Camera {
+        /**
+         * @internal
+         * For cameras that cannot use multiview images to display directly. (e.g. webVR camera will render to multiview texture, then copy to each eye texture and go from there)
+         */
+        _useMultiviewToSingleView: boolean;
+        /**
+         * @internal
+         * For cameras that cannot use multiview images to display directly. (e.g. webVR camera will render to multiview texture, then copy to each eye texture and go from there)
+         */
+        _multiviewTexture: Nullable<RenderTargetTexture>;
+        /**
+         * @internal
+         * For WebXR cameras that are rendering to multiview texture arrays.
+         */
+        _renderingMultiview: boolean;
+        /**
+         * @internal
+         * ensures the multiview texture of the camera exists and has the specified width/height
+         * @param width height to set on the multiview texture
+         * @param height width to set on the multiview texture
+         */
+        _resizeOrCreateMultiviewTexture(width: number, height: number): void;
+    }
+}
+declare module "core/scene.js" {
+    interface Scene {
+        /** @internal */
+        _transformMatrixR: Matrix;
+        /** @internal */
+        _multiviewSceneUbo: Nullable<UniformBuffer>;
+        /** @internal */
+        _createMultiviewUbo(): void;
+        /** @internal */
+        _updateMultiviewUbo(viewR?: Matrix, projectionR?: Matrix): void;
+        /** @internal */
+        _renderMultiviewToSingleView(camera: Camera): void;
+    }
+}
+export declare const initMultiviewExtension: () => void;

package/esm/Engines/Extensions/multiview/multiview.base.js

@@ -0,0 +1,79 @@
+import { Camera } from "../../../../Cameras/camera.js";
+import { Scene } from "../../../../scene.js";
+import { UniformBuffer } from "../../../../Materials/uniformBuffer.js";
+import { Frustum } from "../../../../Maths/math.frustum.js";
+import { Matrix, TmpVectors } from "../../../../Maths/math.vector.js";
+import { MultiviewRenderTarget } from "../../../../Materials/Textures/MultiviewRenderTarget.js";
+export const initMultiviewExtension = () => {
+    Camera.prototype._useMultiviewToSingleView = false;
+    Camera.prototype._multiviewTexture = null;
+    Camera.prototype._resizeOrCreateMultiviewTexture = function (width, height) {
+        if (!this._multiviewTexture) {
+            this._multiviewTexture = new MultiviewRenderTarget(this.getScene(), { width: width, height: height });
+        }
+        else if (this._multiviewTexture.getRenderWidth() != width || this._multiviewTexture.getRenderHeight() != height) {
+            this._multiviewTexture.dispose();
+            this._multiviewTexture = new MultiviewRenderTarget(this.getScene(), { width: width, height: height });
+        }
+    };
+    function createMultiviewUbo(engine, name) {
+        const ubo = new UniformBuffer(engine, undefined, true, name);
+        ubo.addUniform("viewProjection", 16);
+        ubo.addUniform("viewProjectionR", 16);
+        ubo.addUniform("view", 16);
+        ubo.addUniform("projection", 16);
+        ubo.addUniform("vEyePosition", 4);
+        return ubo;
+    }
+    const currentCreateSceneUniformBuffer = Scene.prototype.createSceneUniformBuffer;
+    Scene.prototype._transformMatrixR = Matrix.Zero();
+    Scene.prototype._multiviewSceneUbo = null;
+    Scene.prototype._createMultiviewUbo = function () {
+        this._multiviewSceneUbo = createMultiviewUbo(this.getEngine(), "scene_multiview");
+    };
+    Scene.prototype.createSceneUniformBuffer = function (name) {
+        if (this._multiviewSceneUbo) {
+            return createMultiviewUbo(this.getEngine(), name);
+        }
+        return currentCreateSceneUniformBuffer.bind(this)(name);
+    };
+    Scene.prototype._updateMultiviewUbo = function (viewR, projectionR) {
+        if (viewR && projectionR) {
+            viewR.multiplyToRef(projectionR, this._transformMatrixR);
+        }
+        if (viewR && projectionR) {
+            viewR.multiplyToRef(projectionR, TmpVectors.Matrix[0]);
+            Frustum.GetRightPlaneToRef(TmpVectors.Matrix[0], this._frustumPlanes[3]); // Replace right plane by second camera right plane
+        }
+        if (this._multiviewSceneUbo) {
+            this._multiviewSceneUbo.updateMatrix("viewProjection", this.getTransformMatrix());
+            this._multiviewSceneUbo.updateMatrix("viewProjectionR", this._transformMatrixR);
+            this._multiviewSceneUbo.updateMatrix("view", this._viewMatrix);
+            this._multiviewSceneUbo.updateMatrix("projection", this._projectionMatrix);
+        }
+    };
+    Scene.prototype._renderMultiviewToSingleView = function (camera) {
+        // Multiview is only able to be displayed directly for API's such as webXR
+        // This displays a multiview image by rendering to the multiview image and then
+        // copying the result into the sub cameras instead of rendering them and proceeding as normal from there
+        // Render to a multiview texture
+        camera._resizeOrCreateMultiviewTexture(camera._rigPostProcess && camera._rigPostProcess && camera._rigPostProcess.width > 0 ? camera._rigPostProcess.width : this.getEngine().getRenderWidth(true), camera._rigPostProcess && camera._rigPostProcess && camera._rigPostProcess.height > 0 ? camera._rigPostProcess.height : this.getEngine().getRenderHeight(true));
+        if (!this._multiviewSceneUbo) {
+            this._createMultiviewUbo();
+        }
+        camera.outputRenderTarget = camera._multiviewTexture;
+        this._renderForCamera(camera);
+        camera.outputRenderTarget = null;
+        // Consume the multiview texture through a shader for each eye
+        for (let index = 0; index < camera._rigCameras.length; index++) {
+            const engine = this.getEngine();
+            this._activeCamera = camera._rigCameras[index];
+            engine.setViewport(this._activeCamera.viewport);
+            if (this.postProcessManager) {
+                this.postProcessManager._prepareFrame();
+                this.postProcessManager._finalizeFrame(this._activeCamera.isIntermediate);
+            }
+        }
+    };
+};
+//# sourceMappingURL=multiview.base.js.map

package/esm/Engines/Extensions/multiview/multiview.base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiview.base.js","sourceRoot":"","sources":["../../../../../../../dev/core/src/esm/Engines/Extensions/multiview/multiview.base.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,sCAA4B;AAC7C,OAAO,EAAE,KAAK,EAAE,6BAAmB;AAGnC,OAAO,EAAE,aAAa,EAAE,+CAAqC;AAC7D,OAAO,EAAE,OAAO,EAAE,0CAAgC;AAClD,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,yCAA+B;AAE5D,OAAO,EAAE,qBAAqB,EAAE,gEAAsD;AAyEtF,MAAM,CAAC,MAAM,sBAAsB,GAAG,GAAG,EAAE;IACvC,MAAM,CAAC,SAAS,CAAC,yBAAyB,GAAG,KAAK,CAAC;IAEnD,MAAM,CAAC,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAE1C,MAAM,CAAC,SAAS,CAAC,+BAA+B,GAAG,UAAU,KAAa,EAAE,MAAc;QACtF,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE;YACzB,IAAI,CAAC,iBAAiB,GAAG,IAAI,qBAAqB,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;SACzG;aAAM,IAAI,IAAI,CAAC,iBAAiB,CAAC,cAAc,EAAE,IAAI,KAAK,IAAI,IAAI,CAAC,iBAAiB,CAAC,eAAe,EAAE,IAAI,MAAM,EAAE;YAC/G,IAAI,CAAC,iBAAiB,CAAC,OAAO,EAAE,CAAC;YACjC,IAAI,CAAC,iBAAiB,GAAG,IAAI,qBAAqB,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;SACzG;IACL,CAAC,CAAC;IAEF,SAAS,kBAAkB,CAAC,MAAc,EAAE,IAAa;QACrD,MAAM,GAAG,GAAG,IAAI,aAAa,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;QAC7D,GAAG,CAAC,UAAU,CAAC,gBAAgB,EAAE,EAAE,CAAC,CAAC;QACrC,GAAG,CAAC,UAAU,CAAC,iBAAiB,EAAE,EAAE,CAAC,CAAC;QACtC,GAAG,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;QAC3B,GAAG,CAAC,UAAU,CAAC,YAAY,EAAE,EAAE,CAAC,CAAC;QACjC,GAAG,CAAC,UAAU,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC;QAClC,OAAO,GAAG,CAAC;IACf,CAAC;IAED,MAAM,+BAA+B,GAAG,KAAK,CAAC,SAAS,CAAC,wBAAwB,CAAC;IAEjF,KAAK,CAAC,SAAS,CAAC,iBAAiB,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC;IAClD,KAAK,CAAC,SAAS,CAAC,kBAAkB,GAAG,IAAI,CAAC;IAC1C,KAAK,CAAC,SAAS,CAAC,mBAAmB,GAAG;QAClC,IAAI,CAAC,kBAAkB,GAAG,kBAAkB,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,iBAAiB,CAAC,CAAC;IACtF,CAAC,CAAC;IACF,KAAK,CAAC,SAAS,CAAC,wBAAwB,GAAG,UAAU,IAAa;QAC9D,IAAI,IAAI,CAAC,kBAAkB,EAAE;YACzB,OAAO,kBAAkB,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,IAAI,CAAC,CAAC;SACrD;QACD,OAAO,+BAA+B,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC;IAC5D,CAAC,CAAC;IACF,KAAK,CAAC,SAAS,CAAC,mBAAmB,GAAG,UAAU,KAAc,EAAE,WAAoB;QAChF,IAAI,KAAK,IAAI,WAAW,EAAE;YACtB,KAAK,CAAC,aAAa,CAAC,WAAW,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC;SAC5D;QAED,IAAI,KAAK,IAAI,WAAW,EAAE;YACtB,KAAK,CAAC,aAAa,CAAC,WAAW,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;YACvD,OAAO,CAAC,kBAAkB,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,mDAAmD;SAChI;QAED,IAAI,IAAI,CAAC,kBAAkB,EAAE;YACzB,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,gBAAgB,EAAE,IAAI,CAAC,kBAAkB,EAAE,CAAC,CAAC;YAClF,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,iBAAiB,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC;YAChF,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;YAC/D,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,YAAY,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC;SAC9E;IACL,CAAC,CAAC;IACF,KAAK,CAAC,SAAS,CAAC,4BAA4B,GAAG,UAAU,MAAc;QACnE,0EAA0E;QAC1E,+EAA+E;QAC/E,wGAAwG;QAExG,gCAAgC;QAChC,MAAM,CAAC,+BAA+B,CAClC,MAAM,CAAC,eAAe,IAAI,MAAM,CAAC,eAAe,IAAI,MAAM,CAAC,eAAe,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,cAAc,CAAC,IAAI,CAAC,EAC3J,MAAM,CAAC,eAAe,IAAI,MAAM,CAAC,eAAe,IAAI,MAAM,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,CACjK,CAAC;QACF,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAAE;YAC1B,IAAI,CAAC,mBAAmB,EAAE,CAAC;SAC9B;QACD,MAAM,CAAC,kBAAkB,GAAG,MAAM,CAAC,iBAAiB,CAAC;QACrD,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;QAC9B,MAAM,CAAC,kBAAkB,GAAG,IAAI,CAAC;QAEjC,8DAA8D;QAC9D,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE;YAC5D,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;YAChC,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;YAC/C,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;YAChD,IAAI,IAAI,CAAC,kBAAkB,EAAE;gBACzB,IAAI,CAAC,kBAAkB,CAAC,aAAa,EAAE,CAAC;gBACxC,IAAI,CAAC,kBAAkB,CAAC,cAAc,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC;aAC7E;SACJ;IACL,CAAC,CAAC;AACN,CAAC,CAAC","sourcesContent":["import type { RenderTargetWrapper } from \"core/Engines/renderTargetWrapper\";\r\nimport type { IBaseEnginePublic } from \"../../engine.base\";\r\nimport { Camera } from \"core/Cameras/camera\";\r\nimport { Scene } from \"core/scene\";\r\nimport type { Engine } from \"core/Engines/engine\";\r\nimport type { RenderTargetTexture } from \"core/Materials/Textures/renderTargetTexture\";\r\nimport { UniformBuffer } from \"core/Materials/uniformBuffer\";\r\nimport { Frustum } from \"core/Maths/math.frustum\";\r\nimport { Matrix, TmpVectors } from \"core/Maths/math.vector\";\r\nimport type { Nullable } from \"core/types\";\r\nimport { MultiviewRenderTarget } from \"core/Materials/Textures/MultiviewRenderTarget\";\r\n\r\nexport interface IMultiviewEngineExtension {\r\n    /**\r\n     * Creates a new multiview render target\r\n     * @param width defines the width of the texture\r\n     * @param height defines the height of the texture\r\n     * @returns the created multiview render target wrapper\r\n     */\r\n    createMultiviewRenderTargetTexture(\r\n        engineState: IBaseEnginePublic,\r\n        width: number,\r\n        height: number,\r\n        colorTexture?: WebGLTexture,\r\n        depthStencilTexture?: WebGLTexture\r\n    ): RenderTargetWrapper;\r\n\r\n    /**\r\n     * Binds a multiview render target wrapper to be drawn to\r\n     * @param multiviewTexture render target wrapper to bind\r\n     */\r\n    bindMultiviewFramebuffer(engineState: IBaseEnginePublic, multiviewTexture: RenderTargetWrapper): void;\r\n\r\n    /**\r\n     * Binds a Space Warp render target wrapper to be drawn to\r\n     * @param spaceWarpTexture render target wrapper to bind\r\n     */\r\n    bindSpaceWarpFramebuffer(engineState: IBaseEnginePublic, spaceWarpTexture: RenderTargetWrapper): void;\r\n}\r\ndeclare module \"core/Cameras/camera.js\" {\r\n    export interface Camera {\r\n        /**\r\n         * @internal\r\n         * For cameras that cannot use multiview images to display directly. (e.g. webVR camera will render to multiview texture, then copy to each eye texture and go from there)\r\n         */\r\n        _useMultiviewToSingleView: boolean;\r\n        /**\r\n         * @internal\r\n         * For cameras that cannot use multiview images to display directly. (e.g. webVR camera will render to multiview texture, then copy to each eye texture and go from there)\r\n         */\r\n        _multiviewTexture: Nullable<RenderTargetTexture>;\r\n\r\n        /**\r\n         * @internal\r\n         * For WebXR cameras that are rendering to multiview texture arrays.\r\n         */\r\n        _renderingMultiview: boolean;\r\n\r\n        /**\r\n         * @internal\r\n         * ensures the multiview texture of the camera exists and has the specified width/height\r\n         * @param width height to set on the multiview texture\r\n         * @param height width to set on the multiview texture\r\n         */\r\n        _resizeOrCreateMultiviewTexture(width: number, height: number): void;\r\n    }\r\n}\r\n\r\ndeclare module \"core/scene.js\" {\r\n    export interface Scene {\r\n        /** @internal */\r\n        _transformMatrixR: Matrix;\r\n        /** @internal */\r\n        _multiviewSceneUbo: Nullable<UniformBuffer>;\r\n        /** @internal */\r\n        _createMultiviewUbo(): void;\r\n        /** @internal */\r\n        _updateMultiviewUbo(viewR?: Matrix, projectionR?: Matrix): void;\r\n        /** @internal */\r\n        _renderMultiviewToSingleView(camera: Camera): void;\r\n    }\r\n}\r\n\r\nexport const initMultiviewExtension = () => {\r\n    Camera.prototype._useMultiviewToSingleView = false;\r\n\r\n    Camera.prototype._multiviewTexture = null;\r\n\r\n    Camera.prototype._resizeOrCreateMultiviewTexture = function (width: number, height: number) {\r\n        if (!this._multiviewTexture) {\r\n            this._multiviewTexture = new MultiviewRenderTarget(this.getScene(), { width: width, height: height });\r\n        } else if (this._multiviewTexture.getRenderWidth() != width || this._multiviewTexture.getRenderHeight() != height) {\r\n            this._multiviewTexture.dispose();\r\n            this._multiviewTexture = new MultiviewRenderTarget(this.getScene(), { width: width, height: height });\r\n        }\r\n    };\r\n\r\n    function createMultiviewUbo(engine: Engine, name?: string) {\r\n        const ubo = new UniformBuffer(engine, undefined, true, name);\r\n        ubo.addUniform(\"viewProjection\", 16);\r\n        ubo.addUniform(\"viewProjectionR\", 16);\r\n        ubo.addUniform(\"view\", 16);\r\n        ubo.addUniform(\"projection\", 16);\r\n        ubo.addUniform(\"vEyePosition\", 4);\r\n        return ubo;\r\n    }\r\n\r\n    const currentCreateSceneUniformBuffer = Scene.prototype.createSceneUniformBuffer;\r\n\r\n    Scene.prototype._transformMatrixR = Matrix.Zero();\r\n    Scene.prototype._multiviewSceneUbo = null;\r\n    Scene.prototype._createMultiviewUbo = function () {\r\n        this._multiviewSceneUbo = createMultiviewUbo(this.getEngine(), \"scene_multiview\");\r\n    };\r\n    Scene.prototype.createSceneUniformBuffer = function (name?: string): UniformBuffer {\r\n        if (this._multiviewSceneUbo) {\r\n            return createMultiviewUbo(this.getEngine(), name);\r\n        }\r\n        return currentCreateSceneUniformBuffer.bind(this)(name);\r\n    };\r\n    Scene.prototype._updateMultiviewUbo = function (viewR?: Matrix, projectionR?: Matrix) {\r\n        if (viewR && projectionR) {\r\n            viewR.multiplyToRef(projectionR, this._transformMatrixR);\r\n        }\r\n\r\n        if (viewR && projectionR) {\r\n            viewR.multiplyToRef(projectionR, TmpVectors.Matrix[0]);\r\n            Frustum.GetRightPlaneToRef(TmpVectors.Matrix[0], this._frustumPlanes[3]); // Replace right plane by second camera right plane\r\n        }\r\n\r\n        if (this._multiviewSceneUbo) {\r\n            this._multiviewSceneUbo.updateMatrix(\"viewProjection\", this.getTransformMatrix());\r\n            this._multiviewSceneUbo.updateMatrix(\"viewProjectionR\", this._transformMatrixR);\r\n            this._multiviewSceneUbo.updateMatrix(\"view\", this._viewMatrix);\r\n            this._multiviewSceneUbo.updateMatrix(\"projection\", this._projectionMatrix);\r\n        }\r\n    };\r\n    Scene.prototype._renderMultiviewToSingleView = function (camera: Camera) {\r\n        // Multiview is only able to be displayed directly for API's such as webXR\r\n        // This displays a multiview image by rendering to the multiview image and then\r\n        // copying the result into the sub cameras instead of rendering them and proceeding as normal from there\r\n\r\n        // Render to a multiview texture\r\n        camera._resizeOrCreateMultiviewTexture(\r\n            camera._rigPostProcess && camera._rigPostProcess && camera._rigPostProcess.width > 0 ? camera._rigPostProcess.width : this.getEngine().getRenderWidth(true),\r\n            camera._rigPostProcess && camera._rigPostProcess && camera._rigPostProcess.height > 0 ? camera._rigPostProcess.height : this.getEngine().getRenderHeight(true)\r\n        );\r\n        if (!this._multiviewSceneUbo) {\r\n            this._createMultiviewUbo();\r\n        }\r\n        camera.outputRenderTarget = camera._multiviewTexture;\r\n        this._renderForCamera(camera);\r\n        camera.outputRenderTarget = null;\r\n\r\n        // Consume the multiview texture through a shader for each eye\r\n        for (let index = 0; index < camera._rigCameras.length; index++) {\r\n            const engine = this.getEngine();\r\n            this._activeCamera = camera._rigCameras[index];\r\n            engine.setViewport(this._activeCamera.viewport);\r\n            if (this.postProcessManager) {\r\n                this.postProcessManager._prepareFrame();\r\n                this.postProcessManager._finalizeFrame(this._activeCamera.isIntermediate);\r\n            }\r\n        }\r\n    };\r\n};\r\n"]}