@babylonjs/viewer 7.41.1-alpha → 7.42.0

package/dist/chunks/rawTexture-CWiRIto8.esm.js

@@ -1,191 +0,0 @@
-import { t as Texture, C as Constants } from './index-C6hXZyZb.esm.js';
-
-/**
- * Raw texture can help creating a texture directly from an array of data.
- * This can be super useful if you either get the data from an uncompressed source or
- * if you wish to create your texture pixel by pixel.
- */
-class RawTexture extends Texture {
-    /**
-     * Instantiates a new RawTexture.
-     * Raw texture can help creating a texture directly from an array of data.
-     * This can be super useful if you either get the data from an uncompressed source or
-     * if you wish to create your texture pixel by pixel.
-     * @param data define the array of data to use to create the texture (null to create an empty texture)
-     * @param width define the width of the texture
-     * @param height define the height of the texture
-     * @param format define the format of the data (RGB, RGBA... Engine.TEXTUREFORMAT_xxx)
-     * @param sceneOrEngine defines the scene or engine the texture will belong to
-     * @param generateMipMaps define whether mip maps should be generated or not
-     * @param invertY define if the data should be flipped on Y when uploaded to the GPU
-     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
-     * @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)
-     * @param creationFlags specific flags to use when creating the texture (Constants.TEXTURE_CREATIONFLAG_STORAGE for storage textures, for eg)
-     * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).
-     */
-    constructor(data, width, height, 
-    /**
-     * Define the format of the data (RGB, RGBA... Engine.TEXTUREFORMAT_xxx)
-     */
-    format, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE, type = Constants.TEXTURETYPE_UNSIGNED_BYTE, creationFlags, useSRGBBuffer) {
-        super(null, sceneOrEngine, !generateMipMaps, invertY, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, creationFlags);
-        this.format = format;
-        if (!this._engine) {
-            return;
-        }
-        if (!this._engine._caps.textureFloatLinearFiltering && type === Constants.TEXTURETYPE_FLOAT) {
-            samplingMode = Constants.TEXTURE_NEAREST_SAMPLINGMODE;
-        }
-        if (!this._engine._caps.textureHalfFloatLinearFiltering && type === Constants.TEXTURETYPE_HALF_FLOAT) {
-            samplingMode = Constants.TEXTURE_NEAREST_SAMPLINGMODE;
-        }
-        this._texture = this._engine.createRawTexture(data, width, height, format, generateMipMaps, invertY, samplingMode, null, type, creationFlags ?? 0, useSRGBBuffer ?? false);
-        this.wrapU = Texture.CLAMP_ADDRESSMODE;
-        this.wrapV = Texture.CLAMP_ADDRESSMODE;
-    }
-    /**
-     * Updates the texture underlying data.
-     * @param data Define the new data of the texture
-     */
-    update(data) {
-        this._getEngine().updateRawTexture(this._texture, data, this._texture.format, this._texture.invertY, null, this._texture.type, this._texture._useSRGBBuffer);
-    }
-    /**
-     * Clones the texture.
-     * @returns the cloned texture
-     */
-    clone() {
-        if (!this._texture) {
-            return super.clone();
-        }
-        const rawTexture = new RawTexture(null, this.getSize().width, this.getSize().height, this.format, this.getScene(), this._texture.generateMipMaps, this._invertY, this.samplingMode, this._texture.type, this._texture._creationFlags, this._useSRGBBuffer);
-        rawTexture._texture = this._texture;
-        this._texture.incrementReferences();
-        return rawTexture;
-    }
-    /**
-     * Creates a luminance texture from some data.
-     * @param data Define the texture data
-     * @param width Define the width of the texture
-     * @param height Define the height of the texture
-     * @param sceneOrEngine defines the scene or engine the texture will belong to
-     * @param generateMipMaps Define whether or not to create mip maps for the texture
-     * @param invertY define if the data should be flipped on Y when uploaded to the GPU
-     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
-     * @returns the luminance texture
-     */
-    static CreateLuminanceTexture(data, width, height, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE) {
-        return new RawTexture(data, width, height, Constants.TEXTUREFORMAT_LUMINANCE, sceneOrEngine, generateMipMaps, invertY, samplingMode);
-    }
-    /**
-     * Creates a luminance alpha texture from some data.
-     * @param data Define the texture data
-     * @param width Define the width of the texture
-     * @param height Define the height of the texture
-     * @param sceneOrEngine defines the scene or engine the texture will belong to
-     * @param generateMipMaps Define whether or not to create mip maps for the texture
-     * @param invertY define if the data should be flipped on Y when uploaded to the GPU
-     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
-     * @returns the luminance alpha texture
-     */
-    static CreateLuminanceAlphaTexture(data, width, height, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE) {
-        return new RawTexture(data, width, height, Constants.TEXTUREFORMAT_LUMINANCE_ALPHA, sceneOrEngine, generateMipMaps, invertY, samplingMode);
-    }
-    /**
-     * Creates an alpha texture from some data.
-     * @param data Define the texture data
-     * @param width Define the width of the texture
-     * @param height Define the height of the texture
-     * @param sceneOrEngine defines the scene or engine the texture will belong to
-     * @param generateMipMaps Define whether or not to create mip maps for the texture
-     * @param invertY define if the data should be flipped on Y when uploaded to the GPU
-     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
-     * @returns the alpha texture
-     */
-    static CreateAlphaTexture(data, width, height, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE) {
-        return new RawTexture(data, width, height, Constants.TEXTUREFORMAT_ALPHA, sceneOrEngine, generateMipMaps, invertY, samplingMode);
-    }
-    /**
-     * Creates a RGB texture from some data.
-     * @param data Define the texture data
-     * @param width Define the width of the texture
-     * @param height Define the height of the texture
-     * @param sceneOrEngine defines the scene or engine the texture will belong to
-     * @param generateMipMaps Define whether or not to create mip maps for the texture
-     * @param invertY define if the data should be flipped on Y when uploaded to the GPU
-     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
-     * @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)
-     * @param creationFlags specific flags to use when creating the texture (Constants.TEXTURE_CREATIONFLAG_STORAGE 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 RGB alpha texture
-     */
-    static CreateRGBTexture(data, width, height, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE, type = Constants.TEXTURETYPE_UNSIGNED_BYTE, creationFlags = 0, useSRGBBuffer = false) {
-        return new RawTexture(data, width, height, Constants.TEXTUREFORMAT_RGB, sceneOrEngine, generateMipMaps, invertY, samplingMode, type, creationFlags, useSRGBBuffer);
-    }
-    /**
-     * Creates a RGBA texture from some data.
-     * @param data Define the texture data
-     * @param width Define the width of the texture
-     * @param height Define the height of the texture
-     * @param sceneOrEngine defines the scene or engine the texture will belong to
-     * @param generateMipMaps Define whether or not to create mip maps for the texture
-     * @param invertY define if the data should be flipped on Y when uploaded to the GPU
-     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
-     * @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)
-     * @param creationFlags specific flags to use when creating the texture (Constants.TEXTURE_CREATIONFLAG_STORAGE 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 RGBA texture
-     */
-    static CreateRGBATexture(data, width, height, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE, type = Constants.TEXTURETYPE_UNSIGNED_BYTE, creationFlags = 0, useSRGBBuffer = false) {
-        return new RawTexture(data, width, height, Constants.TEXTUREFORMAT_RGBA, sceneOrEngine, generateMipMaps, invertY, samplingMode, type, creationFlags, useSRGBBuffer);
-    }
-    /**
-     * Creates a RGBA storage texture from some data.
-     * @param data Define the texture data
-     * @param width Define the width of the texture
-     * @param height Define the height of the texture
-     * @param sceneOrEngine defines the scene or engine the texture will belong to
-     * @param generateMipMaps Define whether or not to create mip maps for the texture
-     * @param invertY define if the data should be flipped on Y when uploaded to the GPU
-     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
-     * @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)
-     * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).
-     * @returns the RGBA texture
-     */
-    static CreateRGBAStorageTexture(data, width, height, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE, type = Constants.TEXTURETYPE_UNSIGNED_BYTE, useSRGBBuffer = false) {
-        return new RawTexture(data, width, height, Constants.TEXTUREFORMAT_RGBA, sceneOrEngine, generateMipMaps, invertY, samplingMode, type, Constants.TEXTURE_CREATIONFLAG_STORAGE, useSRGBBuffer);
-    }
-    /**
-     * Creates a R texture from some data.
-     * @param data Define the texture data
-     * @param width Define the width of the texture
-     * @param height Define the height of the texture
-     * @param sceneOrEngine defines the scene or engine the texture will belong to
-     * @param generateMipMaps Define whether or not to create mip maps for the texture
-     * @param invertY define if the data should be flipped on Y when uploaded to the GPU
-     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
-     * @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)
-     * @returns the R texture
-     */
-    static CreateRTexture(data, width, height, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Texture.TRILINEAR_SAMPLINGMODE, type = Constants.TEXTURETYPE_FLOAT) {
-        return new RawTexture(data, width, height, Constants.TEXTUREFORMAT_R, sceneOrEngine, generateMipMaps, invertY, samplingMode, type);
-    }
-    /**
-     * Creates a R storage texture from some data.
-     * @param data Define the texture data
-     * @param width Define the width of the texture
-     * @param height Define the height of the texture
-     * @param sceneOrEngine defines the scene or engine the texture will belong to
-     * @param generateMipMaps Define whether or not to create mip maps for the texture
-     * @param invertY define if the data should be flipped on Y when uploaded to the GPU
-     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)
-     * @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)
-     * @returns the R texture
-     */
-    static CreateRStorageTexture(data, width, height, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Texture.TRILINEAR_SAMPLINGMODE, type = Constants.TEXTURETYPE_FLOAT) {
-        return new RawTexture(data, width, height, Constants.TEXTUREFORMAT_R, sceneOrEngine, generateMipMaps, invertY, samplingMode, type, Constants.TEXTURE_CREATIONFLAG_STORAGE);
-    }
-}
-
-export { RawTexture as R };
-//# sourceMappingURL=rawTexture-CWiRIto8.esm.js.map

package/dist/chunks/rawTexture-CWiRIto8.esm.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"rawTexture-CWiRIto8.esm.js","sources":["../../../../../dev/core/dist/Materials/Textures/rawTexture.js"],"sourcesContent":["import { Texture } from \"./texture\";\nimport { Constants } from \"../../Engines/constants\";\n/**\n * Raw texture can help creating a texture directly from an array of data.\n * This can be super useful if you either get the data from an uncompressed source or\n * if you wish to create your texture pixel by pixel.\n */\nexport class RawTexture extends Texture {\n    /**\n     * Instantiates a new RawTexture.\n     * Raw texture can help creating a texture directly from an array of data.\n     * This can be super useful if you either get the data from an uncompressed source or\n     * if you wish to create your texture pixel by pixel.\n     * @param data define the array of data to use to create the texture (null to create an empty texture)\n     * @param width define the width of the texture\n     * @param height define the height of the texture\n     * @param format define the format of the data (RGB, RGBA... Engine.TEXTUREFORMAT_xxx)\n     * @param sceneOrEngine defines the scene or engine the texture will belong to\n     * @param generateMipMaps define whether mip maps should be generated or not\n     * @param invertY define if the data should be flipped on Y when uploaded to the GPU\n     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)\n     * @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)\n     * @param creationFlags specific flags to use when creating the texture (Constants.TEXTURE_CREATIONFLAG_STORAGE for storage textures, for eg)\n     * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).\n     */\n    constructor(data, width, height, \n    /**\n     * Define the format of the data (RGB, RGBA... Engine.TEXTUREFORMAT_xxx)\n     */\n    format, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE, type = Constants.TEXTURETYPE_UNSIGNED_BYTE, creationFlags, useSRGBBuffer) {\n        super(null, sceneOrEngine, !generateMipMaps, invertY, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, creationFlags);\n        this.format = format;\n        if (!this._engine) {\n            return;\n        }\n        if (!this._engine._caps.textureFloatLinearFiltering && type === Constants.TEXTURETYPE_FLOAT) {\n            samplingMode = Constants.TEXTURE_NEAREST_SAMPLINGMODE;\n        }\n        if (!this._engine._caps.textureHalfFloatLinearFiltering && type === Constants.TEXTURETYPE_HALF_FLOAT) {\n            samplingMode = Constants.TEXTURE_NEAREST_SAMPLINGMODE;\n        }\n        this._texture = this._engine.createRawTexture(data, width, height, format, generateMipMaps, invertY, samplingMode, null, type, creationFlags ?? 0, useSRGBBuffer ?? false);\n        this.wrapU = Texture.CLAMP_ADDRESSMODE;\n        this.wrapV = Texture.CLAMP_ADDRESSMODE;\n    }\n    /**\n     * Updates the texture underlying data.\n     * @param data Define the new data of the texture\n     */\n    update(data) {\n        this._getEngine().updateRawTexture(this._texture, data, this._texture.format, this._texture.invertY, null, this._texture.type, this._texture._useSRGBBuffer);\n    }\n    /**\n     * Clones the texture.\n     * @returns the cloned texture\n     */\n    clone() {\n        if (!this._texture) {\n            return super.clone();\n        }\n        const rawTexture = new RawTexture(null, this.getSize().width, this.getSize().height, this.format, this.getScene(), this._texture.generateMipMaps, this._invertY, this.samplingMode, this._texture.type, this._texture._creationFlags, this._useSRGBBuffer);\n        rawTexture._texture = this._texture;\n        this._texture.incrementReferences();\n        return rawTexture;\n    }\n    /**\n     * Creates a luminance texture from some data.\n     * @param data Define the texture data\n     * @param width Define the width of the texture\n     * @param height Define the height of the texture\n     * @param sceneOrEngine defines the scene or engine the texture will belong to\n     * @param generateMipMaps Define whether or not to create mip maps for the texture\n     * @param invertY define if the data should be flipped on Y when uploaded to the GPU\n     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)\n     * @returns the luminance texture\n     */\n    static CreateLuminanceTexture(data, width, height, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE) {\n        return new RawTexture(data, width, height, Constants.TEXTUREFORMAT_LUMINANCE, sceneOrEngine, generateMipMaps, invertY, samplingMode);\n    }\n    /**\n     * Creates a luminance alpha texture from some data.\n     * @param data Define the texture data\n     * @param width Define the width of the texture\n     * @param height Define the height of the texture\n     * @param sceneOrEngine defines the scene or engine the texture will belong to\n     * @param generateMipMaps Define whether or not to create mip maps for the texture\n     * @param invertY define if the data should be flipped on Y when uploaded to the GPU\n     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)\n     * @returns the luminance alpha texture\n     */\n    static CreateLuminanceAlphaTexture(data, width, height, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE) {\n        return new RawTexture(data, width, height, Constants.TEXTUREFORMAT_LUMINANCE_ALPHA, sceneOrEngine, generateMipMaps, invertY, samplingMode);\n    }\n    /**\n     * Creates an alpha texture from some data.\n     * @param data Define the texture data\n     * @param width Define the width of the texture\n     * @param height Define the height of the texture\n     * @param sceneOrEngine defines the scene or engine the texture will belong to\n     * @param generateMipMaps Define whether or not to create mip maps for the texture\n     * @param invertY define if the data should be flipped on Y when uploaded to the GPU\n     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)\n     * @returns the alpha texture\n     */\n    static CreateAlphaTexture(data, width, height, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE) {\n        return new RawTexture(data, width, height, Constants.TEXTUREFORMAT_ALPHA, sceneOrEngine, generateMipMaps, invertY, samplingMode);\n    }\n    /**\n     * Creates a RGB texture from some data.\n     * @param data Define the texture data\n     * @param width Define the width of the texture\n     * @param height Define the height of the texture\n     * @param sceneOrEngine defines the scene or engine the texture will belong to\n     * @param generateMipMaps Define whether or not to create mip maps for the texture\n     * @param invertY define if the data should be flipped on Y when uploaded to the GPU\n     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)\n     * @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)\n     * @param creationFlags specific flags to use when creating the texture (Constants.TEXTURE_CREATIONFLAG_STORAGE for storage textures, for eg)\n     * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).\n     * @returns the RGB alpha texture\n     */\n    static CreateRGBTexture(data, width, height, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE, type = Constants.TEXTURETYPE_UNSIGNED_BYTE, creationFlags = 0, useSRGBBuffer = false) {\n        return new RawTexture(data, width, height, Constants.TEXTUREFORMAT_RGB, sceneOrEngine, generateMipMaps, invertY, samplingMode, type, creationFlags, useSRGBBuffer);\n    }\n    /**\n     * Creates a RGBA texture from some data.\n     * @param data Define the texture data\n     * @param width Define the width of the texture\n     * @param height Define the height of the texture\n     * @param sceneOrEngine defines the scene or engine the texture will belong to\n     * @param generateMipMaps Define whether or not to create mip maps for the texture\n     * @param invertY define if the data should be flipped on Y when uploaded to the GPU\n     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)\n     * @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)\n     * @param creationFlags specific flags to use when creating the texture (Constants.TEXTURE_CREATIONFLAG_STORAGE for storage textures, for eg)\n     * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).\n     * @returns the RGBA texture\n     */\n    static CreateRGBATexture(data, width, height, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE, type = Constants.TEXTURETYPE_UNSIGNED_BYTE, creationFlags = 0, useSRGBBuffer = false) {\n        return new RawTexture(data, width, height, Constants.TEXTUREFORMAT_RGBA, sceneOrEngine, generateMipMaps, invertY, samplingMode, type, creationFlags, useSRGBBuffer);\n    }\n    /**\n     * Creates a RGBA storage texture from some data.\n     * @param data Define the texture data\n     * @param width Define the width of the texture\n     * @param height Define the height of the texture\n     * @param sceneOrEngine defines the scene or engine the texture will belong to\n     * @param generateMipMaps Define whether or not to create mip maps for the texture\n     * @param invertY define if the data should be flipped on Y when uploaded to the GPU\n     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)\n     * @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)\n     * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).\n     * @returns the RGBA texture\n     */\n    static CreateRGBAStorageTexture(data, width, height, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE, type = Constants.TEXTURETYPE_UNSIGNED_BYTE, useSRGBBuffer = false) {\n        return new RawTexture(data, width, height, Constants.TEXTUREFORMAT_RGBA, sceneOrEngine, generateMipMaps, invertY, samplingMode, type, Constants.TEXTURE_CREATIONFLAG_STORAGE, useSRGBBuffer);\n    }\n    /**\n     * Creates a R texture from some data.\n     * @param data Define the texture data\n     * @param width Define the width of the texture\n     * @param height Define the height of the texture\n     * @param sceneOrEngine defines the scene or engine the texture will belong to\n     * @param generateMipMaps Define whether or not to create mip maps for the texture\n     * @param invertY define if the data should be flipped on Y when uploaded to the GPU\n     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)\n     * @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)\n     * @returns the R texture\n     */\n    static CreateRTexture(data, width, height, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Texture.TRILINEAR_SAMPLINGMODE, type = Constants.TEXTURETYPE_FLOAT) {\n        return new RawTexture(data, width, height, Constants.TEXTUREFORMAT_R, sceneOrEngine, generateMipMaps, invertY, samplingMode, type);\n    }\n    /**\n     * Creates a R storage texture from some data.\n     * @param data Define the texture data\n     * @param width Define the width of the texture\n     * @param height Define the height of the texture\n     * @param sceneOrEngine defines the scene or engine the texture will belong to\n     * @param generateMipMaps Define whether or not to create mip maps for the texture\n     * @param invertY define if the data should be flipped on Y when uploaded to the GPU\n     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)\n     * @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)\n     * @returns the R texture\n     */\n    static CreateRStorageTexture(data, width, height, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Texture.TRILINEAR_SAMPLINGMODE, type = Constants.TEXTURETYPE_FLOAT) {\n        return new RawTexture(data, width, height, Constants.TEXTUREFORMAT_R, sceneOrEngine, generateMipMaps, invertY, samplingMode, type, Constants.TEXTURE_CREATIONFLAG_STORAGE);\n    }\n}\n//# sourceMappingURL=rawTexture.js.map"],"names":[],"mappings":"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"}

