Options
All
  • Public
  • Public/Protected
  • All
Menu

Mirror texture can be used to simulate the view from a mirror in a scene. It will dynamically be rendered every frame to adapt to the camera point of view. You can then easily use it as a reflectionTexture on a flat surface. In case the surface is not a plane, please consider relying on reflection probes.

see

https://doc.babylonjs.com/features/featuresDeepDive/materials/using/reflectionTexture#mirrortexture

Hierarchy

Index

Constructors

Properties

Accessors

Methods

Constructors

  • new MirrorTexture(name: string, size: number | { height: number; width: number } | { ratio: number }, scene?: Scene, generateMipMaps?: boolean, type?: number, samplingMode?: number, generateDepthBuffer?: boolean): MirrorTexture
  • Instantiates a Mirror Texture. Mirror texture can be used to simulate the view from a mirror in a scene. It will dynamically be rendered every frame to adapt to the camera point of view. You can then easily use it as a reflectionTexture on a flat surface. In case the surface is not a plane, please consider relying on reflection probes.

    see

    https://doc.babylonjs.com/features/featuresDeepDive/materials/using/reflectionTexture#mirrors

    Parameters

    • name: string
    • size: number | { height: number; width: number } | { ratio: number }
    • Optional scene: Scene
    • Optional generateMipMaps: boolean
    • Optional type: number
    • Optional samplingMode: number
    • Optional generateDepthBuffer: boolean

    Returns MirrorTexture

Properties

activeCamera: Nullable<Camera>

Define the camera used to render the texture.

animations: Animation[]

Define the list of animation attached to the texture.

anisotropicFilteringLevel: number

With compliant hardware and browser (supporting anisotropic filtering) this defines the level of anisotropic filtering in the texture. The higher the better but the slower. This defaults to 4 as it seems to be the best tradeoff.

boundingBoxPosition: Vector3

Gets or sets the center of the bounding box associated with the texture (when in cube mode) It must define where the camera used to render the texture is set

clearColor: Color4

Define the clear color of the Render Target if it should be different from the scene.

customIsReadyFunction: ((mesh: AbstractMesh, refreshRate: number, preWarm?: boolean) => boolean)

Type declaration

    • (mesh: AbstractMesh, refreshRate: number, preWarm?: boolean): boolean
    • Override the mesh isReady function with your own one.

      Parameters

      • mesh: AbstractMesh
      • refreshRate: number
      • Optional preWarm: boolean

      Returns boolean

customRenderFunction: ((opaqueSubMeshes: SmartArray<SubMesh>, alphaTestSubMeshes: SmartArray<SubMesh>, transparentSubMeshes: SmartArray<SubMesh>, depthOnlySubMeshes: SmartArray<SubMesh>, beforeTransparents?: (() => void)) => void)

Type declaration

delayLoadState: number

Define the current state of the loading sequence when in delayed load mode.

getCustomRenderList: ((layerOrFace: number, renderList: Nullable<readonly AbstractMesh[]>, renderListLength: number) => Nullable<AbstractMesh[]>)

Type declaration

    • Use this function to overload the renderList array at rendering time. Return null to render with the current renderList, else return the list of meshes to use for rendering. For 2DArray RTT, layerOrFace is the index of the layer that is going to be rendered, else it is the faceIndex of the cube (if the RTT is a cube, else layerOrFace=0). The renderList passed to the function is the current render list (the one that will be used if the function returns null). The length of this list is passed through renderListLength: don't use renderList.length directly because the array can hold dummy elements!

      Parameters

      Returns Nullable<AbstractMesh[]>

homogeneousRotationInUVTransform: boolean

Sets this property to true to avoid deformations when rotating the texture with non-uniform scaling

ignoreCameraViewport: boolean

Define if the camera viewport should be respected while rendering the texture or if the render should be done to the entire texture.

inspectableCustomProperties: Nullable<IInspectable[]>

List of inspectable custom properties (used by the Inspector)

see

https://doc.babylonjs.com/toolsAndResources/inspector#extensibility

invertZ: boolean

Is Z inverted in the texture (useful in a cube texture).

isRenderTarget: boolean

Define if the texture is a render target.

level: number

Intensity or strength of the texture. It is commonly used by materials to fine tune the intensity of the texture

metadata: any

Gets or sets an object used to store user defined information.

mirrorPlane: Plane

Define the reflection plane we want to use. The mirrorPlane is usually set to the constructed reflector. It is possible to directly set the mirrorPlane by directly using a Plane(a, b, c, d) where a, b and c give the plane normal vector (a, b, c) and d is a scalar displacement from the mirrorPlane to the origin. However in all but the very simplest of situations it is more straight forward to set it to the reflector as stated in the doc.

see

https://doc.babylonjs.com/features/featuresDeepDive/materials/using/reflectionTexture#mirrors

name: string

Define the name of the texture.

onAfterRenderObservable: Observable<number>

An event triggered after rendering the texture

onAfterUnbindObservable: Observable<RenderTargetTexture>

