@babylonjs/core 7.8.0 → 7.8.1

package/Engines/thinEngine.d.ts

@@ -17,9 +17,7 @@ import type { ICanvas, ICanvasRenderingContext } from "./ICanvas";
 import type { IStencilState } from "../States/IStencilState";
 import type { InternalTextureCreationOptions, TextureSize } from "../Materials/Textures/textureCreationOptions";
 import type { RenderTargetWrapper } from "./renderTargetWrapper";
-import type { RenderTargetTexture } from "../Materials/Textures/renderTargetTexture";
 import type { AbstractEngineOptions, ISceneLike } from "./abstractEngine";
-import type { PostProcess } from "../PostProcesses/postProcess";
 import type { PerformanceMonitor } from "../Misc/performanceMonitor";
 import { AbstractEngine } from "./abstractEngine";
 import { ShaderLanguage } from "../Materials/shaderLanguage";
@@ -806,9 +804,6 @@ export declare class ThinEngine extends AbstractEngine {
      * @param bruteForce defines a boolean to force clearing ALL caches (including stencil, detoh and alpha states)
      */
     wipeCaches(bruteForce?: boolean): void;
-    setTextureFromPostProcess(channel: number, postProcess: Nullable<PostProcess>, name: string): void;
-    setTextureFromPostProcessOutput(channel: number, postProcess: Nullable<PostProcess>, name: string): void;
-    setDepthStencilTexture(channel: number, uniform: Nullable<WebGLUniformLocation>, texture: Nullable<RenderTargetTexture>, name?: string): void;
     /**
      * @internal
      */
@@ -886,7 +881,8 @@ export declare class ThinEngine extends AbstractEngine {
     _unpackFlipY(value: boolean): void;
     /** @internal */
     _getUnpackAlignement(): number;
-    private _getTextureTarget;
+    /** @internal */
+    _getTextureTarget(texture: InternalTexture): number;
     /**
      * Update the sampling mode of a given texture
      * @param samplingMode defines the required sampling mode
@@ -910,10 +906,6 @@ export declare class ThinEngine extends AbstractEngine {
      * @param wrapR defines the texture wrap mode of the r coordinates
      */
     updateTextureWrappingMode(texture: InternalTexture, wrapU: Nullable<number>, wrapV?: Nullable<number>, wrapR?: Nullable<number>): void;
-    /**
-     * @internal
-     */
-    _setupDepthStencilTexture(internalTexture: InternalTexture, size: TextureSize, generateStencil: boolean, bilinearFiltering: boolean, comparisonFunction: number, samples?: number): void;
     /**
      * @internal
      */
@@ -956,7 +948,10 @@ export declare class ThinEngine extends AbstractEngine {
     _releaseTexture(texture: InternalTexture): void;
     protected _deleteTexture(texture: Nullable<WebGLTexture>): void;
     protected _setProgram(program: WebGLProgram): void;
-    protected _boundUniforms: {
+    /**
+     * @internal
+     */
+    _boundUniforms: {
         [key: number]: WebGLUniformLocation;
     };
     /**
@@ -987,7 +982,7 @@ export declare class ThinEngine extends AbstractEngine {
     setTexture(channel: number, uniform: Nullable<WebGLUniformLocation>, texture: Nullable<ThinTexture>, name: string): void;
     private _bindSamplerUniformToChannel;
     private _getTextureWrapMode;
-    protected _setTexture(channel: number, texture: Nullable<ThinTexture>, isPartOfTextureArray?: boolean, depthStencilTexture?: boolean, name?: string): boolean;
+    _setTexture(channel: number, texture: Nullable<ThinTexture>, isPartOfTextureArray?: boolean, depthStencilTexture?: boolean, name?: string): boolean;
     /**
      * Sets an array of texture to the webGL context
      * @param channel defines the channel where the texture array must be set
@@ -1056,12 +1051,6 @@ export declare class ThinEngine extends AbstractEngine {
      * @returns a ArrayBufferView promise (Uint8Array) containing RGBA colors
      */
     readPixels(x: number, y: number, width: number, height: number, hasAlpha?: boolean, flushRenderer?: boolean): Promise<ArrayBufferView>;
-    /**
-     * Force the mipmap generation for the given render target texture
-     * @param texture defines the render target texture to use
-     * @param unbind defines whether or not to unbind the texture after generation. Defaults to true.
-     */
-    generateMipMapsForCubemap(texture: InternalTexture, unbind: boolean): void;
     private static _IsSupported;
     private static _HasMajorPerformanceCaveat;
     /**

package/Engines/thinEngine.js

@@ -12,7 +12,6 @@ import { WebGLHardwareTexture } from "./WebGL/webGLHardwareTexture.js";
 import { ShaderLanguage } from "../Materials/shaderLanguage.js";
 import { InternalTexture, InternalTextureSource } from "../Materials/Textures/internalTexture.js";
 import { Effect } from "../Materials/effect.js";
-import { _WarnImport } from "../Misc/devTools.js";
 import { _ConcatenateShader, _getGlobalDefines } from "./abstractEngine.functions.js";
 import { resetCachedPipeline } from "../Materials/effect.functions.js";
 /**
@@ -125,6 +124,9 @@ export class ThinEngine extends AbstractEngine {
          * value would be set.
          */
         this.enableUnpackFlipYCached = true;
+        /**
+         * @internal
+         */
         this._boundUniforms = {};
         if (!canvasOrContext) {
             return;
@@ -2145,15 +2147,6 @@ export class ThinEngine extends AbstractEngine {
         this._cachedEffectForVertexBuffers = null;
         this.bindIndexBuffer(null);
     }
-    setTextureFromPostProcess(channel, postProcess, name) {
-        // Does nothing
-    }
-    setTextureFromPostProcessOutput(channel, postProcess, name) {
-        // Does nothing
-    }
-    setDepthStencilTexture(channel, uniform, texture, name) {
-        // Does nothing
-    }
     /**
      * @internal
      */
@@ -2463,94 +2456,6 @@ export class ThinEngine extends AbstractEngine {
      * @internal
      */
     _rescaleTexture(source, destination, scene, internalFormat, onComplete) { }
-    // eslint-disable-next-line jsdoc/require-returns-check
-    /**
-     * Creates a raw texture
-     * @param data defines the data to store in the texture
-     * @param width defines the width of the texture
-     * @param height defines the height of the texture
-     * @param format defines the format of the data
-     * @param generateMipMaps defines if the engine should generate the mip levels
-     * @param invertY defines if data must be stored with Y axis inverted
-     * @param samplingMode defines the required sampling mode (Texture.NEAREST_SAMPLINGMODE by default)
-     * @param compression defines the compression used (null by default)
-     * @param type defines the type fo the data (Engine.TEXTURETYPE_UNSIGNED_INT by default)
-     * @param creationFlags specific flags to use when creating the texture (1 for storage textures, for eg)
-     * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).
-     * @returns the raw texture inside an InternalTexture
-     */
-    createRawTexture(data, width, height, format, generateMipMaps, invertY, samplingMode, compression = null, type = 0, creationFlags = 0, useSRGBBuffer = false) {
-        throw _WarnImport("Engine.RawTexture");
-    }
-    // eslint-disable-next-line jsdoc/require-returns-check
-    /**
-     * Creates a new raw cube texture
-     * @param data defines the array of data to use to create each face
-     * @param size defines the size of the textures
-     * @param format defines the format of the data
-     * @param type defines the type of the data (like Engine.TEXTURETYPE_UNSIGNED_INT)
-     * @param generateMipMaps  defines if the engine should generate the mip levels
-     * @param invertY defines if data must be stored with Y axis inverted
-     * @param samplingMode defines the required sampling mode (like Texture.NEAREST_SAMPLINGMODE)
-     * @param compression defines the compression used (null by default)
-     * @returns the cube texture as an InternalTexture
-     */
-    createRawCubeTexture(data, size, format, type, generateMipMaps, invertY, samplingMode, compression = null) {
-        throw _WarnImport("Engine.RawTexture");
-    }
-    // eslint-disable-next-line jsdoc/require-returns-check
-    /**
-     * Creates a new raw 3D texture
-     * @param data defines the data used to create the texture
-     * @param width defines the width of the texture
-     * @param height defines the height of the texture
-     * @param depth defines the depth of the texture
-     * @param format defines the format of the texture
-     * @param generateMipMaps defines if the engine must generate mip levels
-     * @param invertY defines if data must be stored with Y axis inverted
-     * @param samplingMode defines the required sampling mode (like Texture.NEAREST_SAMPLINGMODE)
-     * @param compression defines the compressed used (can be null)
-     * @param textureType defines the compressed used (can be null)
-     * @returns a new raw 3D texture (stored in an InternalTexture)
-     */
-    createRawTexture3D(data, width, height, depth, format, generateMipMaps, invertY, samplingMode, compression = null, textureType = 0) {
-        throw _WarnImport("Engine.RawTexture");
-    }
-    // eslint-disable-next-line jsdoc/require-returns-check
-    /**
-     * Creates a new raw 2D array texture
-     * @param data defines the data used to create the texture
-     * @param width defines the width of the texture
-     * @param height defines the height of the texture
-     * @param depth defines the number of layers of the texture
-     * @param format defines the format of the texture
-     * @param generateMipMaps defines if the engine must generate mip levels
-     * @param invertY defines if data must be stored with Y axis inverted
-     * @param samplingMode defines the required sampling mode (like Texture.NEAREST_SAMPLINGMODE)
-     * @param compression defines the compressed used (can be null)
-     * @param textureType defines the compressed used (can be null)
-     * @returns a new raw 2D array texture (stored in an InternalTexture)
-     */
-    createRawTexture2DArray(data, width, height, depth, format, generateMipMaps, invertY, samplingMode, compression = null, textureType = 0) {
-        throw _WarnImport("Engine.RawTexture");
-    }
-    // eslint-disable-next-line jsdoc/require-returns-check
-    /**
-     * Create a cube texture from prefiltered data (ie. the mipmaps contain ready to use data for PBR reflection)
-     * @param rootUrl defines the url where the file to load is located
-     * @param scene defines the current scene
-     * @param lodScale defines scale to apply to the mip map selection
-     * @param lodOffset defines offset to apply to the mip map selection
-     * @param onLoad defines an optional callback raised when the texture is loaded
-     * @param onError defines an optional callback raised if there is an issue to load the texture
-     * @param format defines the format of the data
-     * @param forcedExtension defines the extension to use to pick the right loader
-     * @param createPolynomials defines wheter or not to create polynomails harmonics for the texture
-     * @returns the cube texture as an InternalTexture
-     */
-    createPrefilteredCubeTexture(rootUrl, scene, lodScale, lodOffset, onLoad, onError, format, forcedExtension, createPolynomials) {
-        throw _WarnImport("Misc/dds");
-    }
     /**
      * @internal
      */
@@ -2566,6 +2471,7 @@ export class ThinEngine extends AbstractEngine {
     _getUnpackAlignement() {
         return this._gl.getParameter(this._gl.UNPACK_ALIGNMENT);
     }
+    /** @internal */
     _getTextureTarget(texture) {
         if (texture.isCube) {
             return this._gl.TEXTURE_CUBE_MAP;
@@ -2627,45 +2533,6 @@ export class ThinEngine extends AbstractEngine {
         }
         this._bindTextureDirectly(target, null);
     }
-    /**
-     * @internal
-     */
-    _setupDepthStencilTexture(internalTexture, size, generateStencil, bilinearFiltering, comparisonFunction, samples = 1) {
-        const width = size.width || size;
-        const height = size.height || size;
-        const layers = size.layers || 0;
-        const depth = size.depth || 0;
-        internalTexture.baseWidth = width;
-        internalTexture.baseHeight = height;
-        internalTexture.width = width;
-        internalTexture.height = height;
-        internalTexture.is2DArray = layers > 0;
-        internalTexture.depth = layers || depth;
-        internalTexture.isReady = true;
-        internalTexture.samples = samples;
-        internalTexture.generateMipMaps = false;
-        internalTexture.samplingMode = bilinearFiltering ? 2 : 1;
-        internalTexture.type = 0;
-        internalTexture._comparisonFunction = comparisonFunction;
-        const gl = this._gl;
-        const target = this._getTextureTarget(internalTexture);
-        const samplingParameters = this._getSamplingParameters(internalTexture.samplingMode, false);
-        gl.texParameteri(target, gl.TEXTURE_MAG_FILTER, samplingParameters.mag);
-        gl.texParameteri(target, gl.TEXTURE_MIN_FILTER, samplingParameters.min);
-        gl.texParameteri(target, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-        gl.texParameteri(target, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-        // TEXTURE_COMPARE_FUNC/MODE are only availble in WebGL2.
-        if (this.webGLVersion > 1) {
-            if (comparisonFunction === 0) {
-                gl.texParameteri(target, gl.TEXTURE_COMPARE_FUNC, 515);
-                gl.texParameteri(target, gl.TEXTURE_COMPARE_MODE, gl.NONE);
-            }
-            else {
-                gl.texParameteri(target, gl.TEXTURE_COMPARE_FUNC, comparisonFunction);
-                gl.texParameteri(target, gl.TEXTURE_COMPARE_MODE, gl.COMPARE_REF_TO_TEXTURE);
-            }
-        }
-    }
     /**
      * @internal
      */
@@ -3619,15 +3486,6 @@ export class ThinEngine extends AbstractEngine {
         this._gl.readPixels(x, y, width, height, format, this._gl.UNSIGNED_BYTE, data);
         return Promise.resolve(data);
     }
-    /**
-     * Force the mipmap generation for the given render target texture
-     * @param texture defines the render target texture to use
-     * @param unbind defines whether or not to unbind the texture after generation. Defaults to true.
-     */
-    generateMipMapsForCubemap(texture, unbind) {
-        // Does nothing
-        // Child classes should implement this function
-    }
     /**
      * Gets a Promise<boolean> indicating if the engine can be instantiated (ie. if a webGL context can be found)
      */