package/dist/chunks/rawTexture-DX8V9PEj.esm.min.js

@@ -1,2 +0,0 @@
-import{t as e,C as t}from"./index-rZVkfTE6.esm.min.js";class E extends e{constructor(E,T,r,R,_,i=!0,n=!1,A=t.TEXTURE_TRILINEAR_SAMPLINGMODE,s=t.TEXTURETYPE_UNSIGNED_BYTE,u,a){super(null,_,!i,n,void 0,void 0,void 0,void 0,void 0,void 0,void 0,void 0,u),this.format=R,this._engine&&(this._engine._caps.textureFloatLinearFiltering||s!==t.TEXTURETYPE_FLOAT||(A=t.TEXTURE_NEAREST_SAMPLINGMODE),this._engine._caps.textureHalfFloatLinearFiltering||s!==t.TEXTURETYPE_HALF_FLOAT||(A=t.TEXTURE_NEAREST_SAMPLINGMODE),this._texture=this._engine.createRawTexture(E,T,r,R,i,n,A,null,s,u??0,a??!1),this.wrapU=e.CLAMP_ADDRESSMODE,this.wrapV=e.CLAMP_ADDRESSMODE)}update(e){this._getEngine().updateRawTexture(this._texture,e,this._texture.format,this._texture.invertY,null,this._texture.type,this._texture._useSRGBBuffer)}clone(){if(!this._texture)return super.clone();const e=new E(null,this.getSize().width,this.getSize().height,this.format,this.getScene(),this._texture.generateMipMaps,this._invertY,this.samplingMode,this._texture.type,this._texture._creationFlags,this._useSRGBBuffer);return e._texture=this._texture,this._texture.incrementReferences(),e}static CreateLuminanceTexture(e,T,r,R,_=!0,i=!1,n=t.TEXTURE_TRILINEAR_SAMPLINGMODE){return new E(e,T,r,t.TEXTUREFORMAT_LUMINANCE,R,_,i,n)}static CreateLuminanceAlphaTexture(e,T,r,R,_=!0,i=!1,n=t.TEXTURE_TRILINEAR_SAMPLINGMODE){return new E(e,T,r,t.TEXTUREFORMAT_LUMINANCE_ALPHA,R,_,i,n)}static CreateAlphaTexture(e,T,r,R,_=!0,i=!1,n=t.TEXTURE_TRILINEAR_SAMPLINGMODE){return new E(e,T,r,t.TEXTUREFORMAT_ALPHA,R,_,i,n)}static CreateRGBTexture(e,T,r,R,_=!0,i=!1,n=t.TEXTURE_TRILINEAR_SAMPLINGMODE,A=t.TEXTURETYPE_UNSIGNED_BYTE,s=0,u=!1){return new E(e,T,r,t.TEXTUREFORMAT_RGB,R,_,i,n,A,s,u)}static CreateRGBATexture(e,T,r,R,_=!0,i=!1,n=t.TEXTURE_TRILINEAR_SAMPLINGMODE,A=t.TEXTURETYPE_UNSIGNED_BYTE,s=0,u=!1){return new E(e,T,r,t.TEXTUREFORMAT_RGBA,R,_,i,n,A,s,u)}static CreateRGBAStorageTexture(e,T,r,R,_=!0,i=!1,n=t.TEXTURE_TRILINEAR_SAMPLINGMODE,A=t.TEXTURETYPE_UNSIGNED_BYTE,s=!1){return new E(e,T,r,t.TEXTUREFORMAT_RGBA,R,_,i,n,A,t.TEXTURE_CREATIONFLAG_STORAGE,s)}static CreateRTexture(T,r,R,_,i=!0,n=!1,A=e.TRILINEAR_SAMPLINGMODE,s=t.TEXTURETYPE_FLOAT){return new E(T,r,R,t.TEXTUREFORMAT_R,_,i,n,A,s)}static CreateRStorageTexture(T,r,R,_,i=!0,n=!1,A=e.TRILINEAR_SAMPLINGMODE,s=t.TEXTURETYPE_FLOAT){return new E(T,r,R,t.TEXTUREFORMAT_R,_,i,n,A,s,t.TEXTURE_CREATIONFLAG_STORAGE)}}export{E as R};
-//# sourceMappingURL=rawTexture-DX8V9PEj.esm.min.js.map

package/dist/chunks/rawTexture-DX8V9PEj.esm.min.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"rawTexture-DX8V9PEj.esm.min.js","sources":["../../../../../dev/core/dist/Materials/Textures/rawTexture.js"],"sourcesContent":["import { Texture } from \"./texture\";\nimport { Constants } from \"../../Engines/constants\";\n/**\n * Raw texture can help creating a texture directly from an array of data.\n * This can be super useful if you either get the data from an uncompressed source or\n * if you wish to create your texture pixel by pixel.\n */\nexport class RawTexture extends Texture {\n    /**\n     * Instantiates a new RawTexture.\n     * Raw texture can help creating a texture directly from an array of data.\n     * This can be super useful if you either get the data from an uncompressed source or\n     * if you wish to create your texture pixel by pixel.\n     * @param data define the array of data to use to create the texture (null to create an empty texture)\n     * @param width define the width of the texture\n     * @param height define the height of the texture\n     * @param format define the format of the data (RGB, RGBA... Engine.TEXTUREFORMAT_xxx)\n     * @param sceneOrEngine defines the scene or engine the texture will belong to\n     * @param generateMipMaps define whether mip maps should be generated or not\n     * @param invertY define if the data should be flipped on Y when uploaded to the GPU\n     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)\n     * @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)\n     * @param creationFlags specific flags to use when creating the texture (Constants.TEXTURE_CREATIONFLAG_STORAGE for storage textures, for eg)\n     * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).\n     */\n    constructor(data, width, height, \n    /**\n     * Define the format of the data (RGB, RGBA... Engine.TEXTUREFORMAT_xxx)\n     */\n    format, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE, type = Constants.TEXTURETYPE_UNSIGNED_BYTE, creationFlags, useSRGBBuffer) {\n        super(null, sceneOrEngine, !generateMipMaps, invertY, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, creationFlags);\n        this.format = format;\n        if (!this._engine) {\n            return;\n        }\n        if (!this._engine._caps.textureFloatLinearFiltering && type === Constants.TEXTURETYPE_FLOAT) {\n            samplingMode = Constants.TEXTURE_NEAREST_SAMPLINGMODE;\n        }\n        if (!this._engine._caps.textureHalfFloatLinearFiltering && type === Constants.TEXTURETYPE_HALF_FLOAT) {\n            samplingMode = Constants.TEXTURE_NEAREST_SAMPLINGMODE;\n        }\n        this._texture = this._engine.createRawTexture(data, width, height, format, generateMipMaps, invertY, samplingMode, null, type, creationFlags ?? 0, useSRGBBuffer ?? false);\n        this.wrapU = Texture.CLAMP_ADDRESSMODE;\n        this.wrapV = Texture.CLAMP_ADDRESSMODE;\n    }\n    /**\n     * Updates the texture underlying data.\n     * @param data Define the new data of the texture\n     */\n    update(data) {\n        this._getEngine().updateRawTexture(this._texture, data, this._texture.format, this._texture.invertY, null, this._texture.type, this._texture._useSRGBBuffer);\n    }\n    /**\n     * Clones the texture.\n     * @returns the cloned texture\n     */\n    clone() {\n        if (!this._texture) {\n            return super.clone();\n        }\n        const rawTexture = new RawTexture(null, this.getSize().width, this.getSize().height, this.format, this.getScene(), this._texture.generateMipMaps, this._invertY, this.samplingMode, this._texture.type, this._texture._creationFlags, this._useSRGBBuffer);\n        rawTexture._texture = this._texture;\n        this._texture.incrementReferences();\n        return rawTexture;\n    }\n    /**\n     * Creates a luminance texture from some data.\n     * @param data Define the texture data\n     * @param width Define the width of the texture\n     * @param height Define the height of the texture\n     * @param sceneOrEngine defines the scene or engine the texture will belong to\n     * @param generateMipMaps Define whether or not to create mip maps for the texture\n     * @param invertY define if the data should be flipped on Y when uploaded to the GPU\n     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)\n     * @returns the luminance texture\n     */\n    static CreateLuminanceTexture(data, width, height, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE) {\n        return new RawTexture(data, width, height, Constants.TEXTUREFORMAT_LUMINANCE, sceneOrEngine, generateMipMaps, invertY, samplingMode);\n    }\n    /**\n     * Creates a luminance alpha texture from some data.\n     * @param data Define the texture data\n     * @param width Define the width of the texture\n     * @param height Define the height of the texture\n     * @param sceneOrEngine defines the scene or engine the texture will belong to\n     * @param generateMipMaps Define whether or not to create mip maps for the texture\n     * @param invertY define if the data should be flipped on Y when uploaded to the GPU\n     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)\n     * @returns the luminance alpha texture\n     */\n    static CreateLuminanceAlphaTexture(data, width, height, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE) {\n        return new RawTexture(data, width, height, Constants.TEXTUREFORMAT_LUMINANCE_ALPHA, sceneOrEngine, generateMipMaps, invertY, samplingMode);\n    }\n    /**\n     * Creates an alpha texture from some data.\n     * @param data Define the texture data\n     * @param width Define the width of the texture\n     * @param height Define the height of the texture\n     * @param sceneOrEngine defines the scene or engine the texture will belong to\n     * @param generateMipMaps Define whether or not to create mip maps for the texture\n     * @param invertY define if the data should be flipped on Y when uploaded to the GPU\n     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)\n     * @returns the alpha texture\n     */\n    static CreateAlphaTexture(data, width, height, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE) {\n        return new RawTexture(data, width, height, Constants.TEXTUREFORMAT_ALPHA, sceneOrEngine, generateMipMaps, invertY, samplingMode);\n    }\n    /**\n     * Creates a RGB texture from some data.\n     * @param data Define the texture data\n     * @param width Define the width of the texture\n     * @param height Define the height of the texture\n     * @param sceneOrEngine defines the scene or engine the texture will belong to\n     * @param generateMipMaps Define whether or not to create mip maps for the texture\n     * @param invertY define if the data should be flipped on Y when uploaded to the GPU\n     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)\n     * @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)\n     * @param creationFlags specific flags to use when creating the texture (Constants.TEXTURE_CREATIONFLAG_STORAGE for storage textures, for eg)\n     * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).\n     * @returns the RGB alpha texture\n     */\n    static CreateRGBTexture(data, width, height, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE, type = Constants.TEXTURETYPE_UNSIGNED_BYTE, creationFlags = 0, useSRGBBuffer = false) {\n        return new RawTexture(data, width, height, Constants.TEXTUREFORMAT_RGB, sceneOrEngine, generateMipMaps, invertY, samplingMode, type, creationFlags, useSRGBBuffer);\n    }\n    /**\n     * Creates a RGBA texture from some data.\n     * @param data Define the texture data\n     * @param width Define the width of the texture\n     * @param height Define the height of the texture\n     * @param sceneOrEngine defines the scene or engine the texture will belong to\n     * @param generateMipMaps Define whether or not to create mip maps for the texture\n     * @param invertY define if the data should be flipped on Y when uploaded to the GPU\n     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)\n     * @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)\n     * @param creationFlags specific flags to use when creating the texture (Constants.TEXTURE_CREATIONFLAG_STORAGE for storage textures, for eg)\n     * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).\n     * @returns the RGBA texture\n     */\n    static CreateRGBATexture(data, width, height, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE, type = Constants.TEXTURETYPE_UNSIGNED_BYTE, creationFlags = 0, useSRGBBuffer = false) {\n        return new RawTexture(data, width, height, Constants.TEXTUREFORMAT_RGBA, sceneOrEngine, generateMipMaps, invertY, samplingMode, type, creationFlags, useSRGBBuffer);\n    }\n    /**\n     * Creates a RGBA storage texture from some data.\n     * @param data Define the texture data\n     * @param width Define the width of the texture\n     * @param height Define the height of the texture\n     * @param sceneOrEngine defines the scene or engine the texture will belong to\n     * @param generateMipMaps Define whether or not to create mip maps for the texture\n     * @param invertY define if the data should be flipped on Y when uploaded to the GPU\n     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)\n     * @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)\n     * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).\n     * @returns the RGBA texture\n     */\n    static CreateRGBAStorageTexture(data, width, height, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Constants.TEXTURE_TRILINEAR_SAMPLINGMODE, type = Constants.TEXTURETYPE_UNSIGNED_BYTE, useSRGBBuffer = false) {\n        return new RawTexture(data, width, height, Constants.TEXTUREFORMAT_RGBA, sceneOrEngine, generateMipMaps, invertY, samplingMode, type, Constants.TEXTURE_CREATIONFLAG_STORAGE, useSRGBBuffer);\n    }\n    /**\n     * Creates a R texture from some data.\n     * @param data Define the texture data\n     * @param width Define the width of the texture\n     * @param height Define the height of the texture\n     * @param sceneOrEngine defines the scene or engine the texture will belong to\n     * @param generateMipMaps Define whether or not to create mip maps for the texture\n     * @param invertY define if the data should be flipped on Y when uploaded to the GPU\n     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)\n     * @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)\n     * @returns the R texture\n     */\n    static CreateRTexture(data, width, height, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Texture.TRILINEAR_SAMPLINGMODE, type = Constants.TEXTURETYPE_FLOAT) {\n        return new RawTexture(data, width, height, Constants.TEXTUREFORMAT_R, sceneOrEngine, generateMipMaps, invertY, samplingMode, type);\n    }\n    /**\n     * Creates a R storage texture from some data.\n     * @param data Define the texture data\n     * @param width Define the width of the texture\n     * @param height Define the height of the texture\n     * @param sceneOrEngine defines the scene or engine the texture will belong to\n     * @param generateMipMaps Define whether or not to create mip maps for the texture\n     * @param invertY define if the data should be flipped on Y when uploaded to the GPU\n     * @param samplingMode define the texture sampling mode (Texture.xxx_SAMPLINGMODE)\n     * @param type define the format of the data (int, float... Engine.TEXTURETYPE_xxx)\n     * @returns the R texture\n     */\n    static CreateRStorageTexture(data, width, height, sceneOrEngine, generateMipMaps = true, invertY = false, samplingMode = Texture.TRILINEAR_SAMPLINGMODE, type = Constants.TEXTURETYPE_FLOAT) {\n        return new RawTexture(data, width, height, Constants.TEXTUREFORMAT_R, sceneOrEngine, generateMipMaps, invertY, samplingMode, type, Constants.TEXTURE_CREATIONFLAG_STORAGE);\n    }\n}\n//# sourceMappingURL=rawTexture.js.map"],"names":["RawTexture","Texture","constructor","data","width","height","format","sceneOrEngine","generateMipMaps","invertY","samplingMode","Constants","TEXTURE_TRILINEAR_SAMPLINGMODE","type","TEXTURETYPE_UNSIGNED_BYTE","creationFlags","useSRGBBuffer","super","undefined","this","_engine","_caps","textureFloatLinearFiltering","TEXTURETYPE_FLOAT","TEXTURE_NEAREST_SAMPLINGMODE","textureHalfFloatLinearFiltering","TEXTURETYPE_HALF_FLOAT","_texture","createRawTexture","wrapU","CLAMP_ADDRESSMODE","wrapV","update","_getEngine","updateRawTexture","_useSRGBBuffer","clone","rawTexture","getSize","getScene","_invertY","_creationFlags","incrementReferences","CreateLuminanceTexture","TEXTUREFORMAT_LUMINANCE","CreateLuminanceAlphaTexture","TEXTUREFORMAT_LUMINANCE_ALPHA","CreateAlphaTexture","TEXTUREFORMAT_ALPHA","CreateRGBTexture","TEXTUREFORMAT_RGB","CreateRGBATexture","TEXTUREFORMAT_RGBA","CreateRGBAStorageTexture","TEXTURE_CREATIONFLAG_STORAGE","CreateRTexture","TRILINEAR_SAMPLINGMODE","TEXTUREFORMAT_R","CreateRStorageTexture"],"mappings":"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"}