An event triggered when the texture is unbind.

onBeforeBindObservable: Observable<RenderTargetTexture>

An event triggered when the texture is unbind.

onBeforeRenderObservable: Observable<number>

An event triggered before rendering the texture

onClearObservable: Observable<Engine>

An event triggered after the texture clear

onDisposeObservable: Observable<BaseTexture>

An event triggered when the texture is disposed.

onLoadObservable: Observable<Texture>

Observable triggered once the texture has been loaded.

onResizeObservable: Observable<RenderTargetTexture>

An event triggered when the texture is resized.

optimizeUVAllocation: boolean

Gets or sets a boolean indicating that the texture should try to reduce shader code if there is no UV manipulation. (ie. when texture.getTextureMatrix().isIdentityAs3x2() returns true)

renderListPredicate: ((AbstractMesh: AbstractMesh) => boolean)

Type declaration

    • Use this predicate to dynamically define the list of mesh you want to render. If set, the renderList property will be overwritten.

      Parameters

      Returns boolean

renderParticles: boolean

Define if particles should be rendered in your texture.

renderPassId: number

Current render pass id of the render target texture. Note it can change over the rendering as there's a separate id for each face of a cube / each layer of an array layer!

renderSprites: boolean

Define if sprites should be rendered in your texture.

reservedDataStore: any

For internal use only. Please do not use.

skipInitialClear: boolean

Skip the initial clear of the rtt at the beginning of the frame render loop

sphericalPolynomial: Nullable<SphericalPolynomial>

Get the polynomial representation of the texture data. This is mainly use as a fast way to recover IBL Diffuse irradiance data.

see

https://learnopengl.com/PBR/IBL/Diffuse-irradiance

uAng: number

Define an offset on the texture to rotate around the u coordinates of the UVs The angle is defined in radians.

see

https://doc.babylonjs.com/features/featuresDeepDive/materials/using/moreMaterials

uOffset: number

Define an offset on the texture to offset the u coordinates of the UVs

see

https://doc.babylonjs.com/features/featuresDeepDive/materials/using/moreMaterials#offsetting

uRotationCenter: number

Defines the center of rotation (U)

uScale: number

Define an offset on the texture to scale the u coordinates of the UVs

see

https://doc.babylonjs.com/features/featuresDeepDive/materials/using/moreMaterials#tiling

uniqueId: number

Gets or sets the unique id of the texture

url: Nullable<string>

Define the url of the texture.

useCameraPostProcesses: boolean

Define if camera post processes should be use while rendering the texture.

vAng: number

Define an offset on the texture to rotate around the v coordinates of the UVs The angle is defined in radians.

see

https://doc.babylonjs.com/features/featuresDeepDive/materials/using/moreMaterials

vOffset: number

Define an offset on the texture to offset the v coordinates of the UVs

see

https://doc.babylonjs.com/features/featuresDeepDive/materials/using/moreMaterials#offsetting

vRotationCenter: number

Defines the center of rotation (V)

vScale: number

Define an offset on the texture to scale the v coordinates of the UVs

see

https://doc.babylonjs.com/features/featuresDeepDive/materials/using/moreMaterials#tiling

wAng: number

Define an offset on the texture to rotate around the w coordinates of the UVs (in case of 3d texture) The angle is defined in radians.

see

https://doc.babylonjs.com/features/featuresDeepDive/materials/using/moreMaterials

wRotationCenter: number

Defines the center of rotation (W)

wrapR: number
ValueTypeDescription
0CLAMP_ADDRESSMODE
1WRAP_ADDRESSMODE
2MIRROR_ADDRESSMODE
BILINEAR_SAMPLINGMODE: 2 = 2

Bilinear is mag = linear and min = linear and mip = nearest

CLAMP_ADDRESSMODE: 0 = 0

Texture is not repeating outside of 0..1 UVs

CUBIC_MODE: 3 = 3

Cubic coordinates mode

DEFAULT_ANISOTROPIC_FILTERING_LEVEL: number

Default anisotropic filtering level for the application. It is set to 4 as a good tradeoff between perf and quality.

EQUIRECTANGULAR_MODE: 7 = 7

Equirectangular coordinates mode

EXPLICIT_MODE: 0 = 0

Explicit coordinates mode

FIXED_EQUIRECTANGULAR_MIRRORED_MODE: 9 = 9

Equirectangular Fixed Mirrored coordinates mode

FIXED_EQUIRECTANGULAR_MODE: 8 = 8

Equirectangular Fixed coordinates mode

ForceSerializeBuffers: boolean

Gets or sets a general boolean used to indicate that texture buffers must be saved as part of the serialization process. If no buffer exists, one will be created as base64 string from the internal webgl data.

INVCUBIC_MODE: 6 = 6

Inverse Cubic coordinates mode

LINEAR_LINEAR: 2 = 2

mag = linear and min = linear and mip = none

LINEAR_LINEAR_MIPLINEAR: 3 = 3

Trilinear is mag = linear and min = linear and mip = linear

LINEAR_LINEAR_MIPNEAREST: 11 = 11

Bilinear is mag = linear and min = linear and mip = nearest

LINEAR_NEAREST: 12 = 12

mag = linear and min = nearest and mip = none

LINEAR_NEAREST_MIPLINEAR: 10 = 10

mag = linear and min = nearest and mip = linear

LINEAR_NEAREST_MIPNEAREST: 9 = 9

mag = linear and min = nearest and mip = nearest

MIRROR_ADDRESSMODE: 2 = 2

Texture is repeating and mirrored

NEAREST_LINEAR: 7 = 7

mag = nearest and min = linear and mip = none

NEAREST_LINEAR_MIPLINEAR: 6 = 6

mag = nearest and min = linear and mip = linear

NEAREST_LINEAR_MIPNEAREST: 5 = 5

mag = nearest and min = linear and mip = nearest

NEAREST_NEAREST: 1 = 1

mag = nearest and min = nearest and mip = none

NEAREST_NEAREST_MIPLINEAR: 8 = 8

nearest is mag = nearest and min = nearest and mip = linear

NEAREST_NEAREST_MIPNEAREST: 4 = 4

mag = nearest and min = nearest and mip = nearest

NEAREST_SAMPLINGMODE: 1 = 1

nearest is mag = nearest and min = nearest and mip = linear

OnTextureLoadErrorObservable: Observable<BaseTexture>

This observable will notify when any texture had a loading error

PLANAR_MODE: 2 = 2

Planar coordinates mode

PROJECTION_MODE: 4 = 4

Projection coordinates mode

REFRESHRATE_RENDER_ONCE: number

The texture will only be rendered once which can be useful to improve performance if everything in your render is static for instance.

REFRESHRATE_RENDER_ONEVERYFRAME: number

The texture will only be rendered rendered every frame and is recommended for dynamic contents.

REFRESHRATE_RENDER_ONEVERYTWOFRAMES: number

The texture will be rendered every 2 frames which could be enough if your dynamic objects are not the central point of your effect and can save a lot of performances.

SKYBOX_MODE: 5 = 5

Inverse Cubic coordinates mode

SPHERICAL_MODE: 1 = 1

Spherical coordinates mode

SerializeBuffers: boolean

Gets or sets a general boolean used to indicate that textures containing direct data (buffers) must be saved as part of the serialization process

TRILINEAR_SAMPLINGMODE: 3 = 3

Trilinear is mag = linear and min = linear and mip = linear

UseSerializedUrlIfAny: boolean

Gets or sets a boolean which defines if the texture url must be build from the serialized URL instead of just using the name and loading them side by side with the scene file

WRAP_ADDRESSMODE: 1 = 1

Texture is repeating outside of 0..1 UVs