package/dist/chunks/ray-ix7SqYNQ.esm.min.js

@@ -1,2 +0,0 @@
-import{ag as t,v as e,ah as i,ai as n,a7 as r,a5 as o,E as s,aj as a,ak as c,al as h,Y as l}from"./index-rZVkfTE6.esm.min.js";class u{constructor(t,e,n=Number.MAX_VALUE,r=i){this.origin=t,this.direction=e,this.length=n,this.epsilon=r}clone(){return new u(this.origin.clone(),this.direction.clone(),this.length)}intersectsBoxMinMax(t,e,i=0){const n=u._TmpVector3[0].copyFromFloats(t.x-i,t.y-i,t.z-i),r=u._TmpVector3[1].copyFromFloats(e.x+i,e.y+i,e.z+i);let o,s,a,c,h=0,l=Number.MAX_VALUE;if(Math.abs(this.direction.x)<1e-7){if(this.origin.x<n.x||this.origin.x>r.x)return!1}else if(o=1/this.direction.x,s=(n.x-this.origin.x)*o,a=(r.x-this.origin.x)*o,a===-1/0&&(a=1/0),s>a&&(c=s,s=a,a=c),h=Math.max(s,h),l=Math.min(a,l),h>l)return!1;if(Math.abs(this.direction.y)<1e-7){if(this.origin.y<n.y||this.origin.y>r.y)return!1}else if(o=1/this.direction.y,s=(n.y-this.origin.y)*o,a=(r.y-this.origin.y)*o,a===-1/0&&(a=1/0),s>a&&(c=s,s=a,a=c),h=Math.max(s,h),l=Math.min(a,l),h>l)return!1;if(Math.abs(this.direction.z)<1e-7){if(this.origin.z<n.z||this.origin.z>r.z)return!1}else if(o=1/this.direction.z,s=(n.z-this.origin.z)*o,a=(r.z-this.origin.z)*o,a===-1/0&&(a=1/0),s>a&&(c=s,s=a,a=c),h=Math.max(s,h),l=Math.min(a,l),h>l)return!1;return!0}intersectsBox(t,e=0){return this.intersectsBoxMinMax(t.minimum,t.maximum,e)}intersectsSphere(t,e=0){const i=t.center.x-this.origin.x,n=t.center.y-this.origin.y,r=t.center.z-this.origin.z,o=i*i+n*n+r*r,s=t.radius+e,a=s*s;if(o<=a)return!0;const c=i*this.direction.x+n*this.direction.y+r*this.direction.z;if(c<0)return!1;return o-c*c<=a}intersectsTriangle(t,i,r){const o=u._TmpVector3[0],s=u._TmpVector3[1],a=u._TmpVector3[2],c=u._TmpVector3[3],h=u._TmpVector3[4];i.subtractToRef(t,o),r.subtractToRef(t,s),e.CrossToRef(this.direction,s,a);const l=e.Dot(o,a);if(0===l)return null;const f=1/l;this.origin.subtractToRef(t,c);const m=e.Dot(c,a)*f;if(m<-this.epsilon||m>1+this.epsilon)return null;e.CrossToRef(c,o,h);const y=e.Dot(this.direction,h)*f;if(y<-this.epsilon||m+y>1+this.epsilon)return null;const d=e.Dot(s,h)*f;return d>this.length?null:new n(1-m-y,m,d)}intersectsPlane(t){let i;const n=e.Dot(t.normal,this.direction);if(Math.abs(n)<9.99999997475243e-7)return null;{const r=e.Dot(t.normal,this.origin);return i=(-t.d-r)/n,i<0?i<-9.99999997475243e-7?null:0:i}}intersectsAxis(t,i=0){switch(t){case"y":{const t=(this.origin.y-i)/this.direction.y;return t>0?null:new e(this.origin.x+this.direction.x*-t,i,this.origin.z+this.direction.z*-t)}case"x":{const t=(this.origin.x-i)/this.direction.x;return t>0?null:new e(i,this.origin.y+this.direction.y*-t,this.origin.z+this.direction.z*-t)}case"z":{const t=(this.origin.z-i)/this.direction.z;return t>0?null:new e(this.origin.x+this.direction.x*-t,this.origin.y+this.direction.y*-t,i)}default:return null}}intersectsMesh(t,e,i,n=!1,o,s=!1){const a=r.Matrix[0];return t.getWorldMatrix().invertToRef(a),this._tmpRay?u.TransformToRef(this,a,this._tmpRay):this._tmpRay=u.Transform(this,a),t.intersects(this._tmpRay,e,i,n,o,s)}intersectsMeshes(t,e,i){i?i.length=0:i=[];for(let n=0;n<t.length;n++){const r=this.intersectsMesh(t[n],e);r.hit&&i.push(r)}return i.sort(this._comparePickingInfo),i}_comparePickingInfo(t,e){return t.distance<e.distance?-1:t.distance>e.distance?1:0}intersectionSegment(t,i,n){const o=this.origin,s=r.Vector3[0],a=r.Vector3[1],c=r.Vector3[2],h=r.Vector3[3];i.subtractToRef(t,s),this.direction.scaleToRef(u._Rayl,c),o.addToRef(c,a),t.subtractToRef(o,h);const l=e.Dot(s,s),f=e.Dot(s,c),m=e.Dot(c,c),y=e.Dot(s,h),d=e.Dot(c,h),g=l*m-f*f;let R,p,T=g,x=g;g<u._Smallnum?(R=0,T=1,p=d,x=m):(R=f*d-m*y,p=l*d-f*y,R<0?(R=0,p=d,x=m):R>T&&(R=T,p=d+f,x=m)),p<0?(p=0,-y<0?R=0:-y>l?R=T:(R=-y,T=l)):p>x&&(p=x,-y+f<0?R=0:-y+f>l?R=T:(R=-y+f,T=l));const _=Math.abs(R)<u._Smallnum?0:R/T,M=Math.abs(p)<u._Smallnum?0:p/x,I=r.Vector3[4];c.scaleToRef(M,I);const k=r.Vector3[5];s.scaleToRef(_,k),k.addInPlace(h);const v=r.Vector3[6];k.subtractToRef(I,v);return M>0&&M<=this.length&&v.lengthSquared()<n*n?k.length():-1}update(t,e,i,n,s,a,c,h=!1){if(h){u._RayDistant||(u._RayDistant=u.Zero()),u._RayDistant.unprojectRayToRef(t,e,i,n,o.IdentityReadOnly,a,c);const h=r.Matrix[0];s.invertToRef(h),u.TransformToRef(u._RayDistant,h,this)}else this.unprojectRayToRef(t,e,i,n,s,a,c);return this}static Zero(){return new u(e.Zero(),e.Zero())}static CreateNew(t,e,i,n,r,o,s){return u.Zero().update(t,e,i,n,r,o,s)}static CreateNewFromTo(t,i,n=o.IdentityReadOnly){const r=new u(new e(0,0,0),new e(0,0,0));return u.CreateFromToToRef(t,i,r,n)}static CreateFromToToRef(t,e,i,n=o.IdentityReadOnly){i.origin.copyFrom(t);const r=e.subtractToRef(t,i.direction),s=Math.sqrt(r.x*r.x+r.y*r.y+r.z*r.z);return i.length=s,i.direction.normalize(),u.TransformToRef(i,n,i)}static Transform(t,i){const n=new u(new e(0,0,0),new e(0,0,0));return u.TransformToRef(t,i,n),n}static TransformToRef(t,i,n){e.TransformCoordinatesToRef(t.origin,i,n.origin),e.TransformNormalToRef(t.direction,i,n.direction),n.length=t.length,n.epsilon=t.epsilon;const r=n.direction,o=r.length();if(0!==o&&1!==o){const t=1/o;r.x*=t,r.y*=t,r.z*=t,n.length*=o}return n}unprojectRayToRef(t,i,n,o,a,c,h){const l=r.Matrix[0];a.multiplyToRef(c,l),l.multiplyToRef(h,l),l.invert();const u=s.LastCreatedEngine,f=r.Vector3[0];f.x=t/n*2-1,f.y=-(i/o*2-1),f.z=u?.useReverseDepthBuffer?1:u?.isNDCHalfZRange?0:-1;const m=r.Vector3[1].copyFromFloats(f.x,f.y,1-1e-8),y=r.Vector3[2],d=r.Vector3[3];e._UnprojectFromInvertedMatrixToRef(f,l,y),e._UnprojectFromInvertedMatrixToRef(m,l,d),this.origin.copyFrom(y),d.subtractToRef(y,this.direction),this.direction.normalize()}}function f(t,e,i,n,r,o=!1){const s=u.Zero();return m(t,e,i,n,s,r,o),s}function m(t,e,i,n,r,s,a=!1,c=!1){const h=t.getEngine();if(!s&&!(s=t.activeCamera))return t;const l=s.viewport,u=h.getRenderHeight(),{x:f,y:m,width:y,height:d}=l.toGlobal(h.getRenderWidth(),u),g=1/h.getHardwareScalingLevel();return e=e*g-f,i=i*g-(u-m-d),r.update(e,i,y,d,n||o.IdentityReadOnly,a?o.IdentityReadOnly:s.getViewMatrix(),s.getProjectionMatrix(),c),t}function y(t,e,i,n){const r=u.Zero();return d(t,e,i,r,n),r}function d(t,e,i,n,r){if(!a)return t;const s=t.getEngine();if(!r&&!(r=t.activeCamera))throw new Error("Active camera not set");const c=r.viewport,h=s.getRenderHeight(),{x:l,y:u,width:f,height:m}=c.toGlobal(s.getRenderWidth(),h),y=o.Identity(),d=1/s.getHardwareScalingLevel();return e=e*d-l,i=i*d-(h-u-m),n.update(e,i,f,m,y,y,r.getProjectionMatrix()),t}function g(t,e,i,n,r,o,s,a){const c=e(n,i.enableDistantPicking),h=i.intersects(c,r,s,o,n,a);return h&&h.hit?!r&&null!=t&&h.distance>=t.distance?null:h:null}function R(t,e,i,n,o,s){let c=null;const h=!!(t.activeCameras&&t.activeCameras.length>1&&t.cameraToUseForPointers!==t.activeCamera),l=t.cameraToUseForPointers||t.activeCamera,u=g;for(let a=0;a<t.meshes.length;a++){const f=t.meshes[a];if(i){if(!i(f,-1))continue}else if(!f.isEnabled()||!f.isVisible||!f.isPickable)continue;const m=h&&f.isWorldMatrixCameraDependent(),y=f.computeWorldMatrix(m,l);if(f.hasThinInstances&&f.thinInstanceEnablePicking){const t=u(c,e,f,y,!0,!0,s);if(t){if(o)return t;const a=r.Matrix[1],h=f.thinInstanceGetWorldMatrices();for(let t=0;t<h.length;t++){if(i&&!i(f,t))continue;h[t].multiplyToRef(y,a);const r=u(c,e,f,a,n,o,s,!0);if(r&&(c=r,c.thinInstanceIndex=t,n))return c}}}else{const t=u(c,e,f,y,n,o,s);if(t&&(c=t,n))return c}}return c||new a}function p(t,e,i,n){if(!a)return null;const o=[],s=!!(t.activeCameras&&t.activeCameras.length>1&&t.cameraToUseForPointers!==t.activeCamera),c=t.cameraToUseForPointers||t.activeCamera,h=g;for(let a=0;a<t.meshes.length;a++){const l=t.meshes[a];if(i){if(!i(l,-1))continue}else if(!l.isEnabled()||!l.isVisible||!l.isPickable)continue;const u=s&&l.isWorldMatrixCameraDependent(),f=l.computeWorldMatrix(u,c);if(l.hasThinInstances&&l.thinInstanceEnablePicking){if(h(null,e,l,f,!0,!0,n)){const t=r.Matrix[1],s=l.thinInstanceGetWorldMatrices();for(let r=0;r<s.length;r++){if(i&&!i(l,r))continue;s[r].multiplyToRef(f,t);const a=h(null,e,l,t,!1,!1,n,!0);a&&(a.thinInstanceIndex=r,o.push(a))}}}else{const t=h(null,e,l,f,!1,!1,n);t&&o.push(t)}}return o}function T(t,e,i,n,r,s){if(!a)return null;const c=R(t,(n=>(t._tempPickingRay||(t._tempPickingRay=u.Zero()),m(t,e,i,n,t._tempPickingRay,s||null),t._tempPickingRay)),n,r,!0);return c&&(c.ray=f(t,e,i,o.Identity(),s||null)),c}function x(t,e,i,n,r,s,a,c=!1){const h=R(t,((n,r)=>(t._tempPickingRay||(t._tempPickingRay=u.Zero()),m(t,e,i,n,t._tempPickingRay,s||null,!1,r),t._tempPickingRay)),n,r,!1,a);return h&&(h.ray=f(t,e,i,o.Identity(),s||null)),h}function _(t,e,i,n,r){const s=R(t,(i=>(t._pickWithRayInverseMatrix||(t._pickWithRayInverseMatrix=o.Identity()),i.invertToRef(t._pickWithRayInverseMatrix),t._cachedRayForTransform||(t._cachedRayForTransform=u.Zero()),u.TransformToRef(e,t._pickWithRayInverseMatrix,t._cachedRayForTransform),t._cachedRayForTransform)),i,n,!1,r);return s&&(s.ray=e),s}function M(t,e,i,n,r,o){return p(t,(n=>f(t,e,i,n,r||null)),n,o)}function I(t,e,i,n){return p(t,(i=>(t._pickWithRayInverseMatrix||(t._pickWithRayInverseMatrix=o.Identity()),i.invertToRef(t._pickWithRayInverseMatrix),t._cachedRayForTransform||(t._cachedRayForTransform=u.Zero()),u.TransformToRef(e,t._pickWithRayInverseMatrix,t._cachedRayForTransform),t._cachedRayForTransform)),i,n)}function k(t,i,n=100,o,s){o||(o=t.getWorldMatrix()),i.length=n,s?i.origin.copyFrom(s):i.origin.copyFrom(t.position);const a=r.Vector3[2];a.set(0,0,t._scene.useRightHandedSystem?-1:1);const c=r.Vector3[3];return e.TransformNormalToRef(a,o,c),e.NormalizeToRef(c,i.direction),i}function v(t,i){i&&(i.prototype.getForwardRay=function(t=100,i,n){return k(this,new u(e.Zero(),e.Zero(),t),t,i,n)},i.prototype.getForwardRayToRef=function(t,e=100,i,n){return k(this,t,e,i,n)}),t&&(c._IsPickingAvailable=!0,t.prototype.createPickingRay=function(t,e,i,n,r=!1){return f(this,t,e,i,n,r)})}u._TmpVector3=t(6,e.Zero),u._RayDistant=u.Zero(),u._Smallnum=1e-8,u._Rayl=1e9,v(h,l),h.prototype.createPickingRayToRef=function(t,e,i,n,r,o=!1,s=!1){return m(this,t,e,i,n,r,o,s)},h.prototype.createPickingRayInCameraSpace=function(t,e,i){return y(this,t,e,i)},h.prototype.createPickingRayInCameraSpaceToRef=function(t,e,i,n){return d(this,t,e,i,n)},h.prototype.pickWithBoundingInfo=function(t,e,i,n,r){return T(this,t,e,i,n,r)},h.prototype.pick=function(t,e,i,n,r,o,s=!1){return x(this,t,e,i,n,r,o,s)},h.prototype.pickWithRay=function(t,e,i,n){return _(this,t,e,i,n)},h.prototype.multiPick=function(t,e,i,n,r){return M(this,t,e,i,n,r)},h.prototype.multiPickWithRay=function(t,e,i){return I(this,t,e,i)};export{v as AddRayExtensions,f as CreatePickingRay,y as CreatePickingRayInCameraSpace,d as CreatePickingRayInCameraSpaceToRef,m as CreatePickingRayToRef,k as GetForwardRayToRef,M as MultiPick,I as MultiPickWithRay,x as Pick,T as PickWithBoundingInfo,_ as PickWithRay,u as Ray};
-//# sourceMappingURL=ray-ix7SqYNQ.esm.min.js.map