Accessors

  • set adaptiveBlurKernel(value: number): void
  • Define the adaptive blur kernel used to blur the reflection if needed. This will autocompute the closest best match for the blurKernel

    Parameters

    • value: number

    Returns void

  • set blurKernel(value: number): void
  • Define the blur kernel used to blur the reflection if needed. Please consider using adaptiveBlurKernel as it could find the closest best value for you.

    Parameters

    • value: number

    Returns void

  • get blurKernelX(): number
  • set blurKernelX(value: number): void
  • Define the blur kernel on the X Axis used to blur the reflection if needed. Please consider using adaptiveBlurKernel as it could find the closest best value for you.

    Returns number

  • Define the blur kernel on the X Axis used to blur the reflection if needed. Please consider using adaptiveBlurKernel as it could find the closest best value for you.

    Parameters

    • value: number

    Returns void

  • get blurKernelY(): number
  • set blurKernelY(value: number): void
  • Define the blur kernel on the Y Axis used to blur the reflection if needed. Please consider using adaptiveBlurKernel as it could find the closest best value for you.

    Returns number

  • Define the blur kernel on the Y Axis used to blur the reflection if needed. Please consider using adaptiveBlurKernel as it could find the closest best value for you.

    Parameters

    • value: number

    Returns void

  • get blurRatio(): number
  • set blurRatio(value: number): void
  • Define the blur ratio used to blur the reflection if needed.

    Returns number

  • Define the blur ratio used to blur the reflection if needed.

    Parameters

    • value: number

    Returns void

  • get boundingBoxSize(): Vector3
  • set boundingBoxSize(value: Vector3): void
  • get canRescale(): boolean
  • Get if the texture can be rescaled or not.

    Returns boolean

  • get coordinatesIndex(): number
  • set coordinatesIndex(value: number): void
  • Define the UV channel to use starting from 0 and defaulting to 0. This is part of the texture as textures usually maps to one uv set.

    Returns number

  • Define the UV channel to use starting from 0 and defaulting to 0. This is part of the texture as textures usually maps to one uv set.

    Parameters

    • value: number

    Returns void

  • get coordinatesMode(): number
  • set coordinatesMode(value: number): void
  • How a texture is mapped.

    ValueTypeDescription
    0EXPLICIT_MODE
    1SPHERICAL_MODE
    2PLANAR_MODE
    3CUBIC_MODE
    4PROJECTION_MODE
    5SKYBOX_MODE
    6INVCUBIC_MODE
    7EQUIRECTANGULAR_MODE
    8FIXED_EQUIRECTANGULAR_MODE
    9FIXED_EQUIRECTANGULAR_MIRRORED_MODE

    Returns number

  • How a texture is mapped.

    ValueTypeDescription
    0EXPLICIT_MODE
    1SPHERICAL_MODE
    2PLANAR_MODE
    3CUBIC_MODE
    4PROJECTION_MODE
    5SKYBOX_MODE
    6INVCUBIC_MODE
    7EQUIRECTANGULAR_MODE
    8FIXED_EQUIRECTANGULAR_MODE
    9FIXED_EQUIRECTANGULAR_MIRRORED_MODE

    Parameters

    • value: number

    Returns void

  • get currentRefreshId(): number
  • Gets the current value of the refreshId counter

    Returns number

  • In case the RTT has been created with a depth texture, get the associated depth texture. Otherwise, return null.

    Returns Nullable<InternalTexture>

  • get errorObject(): undefined | { exception?: any; message?: string }
  • If a loading error occurred this object will be populated with information about the error.

    Returns undefined | { exception?: any; message?: string }

  • get gammaSpace(): boolean
  • set gammaSpace(gamma: boolean): void
  • Define if the texture contains data in gamma space (most of the png/jpg aside bump). HDR texture are usually stored in linear space. This only impacts the PBR and Background materials

    Returns boolean

  • Define if the texture contains data in gamma space (most of the png/jpg aside bump). HDR texture are usually stored in linear space. This only impacts the PBR and Background materials

    Parameters

    • gamma: boolean

    Returns void

  • get getAlphaFromRGB(): boolean
  • set getAlphaFromRGB(value: boolean): void
  • Defines if the alpha value should be determined via the rgb values. If true the luminance of the pixel might be used to find the corresponding alpha value.

    Returns boolean

  • Defines if the alpha value should be determined via the rgb values. If true the luminance of the pixel might be used to find the corresponding alpha value.

    Parameters

    • value: boolean

    Returns void

  • get hasAlpha(): boolean
  • set hasAlpha(value: boolean): void
  • Define if the texture is having a usable alpha value (can be use for transparency or glossiness for instance).

    Returns boolean

  • Define if the texture is having a usable alpha value (can be use for transparency or glossiness for instance).

    Parameters

    • value: boolean

    Returns void

  • get invertY(): boolean
  • Gets a boolean indicating if the texture needs to be inverted on the y axis during loading

    Returns boolean

  • In case a better definition than spherical harmonics is required for the diffuse part of the environment. You can set the irradiance texture to rely on a texture instead of the spherical approach. This texture need to have the same characteristics than its parent (Cube vs 2d, coordinates mode, Gamma/Linear, RGBD).

    Returns Nullable<BaseTexture>

  • In case a better definition than spherical harmonics is required for the diffuse part of the environment. You can set the irradiance texture to rely on a texture instead of the spherical approach. This texture need to have the same characteristics than its parent (Cube vs 2d, coordinates mode, Gamma/Linear, RGBD).

    Parameters

    Returns void

  • get is2DArray(): boolean
  • set is2DArray(value: boolean): void
  • Define if the texture is a 2d array texture (webgl 2) or if false a 2d texture.

    Returns boolean

  • Define if the texture is a 2d array texture (webgl 2) or if false a 2d texture.

    Parameters

    • value: boolean

    Returns void

  • get is3D(): boolean
  • set is3D(value: boolean): void
  • Define if the texture is a 3d texture (webgl 2) or if false a 2d texture.

    Returns boolean

  • Define if the texture is a 3d texture (webgl 2) or if false a 2d texture.

    Parameters

    • value: boolean

    Returns void

  • get isBlocking(): boolean
  • set isBlocking(value: boolean): void
  • Is the texture preventing material to render while loading. If false, a default texture will be used instead of the loading one during the preparation step.

    Returns boolean

  • Is the texture preventing material to render while loading. If false, a default texture will be used instead of the loading one during the preparation step.

    Parameters

    • value: boolean

    Returns void

  • get isCube(): boolean
  • set isCube(value: boolean): void
  • Define if the texture is a cube texture or if false a 2d texture.

    Returns boolean

  • Define if the texture is a cube texture or if false a 2d texture.

    Parameters

    • value: boolean

    Returns void

  • get isRGBD(): boolean
  • set isRGBD(value: boolean): void
  • Gets or sets whether or not the texture contains RGBD data.

    Returns boolean

  • Gets or sets whether or not the texture contains RGBD data.

    Parameters

    • value: boolean

    Returns void

  • get linearSpecularLOD(): boolean
  • set linearSpecularLOD(value: boolean): void
  • With prefiltered texture, defined if the specular generation is based on a linear ramp. By default we are using a log2 of the linear roughness helping to keep a better resolution for average roughness values.

    Returns boolean

  • With prefiltered texture, defined if the specular generation is based on a linear ramp. By default we are using a log2 of the linear roughness helping to keep a better resolution for average roughness values.

    Parameters

    • value: boolean

    Returns void

  • get loadingError(): boolean
  • Was there any loading error?

    Returns boolean

  • get lodGenerationOffset(): number
  • set lodGenerationOffset(value: number): void
  • With prefiltered texture, defined the offset used during the prefiltering steps.

    Returns number

  • With prefiltered texture, defined the offset used during the prefiltering steps.

    Parameters

    • value: number

    Returns void

  • get lodGenerationScale(): number
  • set lodGenerationScale(value: number): void
  • With prefiltered texture, defined the scale used during the prefiltering steps.

    Returns number

  • With prefiltered texture, defined the scale used during the prefiltering steps.

    Parameters

    • value: number

    Returns void

  • get mimeType(): undefined | string
  • Returns the texture mime type if it was defined by a loader (undefined else)

    Returns undefined | string

  • get noMipmap(): boolean
  • Are mip maps generated for this texture or not.

    Returns boolean

  • set onAfterRender(callback: ((faceIndex: number) => void)): void
  • Set a after render callback in the texture. This has been kept for backward compatibility and use of onAfterRenderObservable is recommended.

    Parameters

    • callback: ((faceIndex: number) => void)
        • (faceIndex: number): void
        • Parameters

          • faceIndex: number

          Returns void

    Returns void

  • set onAfterUnbind(callback: (() => void)): void
  • Set a after unbind callback in the texture. This has been kept for backward compatibility and use of onAfterUnbindObservable is recommended.

    Parameters

    • callback: (() => void)
        • (): void
        • Returns void

    Returns void

  • set onBeforeRender(callback: ((faceIndex: number) => void)): void
  • Set a before render callback in the texture. This has been kept for backward compatibility and use of onBeforeRenderObservable is recommended.

    Parameters

    • callback: ((faceIndex: number) => void)
        • (faceIndex: number): void
        • Parameters

          • faceIndex: number

          Returns void

    Returns void

  • set onClear(callback: ((Engine: Engine) => void)): void
  • Set a clear callback in the texture. This has been kept for backward compatibility and use of onClearObservable is recommended.

    Parameters

    • callback: ((Engine: Engine) => void)

    Returns void

  • set onDispose(callback: (() => void)): void
  • Callback triggered when the texture has been disposed. Kept for back compatibility, you can use the onDisposeObservable instead.

    Parameters

    • callback: (() => void)
        • (): void
        • Returns void

    Returns void

  • Post-processes for this render target

    Returns PostProcess[]

  • get refreshRate(): number
  • set refreshRate(value: number): void
  • Define the refresh rate of the texture or the rendering frequency. Use 0 to render just once, 1 to render on every frame, 2 to render every two frames and so on...

    Returns number

  • Define the refresh rate of the texture or the rendering frequency. Use 0 to render just once, 1 to render on every frame, 2 to render every two frames and so on...

    Parameters

    • value: number

    Returns void

  • Use this list to define the list of mesh you want to render.

    Returns Nullable<AbstractMesh[]>

  • Use this list to define the list of mesh you want to render.

    Parameters

    Returns void

  • get renderPassIds(): readonly number[]
  • Gets the render pass ids used by the render target texture. For a single render target the array length will be 1, for a cube texture it will be 6 and for a 2D texture array it will return an array of ids the size of the 2D texture array

    Returns readonly number[]

  • Gets the render target wrapper associated with this render target

    Returns Nullable<RenderTargetWrapper>

  • Gets render target creation options that were used.

    Returns RenderTargetCreationOptions

  • get samples(): number
  • set samples(value: number): void
  • Define the number of samples to use in case of MSAA. It defaults to one meaning no MSAA has been enabled.

    Returns number

  • Define the number of samples to use in case of MSAA. It defaults to one meaning no MSAA has been enabled.

    Parameters

    • value: number

    Returns void

  • get samplingMode(): number
  • Get the current sampling mode associated with the texture.

    Returns number

  • get textureFormat(): number
  • Get the texture underlying format (RGB, RGBA...)

    Returns number

  • get textureType(): number
  • Get the texture underlying type (INT, FLOAT...)

    Returns number

  • get uid(): string
  • Define the unique id of the texture in the scene.

    Returns string

  • get wrapU(): number
  • set wrapU(value: number): void
  • ValueTypeDescription
    0CLAMP_ADDRESSMODE
    1WRAP_ADDRESSMODE
    2MIRROR_ADDRESSMODE

    Returns number

  • ValueTypeDescription
    0CLAMP_ADDRESSMODE
    1WRAP_ADDRESSMODE
    2MIRROR_ADDRESSMODE

    Parameters

    • value: number

    Returns void

  • get wrapV(): number
  • set wrapV(value: number): void
  • ValueTypeDescription
    0CLAMP_ADDRESSMODE
    1WRAP_ADDRESSMODE
    2MIRROR_ADDRESSMODE

    Returns number

  • ValueTypeDescription
    0CLAMP_ADDRESSMODE
    1WRAP_ADDRESSMODE
    2MIRROR_ADDRESSMODE

    Parameters

    • value: number

    Returns void