package/dist/chunks/ray-ix7SqYNQ.esm.min.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ray-ix7SqYNQ.esm.min.js","sources":["../../../../../dev/core/dist/Culling/ray.core.js","../../../../../dev/core/dist/Culling/ray.js"],"sourcesContent":["import { Epsilon } from \"core/Maths/math.constants\";\nimport { Matrix, TmpVectors, Vector3 } from \"core/Maths/math.vector\";\nimport { BuildArray } from \"core/Misc/arrayTools\";\nimport { IntersectionInfo } from \"../Collisions/intersectionInfo\";\nimport { PickingInfo } from \"core/Collisions/pickingInfo\";\nimport { EngineStore } from \"core/Engines/engineStore\";\nimport { _ImportHelper } from \"core/import.helper\";\n/**\n * Use this object to customize mesh picking behavior\n */\nexport const PickingCustomization = {\n    internalPickerForMesh: undefined,\n};\n/**\n * Class representing a ray with position and direction\n */\nexport class Ray {\n    /**\n     * Creates a new ray\n     * @param origin origin point\n     * @param direction direction\n     * @param length length of the ray\n     * @param epsilon The epsilon value to use when calculating the ray/triangle intersection (default: 0)\n     */\n    constructor(\n    /** origin point */\n    origin, \n    /** direction */\n    direction, \n    /** [Number.MAX_VALUE] length of the ray */\n    length = Number.MAX_VALUE, \n    /** [Epsilon] The epsilon value to use when calculating the ray/triangle intersection (default: Epsilon from math constants) */\n    epsilon = Epsilon) {\n        this.origin = origin;\n        this.direction = direction;\n        this.length = length;\n        this.epsilon = epsilon;\n    }\n    // Methods\n    /**\n     * Clone the current ray\n     * @returns a new ray\n     */\n    clone() {\n        return new Ray(this.origin.clone(), this.direction.clone(), this.length);\n    }\n    /**\n     * Checks if the ray intersects a box\n     * This does not account for the ray length by design to improve perfs.\n     * @param minimum bound of the box\n     * @param maximum bound of the box\n     * @param intersectionTreshold extra extend to be added to the box in all direction\n     * @returns if the box was hit\n     */\n    intersectsBoxMinMax(minimum, maximum, intersectionTreshold = 0) {\n        const newMinimum = Ray._TmpVector3[0].copyFromFloats(minimum.x - intersectionTreshold, minimum.y - intersectionTreshold, minimum.z - intersectionTreshold);\n        const newMaximum = Ray._TmpVector3[1].copyFromFloats(maximum.x + intersectionTreshold, maximum.y + intersectionTreshold, maximum.z + intersectionTreshold);\n        let d = 0.0;\n        let maxValue = Number.MAX_VALUE;\n        let inv;\n        let min;\n        let max;\n        let temp;\n        if (Math.abs(this.direction.x) < 0.0000001) {\n            if (this.origin.x < newMinimum.x || this.origin.x > newMaximum.x) {\n                return false;\n            }\n        }\n        else {\n            inv = 1.0 / this.direction.x;\n            min = (newMinimum.x - this.origin.x) * inv;\n            max = (newMaximum.x - this.origin.x) * inv;\n            if (max === -Infinity) {\n                max = Infinity;\n            }\n            if (min > max) {\n                temp = min;\n                min = max;\n                max = temp;\n            }\n            d = Math.max(min, d);\n            maxValue = Math.min(max, maxValue);\n            if (d > maxValue) {\n                return false;\n            }\n        }\n        if (Math.abs(this.direction.y) < 0.0000001) {\n            if (this.origin.y < newMinimum.y || this.origin.y > newMaximum.y) {\n                return false;\n            }\n        }\n        else {\n            inv = 1.0 / this.direction.y;\n            min = (newMinimum.y - this.origin.y) * inv;\n            max = (newMaximum.y - this.origin.y) * inv;\n            if (max === -Infinity) {\n                max = Infinity;\n            }\n            if (min > max) {\n                temp = min;\n                min = max;\n                max = temp;\n            }\n            d = Math.max(min, d);\n            maxValue = Math.min(max, maxValue);\n            if (d > maxValue) {\n                return false;\n            }\n        }\n        if (Math.abs(this.direction.z) < 0.0000001) {\n            if (this.origin.z < newMinimum.z || this.origin.z > newMaximum.z) {\n                return false;\n            }\n        }\n        else {\n            inv = 1.0 / this.direction.z;\n            min = (newMinimum.z - this.origin.z) * inv;\n            max = (newMaximum.z - this.origin.z) * inv;\n            if (max === -Infinity) {\n                max = Infinity;\n            }\n            if (min > max) {\n                temp = min;\n                min = max;\n                max = temp;\n            }\n            d = Math.max(min, d);\n            maxValue = Math.min(max, maxValue);\n            if (d > maxValue) {\n                return false;\n            }\n        }\n        return true;\n    }\n    /**\n     * Checks if the ray intersects a box\n     * This does not account for the ray lenght by design to improve perfs.\n     * @param box the bounding box to check\n     * @param intersectionTreshold extra extend to be added to the BoundingBox in all direction\n     * @returns if the box was hit\n     */\n    intersectsBox(box, intersectionTreshold = 0) {\n        return this.intersectsBoxMinMax(box.minimum, box.maximum, intersectionTreshold);\n    }\n    /**\n     * If the ray hits a sphere\n     * @param sphere the bounding sphere to check\n     * @param intersectionTreshold extra extend to be added to the BoundingSphere in all direction\n     * @returns true if it hits the sphere\n     */\n    intersectsSphere(sphere, intersectionTreshold = 0) {\n        const x = sphere.center.x - this.origin.x;\n        const y = sphere.center.y - this.origin.y;\n        const z = sphere.center.z - this.origin.z;\n        const pyth = x * x + y * y + z * z;\n        const radius = sphere.radius + intersectionTreshold;\n        const rr = radius * radius;\n        if (pyth <= rr) {\n            return true;\n        }\n        const dot = x * this.direction.x + y * this.direction.y + z * this.direction.z;\n        if (dot < 0.0) {\n            return false;\n        }\n        const temp = pyth - dot * dot;\n        return temp <= rr;\n    }\n    /**\n     * If the ray hits a triange\n     * @param vertex0 triangle vertex\n     * @param vertex1 triangle vertex\n     * @param vertex2 triangle vertex\n     * @returns intersection information if hit\n     */\n    intersectsTriangle(vertex0, vertex1, vertex2) {\n        const edge1 = Ray._TmpVector3[0];\n        const edge2 = Ray._TmpVector3[1];\n        const pvec = Ray._TmpVector3[2];\n        const tvec = Ray._TmpVector3[3];\n        const qvec = Ray._TmpVector3[4];\n        vertex1.subtractToRef(vertex0, edge1);\n        vertex2.subtractToRef(vertex0, edge2);\n        Vector3.CrossToRef(this.direction, edge2, pvec);\n        const det = Vector3.Dot(edge1, pvec);\n        if (det === 0) {\n            return null;\n        }\n        const invdet = 1 / det;\n        this.origin.subtractToRef(vertex0, tvec);\n        const bv = Vector3.Dot(tvec, pvec) * invdet;\n        if (bv < -this.epsilon || bv > 1.0 + this.epsilon) {\n            return null;\n        }\n        Vector3.CrossToRef(tvec, edge1, qvec);\n        const bw = Vector3.Dot(this.direction, qvec) * invdet;\n        if (bw < -this.epsilon || bv + bw > 1.0 + this.epsilon) {\n            return null;\n        }\n        //check if the distance is longer than the predefined length.\n        const distance = Vector3.Dot(edge2, qvec) * invdet;\n        if (distance > this.length) {\n            return null;\n        }\n        return new IntersectionInfo(1 - bv - bw, bv, distance);\n    }\n    /**\n     * Checks if ray intersects a plane\n     * @param plane the plane to check\n     * @returns the distance away it was hit\n     */\n    intersectsPlane(plane) {\n        let distance;\n        const result1 = Vector3.Dot(plane.normal, this.direction);\n        if (Math.abs(result1) < 9.99999997475243e-7) {\n            return null;\n        }\n        else {\n            const result2 = Vector3.Dot(plane.normal, this.origin);\n            distance = (-plane.d - result2) / result1;\n            if (distance < 0.0) {\n                if (distance < -9.99999997475243e-7) {\n                    return null;\n                }\n                else {\n                    return 0;\n                }\n            }\n            return distance;\n        }\n    }\n    /**\n     * Calculate the intercept of a ray on a given axis\n     * @param axis to check 'x' | 'y' | 'z'\n     * @param offset from axis interception (i.e. an offset of 1y is intercepted above ground)\n     * @returns a vector containing the coordinates where 'axis' is equal to zero (else offset), or null if there is no intercept.\n     */\n    intersectsAxis(axis, offset = 0) {\n        switch (axis) {\n            case \"y\": {\n                const t = (this.origin.y - offset) / this.direction.y;\n                if (t > 0) {\n                    return null;\n                }\n                return new Vector3(this.origin.x + this.direction.x * -t, offset, this.origin.z + this.direction.z * -t);\n            }\n            case \"x\": {\n                const t = (this.origin.x - offset) / this.direction.x;\n                if (t > 0) {\n                    return null;\n                }\n                return new Vector3(offset, this.origin.y + this.direction.y * -t, this.origin.z + this.direction.z * -t);\n            }\n            case \"z\": {\n                const t = (this.origin.z - offset) / this.direction.z;\n                if (t > 0) {\n                    return null;\n                }\n                return new Vector3(this.origin.x + this.direction.x * -t, this.origin.y + this.direction.y * -t, offset);\n            }\n            default:\n                return null;\n        }\n    }\n    /**\n     * Checks if ray intersects a mesh. The ray is defined in WORLD space. A mesh triangle can be picked both from its front and back sides,\n     * irrespective of orientation.\n     * @param mesh the mesh to check\n     * @param fastCheck defines if the first intersection will be used (and not the closest)\n     * @param trianglePredicate defines an optional predicate used to select faces when a mesh intersection is detected\n     * @param onlyBoundingInfo defines a boolean indicating if picking should only happen using bounding info (false by default)\n     * @param worldToUse defines the world matrix to use to get the world coordinate of the intersection point\n     * @param skipBoundingInfo a boolean indicating if we should skip the bounding info check\n     * @returns picking info of the intersection\n     */\n    intersectsMesh(mesh, fastCheck, trianglePredicate, onlyBoundingInfo = false, worldToUse, skipBoundingInfo = false) {\n        const tm = TmpVectors.Matrix[0];\n        mesh.getWorldMatrix().invertToRef(tm);\n        if (this._tmpRay) {\n            Ray.TransformToRef(this, tm, this._tmpRay);\n        }\n        else {\n            this._tmpRay = Ray.Transform(this, tm);\n        }\n        return mesh.intersects(this._tmpRay, fastCheck, trianglePredicate, onlyBoundingInfo, worldToUse, skipBoundingInfo);\n    }\n    /**\n     * Checks if ray intersects a mesh\n     * @param meshes the meshes to check\n     * @param fastCheck defines if the first intersection will be used (and not the closest)\n     * @param results array to store result in\n     * @returns Array of picking infos\n     */\n    intersectsMeshes(meshes, fastCheck, results) {\n        if (results) {\n            results.length = 0;\n        }\n        else {\n            results = [];\n        }\n        for (let i = 0; i < meshes.length; i++) {\n            const pickInfo = this.intersectsMesh(meshes[i], fastCheck);\n            if (pickInfo.hit) {\n                results.push(pickInfo);\n            }\n        }\n        results.sort(this._comparePickingInfo);\n        return results;\n    }\n    _comparePickingInfo(pickingInfoA, pickingInfoB) {\n        if (pickingInfoA.distance < pickingInfoB.distance) {\n            return -1;\n        }\n        else if (pickingInfoA.distance > pickingInfoB.distance) {\n            return 1;\n        }\n        else {\n            return 0;\n        }\n    }\n    /**\n     * Intersection test between the ray and a given segment within a given tolerance (threshold)\n     * @param sega the first point of the segment to test the intersection against\n     * @param segb the second point of the segment to test the intersection against\n     * @param threshold the tolerance margin, if the ray doesn't intersect the segment but is close to the given threshold, the intersection is successful\n     * @returns the distance from the ray origin to the intersection point if there's intersection, or -1 if there's no intersection\n     */\n    intersectionSegment(sega, segb, threshold) {\n        const o = this.origin;\n        const u = TmpVectors.Vector3[0];\n        const rsegb = TmpVectors.Vector3[1];\n        const v = TmpVectors.Vector3[2];\n        const w = TmpVectors.Vector3[3];\n        segb.subtractToRef(sega, u);\n        this.direction.scaleToRef(Ray._Rayl, v);\n        o.addToRef(v, rsegb);\n        sega.subtractToRef(o, w);\n        const a = Vector3.Dot(u, u); // always >= 0\n        const b = Vector3.Dot(u, v);\n        const c = Vector3.Dot(v, v); // always >= 0\n        const d = Vector3.Dot(u, w);\n        const e = Vector3.Dot(v, w);\n        const D = a * c - b * b; // always >= 0\n        let sN, sD = D; // sc = sN / sD, default sD = D >= 0\n        let tN, tD = D; // tc = tN / tD, default tD = D >= 0\n        // compute the line parameters of the two closest points\n        if (D < Ray._Smallnum) {\n            // the lines are almost parallel\n            sN = 0.0; // force using point P0 on segment S1\n            sD = 1.0; // to prevent possible division by 0.0 later\n            tN = e;\n            tD = c;\n        }\n        else {\n            // get the closest points on the infinite lines\n            sN = b * e - c * d;\n            tN = a * e - b * d;\n            if (sN < 0.0) {\n                // sc < 0 => the s=0 edge is visible\n                sN = 0.0;\n                tN = e;\n                tD = c;\n            }\n            else if (sN > sD) {\n                // sc > 1 => the s=1 edge is visible\n                sN = sD;\n                tN = e + b;\n                tD = c;\n            }\n        }\n        if (tN < 0.0) {\n            // tc < 0 => the t=0 edge is visible\n            tN = 0.0;\n            // recompute sc for this edge\n            if (-d < 0.0) {\n                sN = 0.0;\n            }\n            else if (-d > a) {\n                sN = sD;\n            }\n            else {\n                sN = -d;\n                sD = a;\n            }\n        }\n        else if (tN > tD) {\n            // tc > 1 => the t=1 edge is visible\n            tN = tD;\n            // recompute sc for this edge\n            if (-d + b < 0.0) {\n                sN = 0;\n            }\n            else if (-d + b > a) {\n                sN = sD;\n            }\n            else {\n                sN = -d + b;\n                sD = a;\n            }\n        }\n        // finally do the division to get sc and tc\n        const sc = Math.abs(sN) < Ray._Smallnum ? 0.0 : sN / sD;\n        const tc = Math.abs(tN) < Ray._Smallnum ? 0.0 : tN / tD;\n        // get the difference of the two closest points\n        const qtc = TmpVectors.Vector3[4];\n        v.scaleToRef(tc, qtc);\n        const qsc = TmpVectors.Vector3[5];\n        u.scaleToRef(sc, qsc);\n        qsc.addInPlace(w);\n        const dP = TmpVectors.Vector3[6];\n        qsc.subtractToRef(qtc, dP); // = S1(sc) - S2(tc)\n        const isIntersected = tc > 0 && tc <= this.length && dP.lengthSquared() < threshold * threshold; // return intersection result\n        if (isIntersected) {\n            return qsc.length();\n        }\n        return -1;\n    }\n    /**\n     * Update the ray from viewport position\n     * @param x position\n     * @param y y position\n     * @param viewportWidth viewport width\n     * @param viewportHeight viewport height\n     * @param world world matrix\n     * @param view view matrix\n     * @param projection projection matrix\n     * @param enableDistantPicking defines if picking should handle large values for mesh position/scaling (false by default)\n     * @returns this ray updated\n     */\n    update(x, y, viewportWidth, viewportHeight, world, view, projection, enableDistantPicking = false) {\n        if (enableDistantPicking) {\n            // With world matrices having great values (like 8000000000 on 1 or more scaling or position axis),\n            // multiplying view/projection/world and doing invert will result in loss of float precision in the matrix.\n            // One way to fix it is to compute the ray with world at identity then transform the ray in object space.\n            // This is slower (2 matrix inverts instead of 1) but precision is preserved.\n            // This is hidden behind `EnableDistantPicking` flag (default is false)\n            if (!Ray._RayDistant) {\n                Ray._RayDistant = Ray.Zero();\n            }\n            Ray._RayDistant.unprojectRayToRef(x, y, viewportWidth, viewportHeight, Matrix.IdentityReadOnly, view, projection);\n            const tm = TmpVectors.Matrix[0];\n            world.invertToRef(tm);\n            Ray.TransformToRef(Ray._RayDistant, tm, this);\n        }\n        else {\n            this.unprojectRayToRef(x, y, viewportWidth, viewportHeight, world, view, projection);\n        }\n        return this;\n    }\n    // Statics\n    /**\n     * Creates a ray with origin and direction of 0,0,0\n     * @returns the new ray\n     */\n    static Zero() {\n        return new Ray(Vector3.Zero(), Vector3.Zero());\n    }\n    /**\n     * Creates a new ray from screen space and viewport\n     * @param x position\n     * @param y y position\n     * @param viewportWidth viewport width\n     * @param viewportHeight viewport height\n     * @param world world matrix\n     * @param view view matrix\n     * @param projection projection matrix\n     * @returns new ray\n     */\n    static CreateNew(x, y, viewportWidth, viewportHeight, world, view, projection) {\n        const result = Ray.Zero();\n        return result.update(x, y, viewportWidth, viewportHeight, world, view, projection);\n    }\n    /**\n     * Function will create a new transformed ray starting from origin and ending at the end point. Ray's length will be set, and ray will be\n     * transformed to the given world matrix.\n     * @param origin The origin point\n     * @param end The end point\n     * @param world a matrix to transform the ray to. Default is the identity matrix.\n     * @returns the new ray\n     */\n    static CreateNewFromTo(origin, end, world = Matrix.IdentityReadOnly) {\n        const result = new Ray(new Vector3(0, 0, 0), new Vector3(0, 0, 0));\n        return Ray.CreateFromToToRef(origin, end, result, world);\n    }\n    /**\n     * Function will update a transformed ray starting from origin and ending at the end point. Ray's length will be set, and ray will be\n     * transformed to the given world matrix.\n     * @param origin The origin point\n     * @param end The end point\n     * @param result the object to store the result\n     * @param world a matrix to transform the ray to. Default is the identity matrix.\n     * @returns the ref ray\n     */\n    static CreateFromToToRef(origin, end, result, world = Matrix.IdentityReadOnly) {\n        result.origin.copyFrom(origin);\n        const direction = end.subtractToRef(origin, result.direction);\n        const length = Math.sqrt(direction.x * direction.x + direction.y * direction.y + direction.z * direction.z);\n        result.length = length;\n        result.direction.normalize();\n        return Ray.TransformToRef(result, world, result);\n    }\n    /**\n     * Transforms a ray by a matrix\n     * @param ray ray to transform\n     * @param matrix matrix to apply\n     * @returns the resulting new ray\n     */\n    static Transform(ray, matrix) {\n        const result = new Ray(new Vector3(0, 0, 0), new Vector3(0, 0, 0));\n        Ray.TransformToRef(ray, matrix, result);\n        return result;\n    }\n    /**\n     * Transforms a ray by a matrix\n     * @param ray ray to transform\n     * @param matrix matrix to apply\n     * @param result ray to store result in\n     * @returns the updated result ray\n     */\n    static TransformToRef(ray, matrix, result) {\n        Vector3.TransformCoordinatesToRef(ray.origin, matrix, result.origin);\n        Vector3.TransformNormalToRef(ray.direction, matrix, result.direction);\n        result.length = ray.length;\n        result.epsilon = ray.epsilon;\n        const dir = result.direction;\n        const len = dir.length();\n        if (!(len === 0 || len === 1)) {\n            const num = 1.0 / len;\n            dir.x *= num;\n            dir.y *= num;\n            dir.z *= num;\n            result.length *= len;\n        }\n        return result;\n    }\n    /**\n     * Unproject a ray from screen space to object space\n     * @param sourceX defines the screen space x coordinate to use\n     * @param sourceY defines the screen space y coordinate to use\n     * @param viewportWidth defines the current width of the viewport\n     * @param viewportHeight defines the current height of the viewport\n     * @param world defines the world matrix to use (can be set to Identity to go to world space)\n     * @param view defines the view matrix to use\n     * @param projection defines the projection matrix to use\n     */\n    unprojectRayToRef(sourceX, sourceY, viewportWidth, viewportHeight, world, view, projection) {\n        const matrix = TmpVectors.Matrix[0];\n        world.multiplyToRef(view, matrix);\n        matrix.multiplyToRef(projection, matrix);\n        matrix.invert();\n        const engine = EngineStore.LastCreatedEngine;\n        const nearScreenSource = TmpVectors.Vector3[0];\n        nearScreenSource.x = (sourceX / viewportWidth) * 2 - 1;\n        nearScreenSource.y = -((sourceY / viewportHeight) * 2 - 1);\n        nearScreenSource.z = engine?.useReverseDepthBuffer ? 1 : engine?.isNDCHalfZRange ? 0 : -1;\n        // far Z need to be close but < to 1 or camera projection matrix with maxZ = 0 will NaN\n        const farScreenSource = TmpVectors.Vector3[1].copyFromFloats(nearScreenSource.x, nearScreenSource.y, 1.0 - 1e-8);\n        const nearVec3 = TmpVectors.Vector3[2];\n        const farVec3 = TmpVectors.Vector3[3];\n        Vector3._UnprojectFromInvertedMatrixToRef(nearScreenSource, matrix, nearVec3);\n        Vector3._UnprojectFromInvertedMatrixToRef(farScreenSource, matrix, farVec3);\n        this.origin.copyFrom(nearVec3);\n        farVec3.subtractToRef(nearVec3, this.direction);\n        this.direction.normalize();\n    }\n}\nRay._TmpVector3 = BuildArray(6, Vector3.Zero);\nRay._RayDistant = Ray.Zero();\nRay._Smallnum = 0.00000001;\nRay._Rayl = 10e8;\n/**\n * Creates a ray that can be used to pick in the scene\n * @param scene defines the scene to use for the picking\n * @param x defines the x coordinate of the origin (on-screen)\n * @param y defines the y coordinate of the origin (on-screen)\n * @param world defines the world matrix to use if you want to pick in object space (instead of world space)\n * @param camera defines the camera to use for the picking\n * @param cameraViewSpace defines if picking will be done in view space (false by default)\n * @returns a Ray\n */\nexport function CreatePickingRay(scene, x, y, world, camera, cameraViewSpace = false) {\n    const result = Ray.Zero();\n    CreatePickingRayToRef(scene, x, y, world, result, camera, cameraViewSpace);\n    return result;\n}\n/**\n * Creates a ray that can be used to pick in the scene\n * @param scene defines the scene to use for the picking\n * @param x defines the x coordinate of the origin (on-screen)\n * @param y defines the y coordinate of the origin (on-screen)\n * @param world defines the world matrix to use if you want to pick in object space (instead of world space)\n * @param result defines the ray where to store the picking ray\n * @param camera defines the camera to use for the picking\n * @param cameraViewSpace defines if picking will be done in view space (false by default)\n * @param enableDistantPicking defines if picking should handle large values for mesh position/scaling (false by default)\n * @returns the current scene\n */\nexport function CreatePickingRayToRef(scene, x, y, world, result, camera, cameraViewSpace = false, enableDistantPicking = false) {\n    const engine = scene.getEngine();\n    if (!camera && !(camera = scene.activeCamera)) {\n        return scene;\n    }\n    const cameraViewport = camera.viewport;\n    const renderHeight = engine.getRenderHeight();\n    const { x: vx, y: vy, width, height } = cameraViewport.toGlobal(engine.getRenderWidth(), renderHeight);\n    // Moving coordinates to local viewport world\n    const levelInv = 1 / engine.getHardwareScalingLevel();\n    x = x * levelInv - vx;\n    y = y * levelInv - (renderHeight - vy - height);\n    result.update(x, y, width, height, world ? world : Matrix.IdentityReadOnly, cameraViewSpace ? Matrix.IdentityReadOnly : camera.getViewMatrix(), camera.getProjectionMatrix(), enableDistantPicking);\n    return scene;\n}\n/**\n * Creates a ray that can be used to pick in the scene\n * @param scene defines the scene to use for the picking\n * @param x defines the x coordinate of the origin (on-screen)\n * @param y defines the y coordinate of the origin (on-screen)\n * @param camera defines the camera to use for the picking\n * @returns a Ray\n */\nexport function CreatePickingRayInCameraSpace(scene, x, y, camera) {\n    const result = Ray.Zero();\n    CreatePickingRayInCameraSpaceToRef(scene, x, y, result, camera);\n    return result;\n}\n/**\n * Creates a ray that can be used to pick in the scene\n * @param scene defines the scene to use for the picking\n * @param x defines the x coordinate of the origin (on-screen)\n * @param y defines the y coordinate of the origin (on-screen)\n * @param result defines the ray where to store the picking ray\n * @param camera defines the camera to use for the picking\n * @returns the current scene\n */\nexport function CreatePickingRayInCameraSpaceToRef(scene, x, y, result, camera) {\n    if (!PickingInfo) {\n        return scene;\n    }\n    const engine = scene.getEngine();\n    if (!camera && !(camera = scene.activeCamera)) {\n        throw new Error(\"Active camera not set\");\n    }\n    const cameraViewport = camera.viewport;\n    const renderHeight = engine.getRenderHeight();\n    const { x: vx, y: vy, width, height } = cameraViewport.toGlobal(engine.getRenderWidth(), renderHeight);\n    const identity = Matrix.Identity();\n    // Moving coordinates to local viewport world\n    const levelInv = 1 / engine.getHardwareScalingLevel();\n    x = x * levelInv - vx;\n    y = y * levelInv - (renderHeight - vy - height);\n    result.update(x, y, width, height, identity, identity, camera.getProjectionMatrix());\n    return scene;\n}\nfunction InternalPickForMesh(pickingInfo, rayFunction, mesh, world, fastCheck, onlyBoundingInfo, trianglePredicate, skipBoundingInfo) {\n    const ray = rayFunction(world, mesh.enableDistantPicking);\n    const result = mesh.intersects(ray, fastCheck, trianglePredicate, onlyBoundingInfo, world, skipBoundingInfo);\n    if (!result || !result.hit) {\n        return null;\n    }\n    if (!fastCheck && pickingInfo != null && result.distance >= pickingInfo.distance) {\n        return null;\n    }\n    return result;\n}\nfunction InternalPick(scene, rayFunction, predicate, fastCheck, onlyBoundingInfo, trianglePredicate) {\n    let pickingInfo = null;\n    const computeWorldMatrixForCamera = !!(scene.activeCameras && scene.activeCameras.length > 1 && scene.cameraToUseForPointers !== scene.activeCamera);\n    const currentCamera = scene.cameraToUseForPointers || scene.activeCamera;\n    const picker = PickingCustomization.internalPickerForMesh || InternalPickForMesh;\n    for (let meshIndex = 0; meshIndex < scene.meshes.length; meshIndex++) {\n        const mesh = scene.meshes[meshIndex];\n        if (predicate) {\n            if (!predicate(mesh, -1)) {\n                continue;\n            }\n        }\n        else if (!mesh.isEnabled() || !mesh.isVisible || !mesh.isPickable) {\n            continue;\n        }\n        const forceCompute = computeWorldMatrixForCamera && mesh.isWorldMatrixCameraDependent();\n        const world = mesh.computeWorldMatrix(forceCompute, currentCamera);\n        if (mesh.hasThinInstances && mesh.thinInstanceEnablePicking) {\n            // first check if the ray intersects the whole bounding box/sphere of the mesh\n            const result = picker(pickingInfo, rayFunction, mesh, world, true, true, trianglePredicate);\n            if (result) {\n                if (onlyBoundingInfo) {\n                    // the user only asked for a bounding info check so we can return\n                    return result;\n                }\n                const tmpMatrix = TmpVectors.Matrix[1];\n                const thinMatrices = mesh.thinInstanceGetWorldMatrices();\n                for (let index = 0; index < thinMatrices.length; index++) {\n                    if (predicate && !predicate(mesh, index)) {\n                        continue;\n                    }\n                    const thinMatrix = thinMatrices[index];\n                    thinMatrix.multiplyToRef(world, tmpMatrix);\n                    const result = picker(pickingInfo, rayFunction, mesh, tmpMatrix, fastCheck, onlyBoundingInfo, trianglePredicate, true);\n                    if (result) {\n                        pickingInfo = result;\n                        pickingInfo.thinInstanceIndex = index;\n                        if (fastCheck) {\n                            return pickingInfo;\n                        }\n                    }\n                }\n            }\n        }\n        else {\n            const result = picker(pickingInfo, rayFunction, mesh, world, fastCheck, onlyBoundingInfo, trianglePredicate);\n            if (result) {\n                pickingInfo = result;\n                if (fastCheck) {\n                    return pickingInfo;\n                }\n            }\n        }\n    }\n    return pickingInfo || new PickingInfo();\n}\nfunction InternalMultiPick(scene, rayFunction, predicate, trianglePredicate) {\n    if (!PickingInfo) {\n        return null;\n    }\n    const pickingInfos = [];\n    const computeWorldMatrixForCamera = !!(scene.activeCameras && scene.activeCameras.length > 1 && scene.cameraToUseForPointers !== scene.activeCamera);\n    const currentCamera = scene.cameraToUseForPointers || scene.activeCamera;\n    const picker = PickingCustomization.internalPickerForMesh || InternalPickForMesh;\n    for (let meshIndex = 0; meshIndex < scene.meshes.length; meshIndex++) {\n        const mesh = scene.meshes[meshIndex];\n        if (predicate) {\n            if (!predicate(mesh, -1)) {\n                continue;\n            }\n        }\n        else if (!mesh.isEnabled() || !mesh.isVisible || !mesh.isPickable) {\n            continue;\n        }\n        const forceCompute = computeWorldMatrixForCamera && mesh.isWorldMatrixCameraDependent();\n        const world = mesh.computeWorldMatrix(forceCompute, currentCamera);\n        if (mesh.hasThinInstances && mesh.thinInstanceEnablePicking) {\n            const result = picker(null, rayFunction, mesh, world, true, true, trianglePredicate);\n            if (result) {\n                const tmpMatrix = TmpVectors.Matrix[1];\n                const thinMatrices = mesh.thinInstanceGetWorldMatrices();\n                for (let index = 0; index < thinMatrices.length; index++) {\n                    if (predicate && !predicate(mesh, index)) {\n                        continue;\n                    }\n                    const thinMatrix = thinMatrices[index];\n                    thinMatrix.multiplyToRef(world, tmpMatrix);\n                    const result = picker(null, rayFunction, mesh, tmpMatrix, false, false, trianglePredicate, true);\n                    if (result) {\n                        result.thinInstanceIndex = index;\n                        pickingInfos.push(result);\n                    }\n                }\n            }\n        }\n        else {\n            const result = picker(null, rayFunction, mesh, world, false, false, trianglePredicate);\n            if (result) {\n                pickingInfos.push(result);\n            }\n        }\n    }\n    return pickingInfos;\n}\n/** Launch a ray to try to pick a mesh in the scene using only bounding information of the main mesh (not using submeshes)\n * @param scene defines the scene to use for the picking\n * @param x position on screen\n * @param y position on screen\n * @param predicate Predicate function used to determine eligible meshes. Can be set to null. In this case, a mesh must be enabled, visible and with isPickable set to true. thinInstanceIndex is -1 when the mesh is non-instanced\n * @param fastCheck defines if the first intersection will be used (and not the closest)\n * @param camera to use for computing the picking ray. Can be set to null. In this case, the scene.activeCamera will be used\n * @returns a PickingInfo (Please note that some info will not be set like distance, bv, bu and everything that cannot be capture by only using bounding infos)\n */\nexport function PickWithBoundingInfo(scene, x, y, predicate, fastCheck, camera) {\n    if (!PickingInfo) {\n        return null;\n    }\n    const result = InternalPick(scene, (world) => {\n        if (!scene._tempPickingRay) {\n            scene._tempPickingRay = Ray.Zero();\n        }\n        CreatePickingRayToRef(scene, x, y, world, scene._tempPickingRay, camera || null);\n        return scene._tempPickingRay;\n    }, predicate, fastCheck, true);\n    if (result) {\n        result.ray = CreatePickingRay(scene, x, y, Matrix.Identity(), camera || null);\n    }\n    return result;\n}\n/** Launch a ray to try to pick a mesh in the scene\n * @param scene defines the scene to use for the picking\n * @param x position on screen\n * @param y position on screen\n * @param predicate Predicate function used to determine eligible meshes. Can be set to null. In this case, a mesh must be enabled, visible and with isPickable set to true. thinInstanceIndex is -1 when the mesh is non-instanced\n * @param fastCheck defines if the first intersection will be used (and not the closest)\n * @param camera to use for computing the picking ray. Can be set to null. In this case, the scene.activeCamera will be used\n * @param trianglePredicate defines an optional predicate used to select faces when a mesh intersection is detected\n * @param _enableDistantPicking defines if picking should handle large values for mesh position/scaling (false by default)\n * @returns a PickingInfo\n */\nexport function Pick(scene, x, y, predicate, fastCheck, camera, trianglePredicate, _enableDistantPicking = false) {\n    const result = InternalPick(scene, (world, enableDistantPicking) => {\n        if (!scene._tempPickingRay) {\n            scene._tempPickingRay = Ray.Zero();\n        }\n        CreatePickingRayToRef(scene, x, y, world, scene._tempPickingRay, camera || null, false, enableDistantPicking);\n        return scene._tempPickingRay;\n    }, predicate, fastCheck, false, trianglePredicate);\n    if (result) {\n        result.ray = CreatePickingRay(scene, x, y, Matrix.Identity(), camera || null);\n    }\n    return result;\n}\n/**\n * Use the given ray to pick a mesh in the scene. A mesh triangle can be picked both from its front and back sides,\n * irrespective of orientation.\n * @param scene defines the scene to use for the picking\n * @param ray The ray to use to pick meshes\n * @param predicate Predicate function used to determine eligible meshes. Can be set to null. In this case, a mesh must have isPickable set to true. thinInstanceIndex is -1 when the mesh is non-instanced\n * @param fastCheck defines if the first intersection will be used (and not the closest)\n * @param trianglePredicate defines an optional predicate used to select faces when a mesh intersection is detected\n * @returns a PickingInfo\n */\nexport function PickWithRay(scene, ray, predicate, fastCheck, trianglePredicate) {\n    const result = InternalPick(scene, (world) => {\n        if (!scene._pickWithRayInverseMatrix) {\n            scene._pickWithRayInverseMatrix = Matrix.Identity();\n        }\n        world.invertToRef(scene._pickWithRayInverseMatrix);\n        if (!scene._cachedRayForTransform) {\n            scene._cachedRayForTransform = Ray.Zero();\n        }\n        Ray.TransformToRef(ray, scene._pickWithRayInverseMatrix, scene._cachedRayForTransform);\n        return scene._cachedRayForTransform;\n    }, predicate, fastCheck, false, trianglePredicate);\n    if (result) {\n        result.ray = ray;\n    }\n    return result;\n}\n/**\n * Launch a ray to try to pick a mesh in the scene. A mesh triangle can be picked both from its front and back sides,\n * irrespective of orientation.\n * @param scene defines the scene to use for the picking\n * @param x X position on screen\n * @param y Y position on screen\n * @param predicate Predicate function used to determine eligible meshes and instances. Can be set to null. In this case, a mesh must be enabled, visible and with isPickable set to true. thinInstanceIndex is -1 when the mesh is non-instanced\n * @param camera camera to use for computing the picking ray. Can be set to null. In this case, the scene.activeCamera will be used\n * @param trianglePredicate defines an optional predicate used to select faces when a mesh intersection is detected\n * @returns an array of PickingInfo\n */\nexport function MultiPick(scene, x, y, predicate, camera, trianglePredicate) {\n    return InternalMultiPick(scene, (world) => CreatePickingRay(scene, x, y, world, camera || null), predicate, trianglePredicate);\n}\n/**\n * Launch a ray to try to pick a mesh in the scene\n * @param scene defines the scene to use for the picking\n * @param ray Ray to use\n * @param predicate Predicate function used to determine eligible meshes and instances. Can be set to null. In this case, a mesh must be enabled, visible and with isPickable set to true. thinInstanceIndex is -1 when the mesh is non-instanced\n * @param trianglePredicate defines an optional predicate used to select faces when a mesh intersection is detected\n * @returns an array of PickingInfo\n */\nexport function MultiPickWithRay(scene, ray, predicate, trianglePredicate) {\n    return InternalMultiPick(scene, (world) => {\n        if (!scene._pickWithRayInverseMatrix) {\n            scene._pickWithRayInverseMatrix = Matrix.Identity();\n        }\n        world.invertToRef(scene._pickWithRayInverseMatrix);\n        if (!scene._cachedRayForTransform) {\n            scene._cachedRayForTransform = Ray.Zero();\n        }\n        Ray.TransformToRef(ray, scene._pickWithRayInverseMatrix, scene._cachedRayForTransform);\n        return scene._cachedRayForTransform;\n    }, predicate, trianglePredicate);\n}\n/**\n * Gets a ray in the forward direction from the camera.\n * @param camera Defines the camera to use to get the ray from\n * @param length Defines the length of the ray to create\n * @param transform Defines the transform to apply to the ray, by default the world matrix is used to create a workd space ray\n * @param origin Defines the start point of the ray which defaults to the camera position\n * @returns the forward ray\n */\nexport function GetForwardRay(camera, length = 100, transform, origin) {\n    return GetForwardRayToRef(camera, new Ray(Vector3.Zero(), Vector3.Zero(), length), length, transform, origin);\n}\n/**\n * Gets a ray in the forward direction from the camera.\n * @param camera Defines the camera to use to get the ray from\n * @param refRay the ray to (re)use when setting the values\n * @param length Defines the length of the ray to create\n * @param transform Defines the transform to apply to the ray, by default the world matrx is used to create a workd space ray\n * @param origin Defines the start point of the ray which defaults to the camera position\n * @returns the forward ray\n */\nexport function GetForwardRayToRef(camera, refRay, length = 100, transform, origin) {\n    if (!transform) {\n        transform = camera.getWorldMatrix();\n    }\n    refRay.length = length;\n    if (origin) {\n        refRay.origin.copyFrom(origin);\n    }\n    else {\n        refRay.origin.copyFrom(camera.position);\n    }\n    const forward = TmpVectors.Vector3[2];\n    forward.set(0, 0, camera._scene.useRightHandedSystem ? -1 : 1);\n    const worldForward = TmpVectors.Vector3[3];\n    Vector3.TransformNormalToRef(forward, transform, worldForward);\n    Vector3.NormalizeToRef(worldForward, refRay.direction);\n    return refRay;\n}\n/**\n * Initialize the minimal interdependecies between the Ray and Scene and Camera\n * @param sceneClass defines the scene prototype to use\n * @param cameraClass defines the camera prototype to use\n */\nexport function AddRayExtensions(sceneClass, cameraClass) {\n    if (cameraClass) {\n        cameraClass.prototype.getForwardRay = function (length = 100, transform, origin) {\n            return GetForwardRayToRef(this, new Ray(Vector3.Zero(), Vector3.Zero(), length), length, transform, origin);\n        };\n        cameraClass.prototype.getForwardRayToRef = function (refRay, length = 100, transform, origin) {\n            return GetForwardRayToRef(this, refRay, length, transform, origin);\n        };\n    }\n    if (!sceneClass) {\n        return;\n    }\n    _ImportHelper._IsPickingAvailable = true;\n    sceneClass.prototype.createPickingRay = function (x, y, world, camera, cameraViewSpace = false) {\n        return CreatePickingRay(this, x, y, world, camera, cameraViewSpace);\n    };\n}\n//# sourceMappingURL=ray.core.js.map","import { Scene } from \"../scene\";\nimport { Camera } from \"../Cameras/camera\";\nimport { AddRayExtensions, CreatePickingRayInCameraSpace, CreatePickingRayInCameraSpaceToRef, CreatePickingRayToRef, MultiPick, MultiPickWithRay, Pick, PickWithBoundingInfo, PickWithRay, } from \"./ray.core\";\nexport * from \"./ray.core\";\n// Picking\nAddRayExtensions(Scene, Camera);\nScene.prototype.createPickingRayToRef = function (x, y, world, result, camera, cameraViewSpace = false, enableDistantPicking = false) {\n    return CreatePickingRayToRef(this, x, y, world, result, camera, cameraViewSpace, enableDistantPicking);\n};\nScene.prototype.createPickingRayInCameraSpace = function (x, y, camera) {\n    return CreatePickingRayInCameraSpace(this, x, y, camera);\n};\nScene.prototype.createPickingRayInCameraSpaceToRef = function (x, y, result, camera) {\n    return CreatePickingRayInCameraSpaceToRef(this, x, y, result, camera);\n};\nScene.prototype.pickWithBoundingInfo = function (x, y, predicate, fastCheck, camera) {\n    return PickWithBoundingInfo(this, x, y, predicate, fastCheck, camera);\n};\nScene.prototype.pick = function (x, y, predicate, fastCheck, camera, trianglePredicate, _enableDistantPicking = false) {\n    return Pick(this, x, y, predicate, fastCheck, camera, trianglePredicate, _enableDistantPicking);\n};\nScene.prototype.pickWithRay = function (ray, predicate, fastCheck, trianglePredicate) {\n    return PickWithRay(this, ray, predicate, fastCheck, trianglePredicate);\n};\nScene.prototype.multiPick = function (x, y, predicate, camera, trianglePredicate) {\n    return MultiPick(this, x, y, predicate, camera, trianglePredicate);\n};\nScene.prototype.multiPickWithRay = function (ray, predicate, trianglePredicate) {\n    return MultiPickWithRay(this, ray, predicate, trianglePredicate);\n};\n//# sourceMappingURL=ray.js.map"],"names":["Ray","constructor","origin","direction","length","Number","MAX_VALUE","epsilon","Epsilon","this","clone","intersectsBoxMinMax","minimum","maximum","intersectionTreshold","newMinimum","_TmpVector3","copyFromFloats","x","y","z","newMaximum","inv","min","max","temp","d","maxValue","Math","abs","Infinity","intersectsBox","box","intersectsSphere","sphere","center","pyth","radius","rr","dot","intersectsTriangle","vertex0","vertex1","vertex2","edge1","edge2","pvec","tvec","qvec","subtractToRef","Vector3","CrossToRef","det","Dot","invdet","bv","bw","distance","IntersectionInfo","intersectsPlane","plane","result1","normal","result2","intersectsAxis","axis","offset","t","intersectsMesh","mesh","fastCheck","trianglePredicate","onlyBoundingInfo","worldToUse","skipBoundingInfo","tm","TmpVectors","Matrix","getWorldMatrix","invertToRef","_tmpRay","TransformToRef","Transform","intersects","intersectsMeshes","meshes","results","i","pickInfo","hit","push","sort","_comparePickingInfo","pickingInfoA","pickingInfoB","intersectionSegment","sega","segb","threshold","o","u","rsegb","v","w","scaleToRef","_Rayl","addToRef","a","b","c","e","D","sN","tN","sD","tD","_Smallnum","sc","tc","qtc","qsc","addInPlace","dP","lengthSquared","update","viewportWidth","viewportHeight","world","view","projection","enableDistantPicking","_RayDistant","Zero","unprojectRayToRef","IdentityReadOnly","CreateNew","CreateNewFromTo","end","result","CreateFromToToRef","copyFrom","sqrt","normalize","ray","matrix","TransformCoordinatesToRef","TransformNormalToRef","dir","len","num","sourceX","sourceY","multiplyToRef","invert","engine","EngineStore","LastCreatedEngine","nearScreenSource","useReverseDepthBuffer","isNDCHalfZRange","farScreenSource","nearVec3","farVec3","_UnprojectFromInvertedMatrixToRef","CreatePickingRay","scene","camera","cameraViewSpace","CreatePickingRayToRef","getEngine","activeCamera","cameraViewport","viewport","renderHeight","getRenderHeight","vx","vy","width","height","toGlobal","getRenderWidth","levelInv","getHardwareScalingLevel","getViewMatrix","getProjectionMatrix","CreatePickingRayInCameraSpace","CreatePickingRayInCameraSpaceToRef","PickingInfo","Error","identity","Identity","InternalPickForMesh","pickingInfo","rayFunction","InternalPick","predicate","computeWorldMatrixForCamera","activeCameras","cameraToUseForPointers","currentCamera","picker","meshIndex","isEnabled","isVisible","isPickable","forceCompute","isWorldMatrixCameraDependent","computeWorldMatrix","hasThinInstances","thinInstanceEnablePicking","tmpMatrix","thinMatrices","thinInstanceGetWorldMatrices","index","thinInstanceIndex","InternalMultiPick","pickingInfos","PickWithBoundingInfo","_tempPickingRay","Pick","_enableDistantPicking","PickWithRay","_pickWithRayInverseMatrix","_cachedRayForTransform","MultiPick","MultiPickWithRay","GetForwardRayToRef","refRay","transform","position","forward","set","_scene","useRightHandedSystem","worldForward","NormalizeToRef","AddRayExtensions","sceneClass","cameraClass","prototype","getForwardRay","getForwardRayToRef","_ImportHelper","_IsPickingAvailable","createPickingRay","BuildArray","Scene","Camera","createPickingRayToRef","createPickingRayInCameraSpace","createPickingRayInCameraSpaceToRef","pickWithBoundingInfo","pick","pickWithRay","multiPick","multiPickWithRay"],"mappings":"8HAgBO,MAAMA,EAQT,WAAAC,CAEAC,EAEAC,EAEAC,EAASC,OAAOC,UAEhBC,EAAUC,GACNC,KAAKP,OAASA,EACdO,KAAKN,UAAYA,EACjBM,KAAKL,OAASA,EACdK,KAAKF,QAAUA,CACvB,CAMI,KAAAG,GACI,OAAO,IAAIV,EAAIS,KAAKP,OAAOQ,QAASD,KAAKN,UAAUO,QAASD,KAAKL,OACzE,CASI,mBAAAO,CAAoBC,EAASC,EAASC,EAAuB,GACzD,MAAMC,EAAaf,EAAIgB,YAAY,GAAGC,eAAeL,EAAQM,EAAIJ,EAAsBF,EAAQO,EAAIL,EAAsBF,EAAQQ,EAAIN,GAC/HO,EAAarB,EAAIgB,YAAY,GAAGC,eAAeJ,EAAQK,EAAIJ,EAAsBD,EAAQM,EAAIL,EAAsBD,EAAQO,EAAIN,GACrI,IAEIQ,EACAC,EACAC,EACAC,EALAC,EAAI,EACJC,EAAWtB,OAAOC,UAKtB,GAAIsB,KAAKC,IAAIpB,KAAKN,UAAUe,GAAK,MAC7B,GAAIT,KAAKP,OAAOgB,EAAIH,EAAWG,GAAKT,KAAKP,OAAOgB,EAAIG,EAAWH,EAC3D,OAAO,OAiBX,GAbAI,EAAM,EAAMb,KAAKN,UAAUe,EAC3BK,GAAOR,EAAWG,EAAIT,KAAKP,OAAOgB,GAAKI,EACvCE,GAAOH,EAAWH,EAAIT,KAAKP,OAAOgB,GAAKI,EACnCE,KAASM,MACTN,EAAMM,KAENP,EAAMC,IACNC,EAAOF,EACPA,EAAMC,EACNA,EAAMC,GAEVC,EAAIE,KAAKJ,IAAID,EAAKG,GAClBC,EAAWC,KAAKL,IAAIC,EAAKG,GACrBD,EAAIC,EACJ,OAAO,EAGf,GAAIC,KAAKC,IAAIpB,KAAKN,UAAUgB,GAAK,MAC7B,GAAIV,KAAKP,OAAOiB,EAAIJ,EAAWI,GAAKV,KAAKP,OAAOiB,EAAIE,EAAWF,EAC3D,OAAO,OAiBX,GAbAG,EAAM,EAAMb,KAAKN,UAAUgB,EAC3BI,GAAOR,EAAWI,EAAIV,KAAKP,OAAOiB,GAAKG,EACvCE,GAAOH,EAAWF,EAAIV,KAAKP,OAAOiB,GAAKG,EACnCE,KAASM,MACTN,EAAMM,KAENP,EAAMC,IACNC,EAAOF,EACPA,EAAMC,EACNA,EAAMC,GAEVC,EAAIE,KAAKJ,IAAID,EAAKG,GAClBC,EAAWC,KAAKL,IAAIC,EAAKG,GACrBD,EAAIC,EACJ,OAAO,EAGf,GAAIC,KAAKC,IAAIpB,KAAKN,UAAUiB,GAAK,MAC7B,GAAIX,KAAKP,OAAOkB,EAAIL,EAAWK,GAAKX,KAAKP,OAAOkB,EAAIC,EAAWD,EAC3D,OAAO,OAiBX,GAbAE,EAAM,EAAMb,KAAKN,UAAUiB,EAC3BG,GAAOR,EAAWK,EAAIX,KAAKP,OAAOkB,GAAKE,EACvCE,GAAOH,EAAWD,EAAIX,KAAKP,OAAOkB,GAAKE,EACnCE,KAASM,MACTN,EAAMM,KAENP,EAAMC,IACNC,EAAOF,EACPA,EAAMC,EACNA,EAAMC,GAEVC,EAAIE,KAAKJ,IAAID,EAAKG,GAClBC,EAAWC,KAAKL,IAAIC,EAAKG,GACrBD,EAAIC,EACJ,OAAO,EAGf,OAAO,CACf,CAQI,aAAAI,CAAcC,EAAKlB,EAAuB,GACtC,OAAOL,KAAKE,oBAAoBqB,EAAIpB,QAASoB,EAAInB,QAASC,EAClE,CAOI,gBAAAmB,CAAiBC,EAAQpB,EAAuB,GAC5C,MAAMI,EAAIgB,EAAOC,OAAOjB,EAAIT,KAAKP,OAAOgB,EAClCC,EAAIe,EAAOC,OAAOhB,EAAIV,KAAKP,OAAOiB,EAClCC,EAAIc,EAAOC,OAAOf,EAAIX,KAAKP,OAAOkB,EAClCgB,EAAOlB,EAAIA,EAAIC,EAAIA,EAAIC,EAAIA,EAC3BiB,EAASH,EAAOG,OAASvB,EACzBwB,EAAKD,EAASA,EACpB,GAAID,GAAQE,EACR,OAAO,EAEX,MAAMC,EAAMrB,EAAIT,KAAKN,UAAUe,EAAIC,EAAIV,KAAKN,UAAUgB,EAAIC,EAAIX,KAAKN,UAAUiB,EAC7E,GAAImB,EAAM,EACN,OAAO,EAGX,OADaH,EAAOG,EAAMA,GACXD,CACvB,CAQI,kBAAAE,CAAmBC,EAASC,EAASC,GACjC,MAAMC,EAAQ5C,EAAIgB,YAAY,GACxB6B,EAAQ7C,EAAIgB,YAAY,GACxB8B,EAAO9C,EAAIgB,YAAY,GACvB+B,EAAO/C,EAAIgB,YAAY,GACvBgC,EAAOhD,EAAIgB,YAAY,GAC7B0B,EAAQO,cAAcR,EAASG,GAC/BD,EAAQM,cAAcR,EAASI,GAC/BK,EAAQC,WAAW1C,KAAKN,UAAW0C,EAAOC,GAC1C,MAAMM,EAAMF,EAAQG,IAAIT,EAAOE,GAC/B,GAAY,IAARM,EACA,OAAO,KAEX,MAAME,EAAS,EAAIF,EACnB3C,KAAKP,OAAO+C,cAAcR,EAASM,GACnC,MAAMQ,EAAKL,EAAQG,IAAIN,EAAMD,GAAQQ,EACrC,GAAIC,GAAM9C,KAAKF,SAAWgD,EAAK,EAAM9C,KAAKF,QACtC,OAAO,KAEX2C,EAAQC,WAAWJ,EAAMH,EAAOI,GAChC,MAAMQ,EAAKN,EAAQG,IAAI5C,KAAKN,UAAW6C,GAAQM,EAC/C,GAAIE,GAAM/C,KAAKF,SAAWgD,EAAKC,EAAK,EAAM/C,KAAKF,QAC3C,OAAO,KAGX,MAAMkD,EAAWP,EAAQG,IAAIR,EAAOG,GAAQM,EAC5C,OAAIG,EAAWhD,KAAKL,OACT,KAEJ,IAAIsD,EAAiB,EAAIH,EAAKC,EAAID,EAAIE,EACrD,CAMI,eAAAE,CAAgBC,GACZ,IAAIH,EACJ,MAAMI,EAAUX,EAAQG,IAAIO,EAAME,OAAQrD,KAAKN,WAC/C,GAAIyB,KAAKC,IAAIgC,GAAW,oBACpB,OAAO,KAEN,CACD,MAAME,EAAUb,EAAQG,IAAIO,EAAME,OAAQrD,KAAKP,QAE/C,OADAuD,IAAaG,EAAMlC,EAAIqC,GAAWF,EAC9BJ,EAAW,EACPA,GAAY,oBACL,KAGA,EAGRA,CACnB,CACA,CAOI,cAAAO,CAAeC,EAAMC,EAAS,GAC1B,OAAQD,GACJ,IAAK,IAAK,CACN,MAAME,GAAK1D,KAAKP,OAAOiB,EAAI+C,GAAUzD,KAAKN,UAAUgB,EACpD,OAAIgD,EAAI,EACG,KAEJ,IAAIjB,EAAQzC,KAAKP,OAAOgB,EAAIT,KAAKN,UAAUe,GAAKiD,EAAGD,EAAQzD,KAAKP,OAAOkB,EAAIX,KAAKN,UAAUiB,GAAK+C,EACtH,CACY,IAAK,IAAK,CACN,MAAMA,GAAK1D,KAAKP,OAAOgB,EAAIgD,GAAUzD,KAAKN,UAAUe,EACpD,OAAIiD,EAAI,EACG,KAEJ,IAAIjB,EAAQgB,EAAQzD,KAAKP,OAAOiB,EAAIV,KAAKN,UAAUgB,GAAKgD,EAAG1D,KAAKP,OAAOkB,EAAIX,KAAKN,UAAUiB,GAAK+C,EACtH,CACY,IAAK,IAAK,CACN,MAAMA,GAAK1D,KAAKP,OAAOkB,EAAI8C,GAAUzD,KAAKN,UAAUiB,EACpD,OAAI+C,EAAI,EACG,KAEJ,IAAIjB,EAAQzC,KAAKP,OAAOgB,EAAIT,KAAKN,UAAUe,GAAKiD,EAAG1D,KAAKP,OAAOiB,EAAIV,KAAKN,UAAUgB,GAAKgD,EAAGD,EACjH,CACY,QACI,OAAO,KAEvB,CAYI,cAAAE,CAAeC,EAAMC,EAAWC,EAAmBC,GAAmB,EAAOC,EAAYC,GAAmB,GACxG,MAAMC,EAAKC,EAAWC,OAAO,GAQ7B,OAPAR,EAAKS,iBAAiBC,YAAYJ,GAC9BlE,KAAKuE,QACLhF,EAAIiF,eAAexE,KAAMkE,EAAIlE,KAAKuE,SAGlCvE,KAAKuE,QAAUhF,EAAIkF,UAAUzE,KAAMkE,GAEhCN,EAAKc,WAAW1E,KAAKuE,QAASV,EAAWC,EAAmBC,EAAkBC,EAAYC,EACzG,CAQI,gBAAAU,CAAiBC,EAAQf,EAAWgB,GAC5BA,EACAA,EAAQlF,OAAS,EAGjBkF,EAAU,GAEd,IAAK,IAAIC,EAAI,EAAGA,EAAIF,EAAOjF,OAAQmF,IAAK,CACpC,MAAMC,EAAW/E,KAAK2D,eAAeiB,EAAOE,GAAIjB,GAC5CkB,EAASC,KACTH,EAAQI,KAAKF,EAE7B,CAEQ,OADAF,EAAQK,KAAKlF,KAAKmF,qBACXN,CACf,CACI,mBAAAM,CAAoBC,EAAcC,GAC9B,OAAID,EAAapC,SAAWqC,EAAarC,UAC7B,EAEHoC,EAAapC,SAAWqC,EAAarC,SACnC,EAGA,CAEnB,CAQI,mBAAAsC,CAAoBC,EAAMC,EAAMC,GAC5B,MAAMC,EAAI1F,KAAKP,OACTkG,EAAIxB,EAAW1B,QAAQ,GACvBmD,EAAQzB,EAAW1B,QAAQ,GAC3BoD,EAAI1B,EAAW1B,QAAQ,GACvBqD,EAAI3B,EAAW1B,QAAQ,GAC7B+C,EAAKhD,cAAc+C,EAAMI,GACzB3F,KAAKN,UAAUqG,WAAWxG,EAAIyG,MAAOH,GACrCH,EAAEO,SAASJ,EAAGD,GACdL,EAAK/C,cAAckD,EAAGI,GACtB,MAAMI,EAAIzD,EAAQG,IAAI+C,EAAGA,GACnBQ,EAAI1D,EAAQG,IAAI+C,EAAGE,GACnBO,EAAI3D,EAAQG,IAAIiD,EAAGA,GACnB5E,EAAIwB,EAAQG,IAAI+C,EAAGG,GACnBO,EAAI5D,EAAQG,IAAIiD,EAAGC,GACnBQ,EAAIJ,EAAIE,EAAID,EAAIA,EACtB,IAAII,EACAC,EADIC,EAAKH,EACLI,EAAKJ,EAETA,EAAI/G,EAAIoH,WAERJ,EAAK,EACLE,EAAK,EACLD,EAAKH,EACLK,EAAKN,IAILG,EAAKJ,EAAIE,EAAID,EAAInF,EACjBuF,EAAKN,EAAIG,EAAIF,EAAIlF,EACbsF,EAAK,GAELA,EAAK,EACLC,EAAKH,EACLK,EAAKN,GAEAG,EAAKE,IAEVF,EAAKE,EACLD,EAAKH,EAAIF,EACTO,EAAKN,IAGTI,EAAK,GAELA,EAAK,GAEAvF,EAAI,EACLsF,EAAK,GAECtF,EAAIiF,EACVK,EAAKE,GAGLF,GAAMtF,EACNwF,EAAKP,IAGJM,EAAKE,IAEVF,EAAKE,GAEAzF,EAAIkF,EAAI,EACTI,EAAK,GAECtF,EAAIkF,EAAID,EACdK,EAAKE,GAGLF,GAAMtF,EAAIkF,EACVM,EAAKP,IAIb,MAAMU,EAAKzF,KAAKC,IAAImF,GAAMhH,EAAIoH,UAAY,EAAMJ,EAAKE,EAC/CI,EAAK1F,KAAKC,IAAIoF,GAAMjH,EAAIoH,UAAY,EAAMH,EAAKE,EAE/CI,EAAM3C,EAAW1B,QAAQ,GAC/BoD,EAAEE,WAAWc,EAAIC,GACjB,MAAMC,EAAM5C,EAAW1B,QAAQ,GAC/BkD,EAAEI,WAAWa,EAAIG,GACjBA,EAAIC,WAAWlB,GACf,MAAMmB,EAAK9C,EAAW1B,QAAQ,GAC9BsE,EAAIvE,cAAcsE,EAAKG,GAEvB,OADsBJ,EAAK,GAAKA,GAAM7G,KAAKL,QAAUsH,EAAGC,gBAAkBzB,EAAYA,EAE3EsB,EAAIpH,UAEP,CAChB,CAaI,MAAAwH,CAAO1G,EAAGC,EAAG0G,EAAeC,EAAgBC,EAAOC,EAAMC,EAAYC,GAAuB,GACxF,GAAIA,EAAsB,CAMjBlI,EAAImI,cACLnI,EAAImI,YAAcnI,EAAIoI,QAE1BpI,EAAImI,YAAYE,kBAAkBnH,EAAGC,EAAG0G,EAAeC,EAAgBjD,EAAOyD,iBAAkBN,EAAMC,GACtG,MAAMtD,EAAKC,EAAWC,OAAO,GAC7BkD,EAAMhD,YAAYJ,GAClB3E,EAAIiF,eAAejF,EAAImI,YAAaxD,EAAIlE,KACpD,MAEYA,KAAK4H,kBAAkBnH,EAAGC,EAAG0G,EAAeC,EAAgBC,EAAOC,EAAMC,GAE7E,OAAOxH,IACf,CAMI,WAAO2H,GACH,OAAO,IAAIpI,EAAIkD,EAAQkF,OAAQlF,EAAQkF,OAC/C,CAYI,gBAAOG,CAAUrH,EAAGC,EAAG0G,EAAeC,EAAgBC,EAAOC,EAAMC,GAE/D,OADejI,EAAIoI,OACLR,OAAO1G,EAAGC,EAAG0G,EAAeC,EAAgBC,EAAOC,EAAMC,EAC/E,CASI,sBAAOO,CAAgBtI,EAAQuI,EAAKV,EAAQlD,EAAOyD,kBAC/C,MAAMI,EAAS,IAAI1I,EAAI,IAAIkD,EAAQ,EAAG,EAAG,GAAI,IAAIA,EAAQ,EAAG,EAAG,IAC/D,OAAOlD,EAAI2I,kBAAkBzI,EAAQuI,EAAKC,EAAQX,EAC1D,CAUI,wBAAOY,CAAkBzI,EAAQuI,EAAKC,EAAQX,EAAQlD,EAAOyD,kBACzDI,EAAOxI,OAAO0I,SAAS1I,GACvB,MAAMC,EAAYsI,EAAIxF,cAAc/C,EAAQwI,EAAOvI,WAC7CC,EAASwB,KAAKiH,KAAK1I,EAAUe,EAAIf,EAAUe,EAAIf,EAAUgB,EAAIhB,EAAUgB,EAAIhB,EAAUiB,EAAIjB,EAAUiB,GAGzG,OAFAsH,EAAOtI,OAASA,EAChBsI,EAAOvI,UAAU2I,YACV9I,EAAIiF,eAAeyD,EAAQX,EAAOW,EACjD,CAOI,gBAAOxD,CAAU6D,EAAKC,GAClB,MAAMN,EAAS,IAAI1I,EAAI,IAAIkD,EAAQ,EAAG,EAAG,GAAI,IAAIA,EAAQ,EAAG,EAAG,IAE/D,OADAlD,EAAIiF,eAAe8D,EAAKC,EAAQN,GACzBA,CACf,CAQI,qBAAOzD,CAAe8D,EAAKC,EAAQN,GAC/BxF,EAAQ+F,0BAA0BF,EAAI7I,OAAQ8I,EAAQN,EAAOxI,QAC7DgD,EAAQgG,qBAAqBH,EAAI5I,UAAW6I,EAAQN,EAAOvI,WAC3DuI,EAAOtI,OAAS2I,EAAI3I,OACpBsI,EAAOnI,QAAUwI,EAAIxI,QACrB,MAAM4I,EAAMT,EAAOvI,UACbiJ,EAAMD,EAAI/I,SAChB,GAAc,IAARgJ,GAAqB,IAARA,EAAY,CAC3B,MAAMC,EAAM,EAAMD,EAClBD,EAAIjI,GAAKmI,EACTF,EAAIhI,GAAKkI,EACTF,EAAI/H,GAAKiI,EACTX,EAAOtI,QAAUgJ,CAC7B,CACQ,OAAOV,CACf,CAWI,iBAAAL,CAAkBiB,EAASC,EAAS1B,EAAeC,EAAgBC,EAAOC,EAAMC,GAC5E,MAAMe,EAASpE,EAAWC,OAAO,GACjCkD,EAAMyB,cAAcxB,EAAMgB,GAC1BA,EAAOQ,cAAcvB,EAAYe,GACjCA,EAAOS,SACP,MAAMC,EAASC,EAAYC,kBACrBC,EAAmBjF,EAAW1B,QAAQ,GAC5C2G,EAAiB3I,EAAKoI,EAAUzB,EAAiB,EAAI,EACrDgC,EAAiB1I,IAAOoI,EAAUzB,EAAkB,EAAI,GACxD+B,EAAiBzI,EAAIsI,GAAQI,sBAAwB,EAAIJ,GAAQK,gBAAkB,GAAK,EAExF,MAAMC,EAAkBpF,EAAW1B,QAAQ,GAAGjC,eAAe4I,EAAiB3I,EAAG2I,EAAiB1I,EAAG,EAAM,MACrG8I,EAAWrF,EAAW1B,QAAQ,GAC9BgH,EAAUtF,EAAW1B,QAAQ,GACnCA,EAAQiH,kCAAkCN,EAAkBb,EAAQiB,GACpE/G,EAAQiH,kCAAkCH,EAAiBhB,EAAQkB,GACnEzJ,KAAKP,OAAO0I,SAASqB,GACrBC,EAAQjH,cAAcgH,EAAUxJ,KAAKN,WACrCM,KAAKN,UAAU2I,WACvB,EAgBO,SAASsB,EAAiBC,EAAOnJ,EAAGC,EAAG4G,EAAOuC,EAAQC,GAAkB,GAC3E,MAAM7B,EAAS1I,EAAIoI,OAEnB,OADAoC,EAAsBH,EAAOnJ,EAAGC,EAAG4G,EAAOW,EAAQ4B,EAAQC,GACnD7B,CACX,CAaO,SAAS8B,EAAsBH,EAAOnJ,EAAGC,EAAG4G,EAAOW,EAAQ4B,EAAQC,GAAkB,EAAOrC,GAAuB,GACtH,MAAMwB,EAASW,EAAMI,YACrB,IAAKH,KAAYA,EAASD,EAAMK,cAC5B,OAAOL,EAEX,MAAMM,EAAiBL,EAAOM,SACxBC,EAAenB,EAAOoB,mBACpB5J,EAAG6J,EAAI5J,EAAG6J,EAAEC,MAAEA,EAAKC,OAAEA,GAAWP,EAAeQ,SAASzB,EAAO0B,iBAAkBP,GAEnFQ,EAAW,EAAI3B,EAAO4B,0BAI5B,OAHApK,EAAIA,EAAImK,EAAWN,EACnB5J,EAAIA,EAAIkK,GAAYR,EAAeG,EAAKE,GACxCxC,EAAOd,OAAO1G,EAAGC,EAAG8J,EAAOC,EAAQnD,GAAgBlD,EAAOyD,iBAAkBiC,EAAkB1F,EAAOyD,iBAAmBgC,EAAOiB,gBAAiBjB,EAAOkB,sBAAuBtD,GACvKmC,CACX,CASO,SAASoB,EAA8BpB,EAAOnJ,EAAGC,EAAGmJ,GACvD,MAAM5B,EAAS1I,EAAIoI,OAEnB,OADAsD,EAAmCrB,EAAOnJ,EAAGC,EAAGuH,EAAQ4B,GACjD5B,CACX,CAUO,SAASgD,EAAmCrB,EAAOnJ,EAAGC,EAAGuH,EAAQ4B,GACpE,IAAKqB,EACD,OAAOtB,EAEX,MAAMX,EAASW,EAAMI,YACrB,IAAKH,KAAYA,EAASD,EAAMK,cAC5B,MAAM,IAAIkB,MAAM,yBAEpB,MAAMjB,EAAiBL,EAAOM,SACxBC,EAAenB,EAAOoB,mBACpB5J,EAAG6J,EAAI5J,EAAG6J,EAAEC,MAAEA,EAAKC,OAAEA,GAAWP,EAAeQ,SAASzB,EAAO0B,iBAAkBP,GACnFgB,EAAWhH,EAAOiH,WAElBT,EAAW,EAAI3B,EAAO4B,0BAI5B,OAHApK,EAAIA,EAAImK,EAAWN,EACnB5J,EAAIA,EAAIkK,GAAYR,EAAeG,EAAKE,GACxCxC,EAAOd,OAAO1G,EAAGC,EAAG8J,EAAOC,EAAQW,EAAUA,EAAUvB,EAAOkB,uBACvDnB,CACX,CACA,SAAS0B,EAAoBC,EAAaC,EAAa5H,EAAM0D,EAAOzD,EAAWE,EAAkBD,EAAmBG,GAChH,MAAMqE,EAAMkD,EAAYlE,EAAO1D,EAAK6D,sBAC9BQ,EAASrE,EAAKc,WAAW4D,EAAKzE,EAAWC,EAAmBC,EAAkBuD,EAAOrD,GAC3F,OAAKgE,GAAWA,EAAOjD,KAGlBnB,GAA4B,MAAf0H,GAAuBtD,EAAOjF,UAAYuI,EAAYvI,SAC7D,KAEJiF,EALI,IAMf,CACA,SAASwD,EAAa7B,EAAO4B,EAAaE,EAAW7H,EAAWE,EAAkBD,GAC9E,IAAIyH,EAAc,KAClB,MAAMI,KAAiC/B,EAAMgC,eAAiBhC,EAAMgC,cAAcjM,OAAS,GAAKiK,EAAMiC,yBAA2BjC,EAAMK,cACjI6B,EAAgBlC,EAAMiC,wBAA0BjC,EAAMK,aACtD8B,EAAuDT,EAC7D,IAAK,IAAIU,EAAY,EAAGA,EAAYpC,EAAMhF,OAAOjF,OAAQqM,IAAa,CAClE,MAAMpI,EAAOgG,EAAMhF,OAAOoH,GAC1B,GAAIN,GACA,IAAKA,EAAU9H,GAAO,GAClB,cAGH,IAAKA,EAAKqI,cAAgBrI,EAAKsI,YAActI,EAAKuI,WACnD,SAEJ,MAAMC,EAAeT,GAA+B/H,EAAKyI,+BACnD/E,EAAQ1D,EAAK0I,mBAAmBF,EAAcN,GACpD,GAAIlI,EAAK2I,kBAAoB3I,EAAK4I,0BAA2B,CAEzD,MAAMvE,EAAS8D,EAAOR,EAAaC,EAAa5H,EAAM0D,GAAO,GAAM,EAAMxD,GACzE,GAAImE,EAAQ,CACR,GAAIlE,EAEA,OAAOkE,EAEX,MAAMwE,EAAYtI,EAAWC,OAAO,GAC9BsI,EAAe9I,EAAK+I,+BAC1B,IAAK,IAAIC,EAAQ,EAAGA,EAAQF,EAAa/M,OAAQiN,IAAS,CACtD,GAAIlB,IAAcA,EAAU9H,EAAMgJ,GAC9B,SAEeF,EAAaE,GACrB7D,cAAczB,EAAOmF,GAChC,MAAMxE,EAAS8D,EAAOR,EAAaC,EAAa5H,EAAM6I,EAAW5I,EAAWE,EAAkBD,GAAmB,GACjH,GAAImE,IACAsD,EAActD,EACdsD,EAAYsB,kBAAoBD,EAC5B/I,GACA,OAAO0H,CAGnC,CACA,CACA,KACa,CACD,MAAMtD,EAAS8D,EAAOR,EAAaC,EAAa5H,EAAM0D,EAAOzD,EAAWE,EAAkBD,GAC1F,GAAImE,IACAsD,EAActD,EACVpE,GACA,OAAO0H,CAG3B,CACA,CACI,OAAOA,GAAe,IAAIL,CAC9B,CACA,SAAS4B,EAAkBlD,EAAO4B,EAAaE,EAAW5H,GACtD,IAAKoH,EACD,OAAO,KAEX,MAAM6B,EAAe,GACfpB,KAAiC/B,EAAMgC,eAAiBhC,EAAMgC,cAAcjM,OAAS,GAAKiK,EAAMiC,yBAA2BjC,EAAMK,cACjI6B,EAAgBlC,EAAMiC,wBAA0BjC,EAAMK,aACtD8B,EAAuDT,EAC7D,IAAK,IAAIU,EAAY,EAAGA,EAAYpC,EAAMhF,OAAOjF,OAAQqM,IAAa,CAClE,MAAMpI,EAAOgG,EAAMhF,OAAOoH,GAC1B,GAAIN,GACA,IAAKA,EAAU9H,GAAO,GAClB,cAGH,IAAKA,EAAKqI,cAAgBrI,EAAKsI,YAActI,EAAKuI,WACnD,SAEJ,MAAMC,EAAeT,GAA+B/H,EAAKyI,+BACnD/E,EAAQ1D,EAAK0I,mBAAmBF,EAAcN,GACpD,GAAIlI,EAAK2I,kBAAoB3I,EAAK4I,0BAA2B,CAEzD,GADeT,EAAO,KAAMP,EAAa5H,EAAM0D,GAAO,GAAM,EAAMxD,GACtD,CACR,MAAM2I,EAAYtI,EAAWC,OAAO,GAC9BsI,EAAe9I,EAAK+I,+BAC1B,IAAK,IAAIC,EAAQ,EAAGA,EAAQF,EAAa/M,OAAQiN,IAAS,CACtD,GAAIlB,IAAcA,EAAU9H,EAAMgJ,GAC9B,SAEeF,EAAaE,GACrB7D,cAAczB,EAAOmF,GAChC,MAAMxE,EAAS8D,EAAO,KAAMP,EAAa5H,EAAM6I,GAAW,GAAO,EAAO3I,GAAmB,GACvFmE,IACAA,EAAO4E,kBAAoBD,EAC3BG,EAAa9H,KAAKgD,GAE1C,CACA,CACA,KACa,CACD,MAAMA,EAAS8D,EAAO,KAAMP,EAAa5H,EAAM0D,GAAO,GAAO,EAAOxD,GAChEmE,GACA8E,EAAa9H,KAAKgD,EAElC,CACA,CACI,OAAO8E,CACX,CAUO,SAASC,EAAqBpD,EAAOnJ,EAAGC,EAAGgL,EAAW7H,EAAWgG,GACpE,IAAKqB,EACD,OAAO,KAEX,MAAMjD,EAASwD,EAAa7B,GAAQtC,IAC3BsC,EAAMqD,kBACPrD,EAAMqD,gBAAkB1N,EAAIoI,QAEhCoC,EAAsBH,EAAOnJ,EAAGC,EAAG4G,EAAOsC,EAAMqD,gBAAiBpD,GAAU,MACpED,EAAMqD,kBACdvB,EAAW7H,GAAW,GAIzB,OAHIoE,IACAA,EAAOK,IAAMqB,EAAiBC,EAAOnJ,EAAGC,EAAG0D,EAAOiH,WAAYxB,GAAU,OAErE5B,CACX,CAYO,SAASiF,EAAKtD,EAAOnJ,EAAGC,EAAGgL,EAAW7H,EAAWgG,EAAQ/F,EAAmBqJ,GAAwB,GACvG,MAAMlF,EAASwD,EAAa7B,GAAO,CAACtC,EAAOG,KAClCmC,EAAMqD,kBACPrD,EAAMqD,gBAAkB1N,EAAIoI,QAEhCoC,EAAsBH,EAAOnJ,EAAGC,EAAG4G,EAAOsC,EAAMqD,gBAAiBpD,GAAU,MAAM,EAAOpC,GACjFmC,EAAMqD,kBACdvB,EAAW7H,GAAW,EAAOC,GAIhC,OAHImE,IACAA,EAAOK,IAAMqB,EAAiBC,EAAOnJ,EAAGC,EAAG0D,EAAOiH,WAAYxB,GAAU,OAErE5B,CACX,CAWO,SAASmF,EAAYxD,EAAOtB,EAAKoD,EAAW7H,EAAWC,GAC1D,MAAMmE,EAASwD,EAAa7B,GAAQtC,IAC3BsC,EAAMyD,4BACPzD,EAAMyD,0BAA4BjJ,EAAOiH,YAE7C/D,EAAMhD,YAAYsF,EAAMyD,2BACnBzD,EAAM0D,yBACP1D,EAAM0D,uBAAyB/N,EAAIoI,QAEvCpI,EAAIiF,eAAe8D,EAAKsB,EAAMyD,0BAA2BzD,EAAM0D,wBACxD1D,EAAM0D,yBACd5B,EAAW7H,GAAW,EAAOC,GAIhC,OAHImE,IACAA,EAAOK,IAAMA,GAEVL,CACX,CAYO,SAASsF,EAAU3D,EAAOnJ,EAAGC,EAAGgL,EAAW7B,EAAQ/F,GACtD,OAAOgJ,EAAkBlD,GAAQtC,GAAUqC,EAAiBC,EAAOnJ,EAAGC,EAAG4G,EAAOuC,GAAU,OAAO6B,EAAW5H,EAChH,CASO,SAAS0J,EAAiB5D,EAAOtB,EAAKoD,EAAW5H,GACpD,OAAOgJ,EAAkBlD,GAAQtC,IACxBsC,EAAMyD,4BACPzD,EAAMyD,0BAA4BjJ,EAAOiH,YAE7C/D,EAAMhD,YAAYsF,EAAMyD,2BACnBzD,EAAM0D,yBACP1D,EAAM0D,uBAAyB/N,EAAIoI,QAEvCpI,EAAIiF,eAAe8D,EAAKsB,EAAMyD,0BAA2BzD,EAAM0D,wBACxD1D,EAAM0D,yBACd5B,EAAW5H,EAClB,CAqBO,SAAS2J,EAAmB5D,EAAQ6D,EAAQ/N,EAAS,IAAKgO,EAAWlO,GACnEkO,IACDA,EAAY9D,EAAOxF,kBAEvBqJ,EAAO/N,OAASA,EACZF,EACAiO,EAAOjO,OAAO0I,SAAS1I,GAGvBiO,EAAOjO,OAAO0I,SAAS0B,EAAO+D,UAElC,MAAMC,EAAU1J,EAAW1B,QAAQ,GACnCoL,EAAQC,IAAI,EAAG,EAAGjE,EAAOkE,OAAOC,sBAAwB,EAAI,GAC5D,MAAMC,EAAe9J,EAAW1B,QAAQ,GAGxC,OAFAA,EAAQgG,qBAAqBoF,EAASF,EAAWM,GACjDxL,EAAQyL,eAAeD,EAAcP,EAAOhO,WACrCgO,CACX,CAMO,SAASS,EAAiBC,EAAYC,GACrCA,IACAA,EAAYC,UAAUC,cAAgB,SAAU5O,EAAS,IAAKgO,EAAWlO,GACrE,OAAOgO,EAAmBzN,KAAM,IAAIT,EAAIkD,EAAQkF,OAAQlF,EAAQkF,OAAQhI,GAASA,EAAQgO,EAAWlO,EACvG,EACD4O,EAAYC,UAAUE,mBAAqB,SAAUd,EAAQ/N,EAAS,IAAKgO,EAAWlO,GAClF,OAAOgO,EAAmBzN,KAAM0N,EAAQ/N,EAAQgO,EAAWlO,EAC9D,GAEA2O,IAGLK,EAAcC,qBAAsB,EACpCN,EAAWE,UAAUK,iBAAmB,SAAUlO,EAAGC,EAAG4G,EAAOuC,EAAQC,GAAkB,GACrF,OAAOH,EAAiB3J,KAAMS,EAAGC,EAAG4G,EAAOuC,EAAQC,EACtD,EACL,CApXAvK,EAAIgB,YAAcqO,EAAW,EAAGnM,EAAQkF,MACxCpI,EAAImI,YAAcnI,EAAIoI,OACtBpI,EAAIoH,UAAY,KAChBpH,EAAIyG,MAAQ,ICnjBZmI,EAAiBU,EAAOC,GACxBD,EAAMP,UAAUS,sBAAwB,SAAUtO,EAAGC,EAAG4G,EAAOW,EAAQ4B,EAAQC,GAAkB,EAAOrC,GAAuB,GAC3H,OAAOsC,EAAsB/J,KAAMS,EAAGC,EAAG4G,EAAOW,EAAQ4B,EAAQC,EAAiBrC,EACrF,EACAoH,EAAMP,UAAUU,8BAAgC,SAAUvO,EAAGC,EAAGmJ,GAC5D,OAAOmB,EAA8BhL,KAAMS,EAAGC,EAAGmJ,EACrD,EACAgF,EAAMP,UAAUW,mCAAqC,SAAUxO,EAAGC,EAAGuH,EAAQ4B,GACzE,OAAOoB,EAAmCjL,KAAMS,EAAGC,EAAGuH,EAAQ4B,EAClE,EACAgF,EAAMP,UAAUY,qBAAuB,SAAUzO,EAAGC,EAAGgL,EAAW7H,EAAWgG,GACzE,OAAOmD,EAAqBhN,KAAMS,EAAGC,EAAGgL,EAAW7H,EAAWgG,EAClE,EACAgF,EAAMP,UAAUa,KAAO,SAAU1O,EAAGC,EAAGgL,EAAW7H,EAAWgG,EAAQ/F,EAAmBqJ,GAAwB,GAC5G,OAAOD,EAAKlN,KAAMS,EAAGC,EAAGgL,EAAW7H,EAAWgG,EAAQ/F,EAAmBqJ,EAC7E,EACA0B,EAAMP,UAAUc,YAAc,SAAU9G,EAAKoD,EAAW7H,EAAWC,GAC/D,OAAOsJ,EAAYpN,KAAMsI,EAAKoD,EAAW7H,EAAWC,EACxD,EACA+K,EAAMP,UAAUe,UAAY,SAAU5O,EAAGC,EAAGgL,EAAW7B,EAAQ/F,GAC3D,OAAOyJ,EAAUvN,KAAMS,EAAGC,EAAGgL,EAAW7B,EAAQ/F,EACpD,EACA+K,EAAMP,UAAUgB,iBAAmB,SAAUhH,EAAKoD,EAAW5H,GACzD,OAAO0J,EAAiBxN,KAAMsI,EAAKoD,EAAW5H,EAClD"}