Methods

  • Adds a post process to the render target rendering passes.

    Parameters

    • postProcess: PostProcess

      define the post process to add

    Returns void

  • Checks if the texture has the same transform matrix than another texture

    Parameters

    Returns boolean

    true if the transforms are the same, else false

  • clearPostProcesses(dispose?: boolean): void
  • Clear all the post processes attached to the render target

    Parameters

    • Optional dispose: boolean

      define if the cleared post processes should also be disposed (false by default)

    Returns void

  • createDepthStencilTexture(comparisonFunction?: number, bilinearFiltering?: boolean, generateStencil?: boolean, samples?: number, format?: number): void
  • Creates a depth stencil texture. This is only available in WebGL 2 or with the depth texture extension available.

    Parameters

    • Optional comparisonFunction: number

      Specifies the comparison function to set on the texture. If 0 or undefined, the texture is not in comparison mode (default: 0)

    • Optional bilinearFiltering: boolean

      Specifies whether or not bilinear filtering is enable on the texture (default: true)

    • Optional generateStencil: boolean

      Specifies whether or not a stencil should be allocated in the texture (default: false)

    • Optional samples: number

      sample count of the depth/stencil texture (default: 1)

    • Optional format: number

      format of the depth texture (default: Constants.TEXTUREFORMAT_DEPTH32_FLOAT)

    Returns void

  • disableRescaling(): void
  • Don't allow this render target texture to rescale. Mainly used to prevent rescaling by the scene optimizer.

    Returns void

  • dispose(): void
  • Dispose the texture and release its associated resources.

    Returns void

  • disposeFramebufferObjects(): void
  • This will remove the attached framebuffer objects. The texture will not be able to be used as render target anymore

    Returns void

  • forceSphericalPolynomialsRecompute(): void
  • Force recomputation of spherical polynomials. Can be useful if you generate a cubemap multiple times (from a probe for eg) and you need the proper polynomials each time

    Returns void

  • freeRenderingGroups(): void
  • Clear the info related to rendering groups preventing retention point in material dispose.

    Returns void

  • Get the base size of the texture. It can be different from the size if the texture has been resized for POT for instance

    Returns ISize

    the base size

  • getClassName(): string
  • Get the current class name of the texture useful for serialization or dynamic coding.

    Returns string

    "Texture"

  • getReflectionTextureMatrix(): Matrix
  • getRenderHeight(): number
  • Gets the actual render height of the texture.

    Returns number

    the height of the render size

  • getRenderLayers(): number
  • Gets the actual number of layers of the texture.

    Returns number

    the number of layers

  • getRenderSize(): number
  • Gets the actual render size of the texture.

    Returns number

    the width of the render size

  • getRenderWidth(): number
  • Gets the actual render width of the texture.

    Returns number

    the width of the render size

  • getTextureMatrix(uBase?: number): Matrix
  • Get the current texture matrix which includes the requested offsetting, tiling and rotation components.

    Parameters

    • Optional uBase: number

    Returns Matrix

    the transform matrix of the texture.

  • getViewCount(): number
  • Gets the number of views the corresponding to the texture (eg. a MultiviewRenderTarget will have > 1)

    Returns number

    the view count

  • isReady(): boolean
  • Get if the texture is ready to be used (downloaded, converted, mip mapped...).

    Returns boolean

    true if fully ready

  • isReadyForRendering(): boolean
  • This function will check if the render target texture can be rendered (textures are loaded, shaders are compiled)

    Returns boolean

    true if all required resources are ready

  • isReadyOrNotBlocking(): boolean
  • Get if the texture is ready to be consumed (either it is ready or it is not blocking)

    Returns boolean

    true if ready, not blocking or if there was an error loading the texture

  • readPixels(faceIndex?: number, level?: number, buffer?: Nullable<ArrayBufferView>, flushRenderer?: boolean, noDataConversion?: boolean, x?: number, y?: number, width?: number, height?: number): Nullable<Promise<ArrayBufferView>>
  • Reads the pixels stored in the webgl texture and returns them as an ArrayBuffer. This will returns an RGBA array buffer containing either in values (0-255) or float values (0-1) depending of the underlying buffer type.

    Parameters

    • Optional faceIndex: number

      defines the face of the texture to read (in case of cube texture)

    • Optional level: number

      defines the LOD level of the texture to read (in case of Mip Maps)

    • Optional buffer: Nullable<ArrayBufferView>

      defines a user defined buffer to fill with data (can be null)

    • Optional flushRenderer: boolean

      true to flush the renderer from the pending commands before reading the pixels

    • Optional noDataConversion: boolean

      false to convert the data to Uint8Array (if texture type is UNSIGNED_BYTE) or to Float32Array (if texture type is anything but UNSIGNED_BYTE). If true, the type of the generated buffer (if buffer==null) will depend on the type of the texture

    • Optional x: number

      defines the region x coordinates to start reading from (default to 0)

    • Optional y: number

      defines the region y coordinates to start reading from (default to 0)

    • Optional width: number

      defines the region width to read from (default to the texture size at level)

    • Optional height: number

      defines the region width to read from (default to the texture size at level)

    Returns Nullable<Promise<ArrayBufferView>>

    The Array buffer promise containing the pixels data.

  • releaseInternalTexture(): void
  • Remove one of the post process from the list of attached post processes to the texture

    Parameters

    • postProcess: PostProcess

      define the post process to remove from the list

    Returns void

  • render(useCameraPostProcess?: boolean, dumpForDebug?: boolean): void
  • Renders all the objects from the render list into the texture.

    Parameters

    • Optional useCameraPostProcess: boolean

      Define if camera post processes should be used during the rendering

    • Optional dumpForDebug: boolean

      Define if the rendering result should be dumped (copied) for debugging purpose

    Returns void

  • resetRefreshCounter(): void
  • Resets the refresh counter of the texture and start bak from scratch. Could be useful to regenerate the texture if it is setup to render only once.

    Returns void

  • resize(size: number | { height: number; width: number } | { ratio: number }): void
  • Resize the texture to a new desired size. Be careful as it will recreate all the data in the new texture.

    Parameters

    • size: number | { height: number; width: number } | { ratio: number }

      Define the new size. It can be:

      • a number for squared texture,
      • an object containing { width: number, height: number }
      • or an object containing a ratio { ratio: number }

    Returns void

  • scale(ratio: number): void
  • Resize the texture using a ratio.

    Parameters

    • ratio: number

      the ratio to apply to the texture size in order to compute the new target size

    Returns void

  • serialize(): any
  • Serialize the texture to a JSON representation you could use in Parse later on

    Returns any

    the serialized JSON representation

  • Sets a specific material to be used to render a mesh/a list of meshes in this render target texture

    Parameters

    • mesh: AbstractMesh | AbstractMesh[]

      mesh or array of meshes

    • Optional material: Material | Material[]

      material or array of materials to use for this render pass. If undefined is passed, no specific material will be used but the regular material instead (mesh.material). It's possible to provide an array of materials to use a different material for each rendering in the case of a cube texture (6 rendering) and a 2D texture array (as many rendering as the length of the array)

    Returns void

  • setRenderingAutoClearDepthStencil(renderingGroupId: number, autoClearDepthStencil: boolean): void
  • Specifies whether or not the stencil and depth buffer are cleared between two rendering groups.

    Parameters

    • renderingGroupId: number

      The rendering group id corresponding to its index

    • autoClearDepthStencil: boolean

      Automatically clears depth and stencil between groups if true.

    Returns void

  • Overrides the default sort function applied in the rendering group to prepare the meshes. This allowed control for front to back rendering or reversely depending of the special needs.

    Parameters

    • renderingGroupId: number

      The rendering group id corresponding to its index

    • Optional opaqueSortCompareFn: Nullable<((a: SubMesh, b: SubMesh) => number)>

      The opaque queue comparison function use to sort.

    • Optional alphaTestSortCompareFn: Nullable<((a: SubMesh, b: SubMesh) => number)>

      The alpha test queue comparison function use to sort.

    • Optional transparentSortCompareFn: Nullable<((a: SubMesh, b: SubMesh) => number)>

      The transparent queue comparison function use to sort.

    Returns void

  • toString(): string
  • Return a string representation of the texture.

    Returns string

    the texture as a string

  • updateSamplingMode(samplingMode: number): void
  • Update the sampling mode of the texture. Default is Trilinear mode.

    ValueTypeDescription
    1NEAREST_SAMPLINGMODE or NEAREST_NEAREST_MIPLINEARNearest is: mag = nearest, min = nearest, mip = linear
    2BILINEAR_SAMPLINGMODE or LINEAR_LINEAR_MIPNEARESTBilinear is: mag = linear, min = linear, mip = nearest
    3TRILINEAR_SAMPLINGMODE or LINEAR_LINEAR_MIPLINEARTrilinear is: mag = linear, min = linear, mip = linear
    4NEAREST_NEAREST_MIPNEAREST
    5NEAREST_LINEAR_MIPNEAREST
    6NEAREST_LINEAR_MIPLINEAR
    7NEAREST_LINEAR
    8NEAREST_NEAREST
    9LINEAR_NEAREST_MIPNEAREST
    10LINEAR_NEAREST_MIPLINEAR
    11LINEAR_LINEAR
    12LINEAR_NEAREST

    mag: magnification filter (close to the viewer) min: minification filter (far from the viewer) mip: filter used between mip map levels

    Parameters

    • samplingMode: number

      Define the new sampling mode of the texture

    Returns void

  • updateURL(url: string, buffer?: Nullable<string | ArrayBufferView | Blob | ArrayBuffer | HTMLImageElement>, onLoad?: (() => void), forcedExtension?: string): void
  • Update the url (and optional buffer) of this texture if url was null during construction.

    Parameters

    • url: string

      the url of the texture

    • Optional buffer: Nullable<string | ArrayBufferView | Blob | ArrayBuffer | HTMLImageElement>

      the buffer of the texture (defaults to null)

    • Optional onLoad: (() => void)

      callback called when the texture is loaded (defaults to null)

        • (): void
        • Returns void

    • Optional forcedExtension: string

      defines the extension to use to pick the right loader

    Returns void

  • CreateFromBase64String(data: string, name: string, scene: Scene, noMipmapOrOptions?: boolean | ITextureCreationOptions, invertY?: boolean, samplingMode?: number, onLoad?: Nullable<(() => void)>, onError?: Nullable<(() => void)>, format?: number, creationFlags?: number): Texture
  • Creates a texture from its base 64 representation.

    Parameters

    • data: string

      Define the base64 payload without the data: prefix

    • name: string

      Define the name of the texture in the scene useful fo caching purpose for instance

    • scene: Scene

      Define the scene the texture should belong to

    • Optional noMipmapOrOptions: boolean | ITextureCreationOptions

      defines if the texture will require mip maps or not or set of all options to create the texture

    • Optional invertY: boolean

      define if the texture needs to be inverted on the y axis during loading

    • Optional samplingMode: number

      define the sampling mode we want for the texture while fetching from it (Texture.NEAREST_SAMPLINGMODE...)

    • Optional onLoad: Nullable<(() => void)>

      define a callback triggered when the texture has been loaded

    • Optional onError: Nullable<(() => void)>

      define a callback triggered when an error occurred during the loading session

    • Optional format: number

      define the format of the texture we are trying to load (Engine.TEXTUREFORMAT_RGBA...)

    • Optional creationFlags: number

      specific flags to use when creating the texture (Constants.TEXTURE_CREATIONFLAG_STORAGE for storage textures, for eg)

    Returns Texture

    the created texture

  • LoadFromDataString(name: string, buffer: any, scene: Scene, deleteBuffer?: boolean, noMipmapOrOptions?: boolean | ITextureCreationOptions, invertY?: boolean, samplingMode?: number, onLoad?: Nullable<(() => void)>, onError?: Nullable<((message?: string, exception?: any) => void)>, format?: number, creationFlags?: number): Texture
  • Creates a texture from its data: representation. (data: will be added in case only the payload has been passed in)

    Parameters

    • name: string

      Define the name of the texture in the scene useful fo caching purpose for instance

    • buffer: any

      define the buffer to load the texture from in case the texture is loaded from a buffer representation

    • scene: Scene

      Define the scene the texture should belong to

    • Optional deleteBuffer: boolean

      define if the buffer we are loading the texture from should be deleted after load

    • Optional noMipmapOrOptions: boolean | ITextureCreationOptions

      defines if the texture will require mip maps or not or set of all options to create the texture

    • Optional invertY: boolean

      define if the texture needs to be inverted on the y axis during loading

    • Optional samplingMode: number

      define the sampling mode we want for the texture while fetching from it (Texture.NEAREST_SAMPLINGMODE...)

    • Optional onLoad: Nullable<(() => void)>

      define a callback triggered when the texture has been loaded

    • Optional onError: Nullable<((message?: string, exception?: any) => void)>

      define a callback triggered when an error occurred during the loading session

    • Optional format: number

      define the format of the texture we are trying to load (Engine.TEXTUREFORMAT_RGBA...)

    • Optional creationFlags: number

      specific flags to use when creating the texture (Constants.TEXTURE_CREATIONFLAG_STORAGE for storage textures, for eg)

    Returns Texture

    the created texture

  • Parse the JSON representation of a texture in order to recreate the texture in the given scene.

    Parameters

    • parsedTexture: any

      Define the JSON representation of the texture

    • scene: Scene

      Define the scene the parsed texture should be instantiated in

    • rootUrl: string

      Define the root url of the parsing sequence in the case of relative dependencies

    Returns Nullable<BaseTexture>

    The parsed texture if successful

  • WhenAllReady(textures: BaseTexture[], callback: (() => void)): void
  • Helper function to be called back once a list of texture contains only ready textures.

    Parameters

    • textures: BaseTexture[]

      Define the list of textures to wait for

    • callback: (() => void)

      Define the callback triggered once the entire list will be ready

        • (): void
        • Returns void

    Returns void

Legend

  • Constructor
  • Property
  • Method
  • Accessor
  • Inherited constructor
  • Inherited property
  • Inherited method
  • Inherited accessor
  • Property
  • Method
  • Static method

Settings

Theme