The Physically based material of BJS.

This offers the main features of a standard PBR material. For more information, please refer to the documentation : https://doc.babylonjs.com/features/featuresDeepDive/materials/using/introToPBR

Hierarchy

  • PBRBaseMaterial
    • PBRMaterial

Constructors

Properties

albedoColor albedoTexture allowShaderHotSwapping alphaCutOff ambientColor ambientTexture ambientTextureImpactOnAnalyticalLights ambientTextureStrength animations anisotropy applyDecalMapAfterDetailMap brdf bumpTexture checkReadyOnEveryCall checkReadyOnlyOnce clearCoat clipPlane clipPlane2 clipPlane3 clipPlane4 clipPlane5 clipPlane6 customShaderNameResolve decalMap depthFunction detailMap directIntensity disableBumpMap disableColorWrite disableDepthWrite disableLighting doNotSerialize emissiveColor emissiveIntensity emissiveTexture enableSpecularAntiAliasing environmentBRDFTexture environmentIntensity forceAlphaTest forceDepthWrite forceIrradianceInFragment forceNormalForward getRenderTargetTextures id inspectableCustomProperties invertNormalMapX invertNormalMapY iridescence lightmapTexture maxSimultaneousLights metadata metallic metallicF0Factor metallicReflectanceColor metallicReflectanceTexture metallicTexture microSurface microSurfaceTexture name onCompiled onDisposeObservable onError opacityTexture parallaxScaleBias pluginManager? pointSize prePassConfiguration reflectanceTexture reflectionColor reflectionTexture reflectivityColor reflectivityTexture reservedDataStore roughness separateCullingPass shadowDepthWrapper sheen sideOrientation specularIntensity state stencil subSurface twoSidedLighting uniqueId unlit useAlphaFresnel useAlphaFromAlbedoTexture useAmbientInGrayScale useAmbientOcclusionFromMetallicTextureRed useAutoMicroSurfaceFromReflectivityMap useHorizonOcclusion useLightmapAsShadowmap useLinearAlphaFresnel useMetallnessFromMetallicTextureBlue useMicroSurfaceFromReflectivityMapAlpha useObjectSpaceNormalMap useOnlyMetallicFromMetallicReflectanceTexture useParallax useParallaxOcclusion useRadianceOcclusion useRadianceOverAlpha useRoughnessFromMetallicTextureAlpha useRoughnessFromMetallicTextureGreen useSpecularOverAlpha zOffset zOffsetUnits AllDirtyFlag AttributesDirtyFlag ClockWiseSideOrientation CounterClockWiseSideOrientation DEFAULT_AO_ON_ANALYTICAL_LIGHTS FresnelDirtyFlag LIGHTFALLOFF_GLTF LIGHTFALLOFF_PHYSICAL LIGHTFALLOFF_STANDARD LightDirtyFlag LineListDrawMode LineLoopDrawMode LineStripDrawMode MATERIAL_ALPHABLEND MATERIAL_ALPHATEST MATERIAL_ALPHATESTANDBLEND MATERIAL_NORMALBLENDMETHOD_RNM MATERIAL_NORMALBLENDMETHOD_WHITEOUT MATERIAL_OPAQUE MiscDirtyFlag OnEventObservable PBRMATERIAL_ALPHABLEND PBRMATERIAL_ALPHATEST PBRMATERIAL_ALPHATESTANDBLEND PBRMATERIAL_OPAQUE PointFillMode PointListDrawMode PrePassDirtyFlag TextureDirtyFlag TriangleFanDrawMode TriangleFillMode TriangleStripDrawMode WireFrameFillMode

Accessors

Methods

Constructors

  • Instantiates a new PBRMaterial instance.

    Parameters

    • name: string

      The material name

    • Optional scene: Scene

      The scene the material will be use in.

    Returns PBRMaterial

Properties

albedoColor: Color3

AKA Diffuse Color in other nomenclature.

albedoTexture: Nullable<BaseTexture>

AKA Diffuse Texture in standard nomenclature.

allowShaderHotSwapping: boolean

Gets or sets a boolean indicating that the material is allowed (if supported) to do shader hot swapping. This means that the material can keep using a previous shader while a new one is being compiled. This is mostly used when shader parallel compilation is supported (true by default)

alphaCutOff: number

Defines the alpha limits in alpha test mode.

ambientColor: Color3

The color of a material in ambient lighting.

ambientTexture: Nullable<BaseTexture>

AKA Occlusion Texture in other nomenclature.

ambientTextureImpactOnAnalyticalLights: number

Defines how much the AO map is occluding the analytical lights (point spot...). 1 means it completely occludes it 0 mean it has no impact

ambientTextureStrength: number

AKA Occlusion Texture Intensity in other nomenclature.

animations: Nullable<BabylonAnimation[]>

Stores the animations for the material

anisotropy: PBRAnisotropicConfiguration

Defines the anisotropic parameters for the material.

applyDecalMapAfterDetailMap: boolean

If sets to true, the decal map will be applied after the detail map. Else, it is applied before (default: false)

brdf: PBRBRDFConfiguration

Defines the BRDF parameters for the material.

bumpTexture: Nullable<BaseTexture>

Stores surface normal data used to displace a mesh in a texture.

checkReadyOnEveryCall: boolean

Specifies if the ready state should be checked on each call

checkReadyOnlyOnce: boolean

Specifies if the ready state should be checked once

clearCoat: PBRClearCoatConfiguration

Defines the clear coat layer parameters for the material.

clipPlane: Nullable<Plane>

Gets or sets the active clipplane 1

clipPlane2: Nullable<Plane>

Gets or sets the active clipplane 2

clipPlane3: Nullable<Plane>

Gets or sets the active clipplane 3

clipPlane4: Nullable<Plane>

Gets or sets the active clipplane 4

clipPlane5: Nullable<Plane>

Gets or sets the active clipplane 5

clipPlane6: Nullable<Plane>

Gets or sets the active clipplane 6

customShaderNameResolve: ((shaderName: string, uniforms: string[], uniformBuffers: string[], samplers: string[], defines: string[] | MaterialDefines, attributes?: string[], options?: ICustomShaderNameResolveOptions) => string)

Type declaration

    • (shaderName: string, uniforms: string[], uniformBuffers: string[], samplers: string[], defines: string[] | MaterialDefines, attributes?: string[], options?: ICustomShaderNameResolveOptions): string
    • Custom callback helping to override the default shader used in the material.

      Parameters

      • shaderName: string
      • uniforms: string[]
      • uniformBuffers: string[]
      • samplers: string[]
      • defines: string[] | MaterialDefines
      • Optional attributes: string[]
      • Optional options: ICustomShaderNameResolveOptions

      Returns string

decalMap: Nullable<DecalMapConfiguration>

Defines the decal map parameters for the material.

depthFunction: number

Specifies the depth function that should be used. 0 means the default engine function

detailMap: DetailMapConfiguration

Defines the detail map parameters for the material.

directIntensity: number

Intensity of the direct lights e.g. the four lights available in your scene. This impacts both the direct diffuse and specular highlights.

disableBumpMap: boolean

Debug Control allowing disabling the bump map on this material.

disableColorWrite: boolean

Specifies if color writing should be disabled

disableDepthWrite: boolean

Specifies if depth writing should be disabled

disableLighting: boolean

If sets to true, disables all the lights affecting the material.

doNotSerialize: boolean

Specifies if the material should be serialized

emissiveColor: Color3

The color emitted from the material.

emissiveIntensity: number

Intensity of the emissive part of the material. This helps controlling the emissive effect without modifying the emissive color.

emissiveTexture: Nullable<BaseTexture>

Stores the emissive values in a texture.

enableSpecularAntiAliasing: boolean

Enables specular anti aliasing in the PBR shader. It will both interacts on the Geometry for analytical and IBL lighting. It also prefilter the roughness map based on the bump values.

environmentBRDFTexture: Nullable<BaseTexture>

Let user defines the brdf lookup texture used for IBL. A default 8bit version is embedded but you could point at :

environmentIntensity: number

Intensity of the environment e.g. how much the environment will light the object either through harmonics for rough material or through the reflection for shiny ones.

forceAlphaTest: boolean

Enforces alpha test in opaque or blend mode in order to improve the performances of some situations.

forceDepthWrite: boolean

Specifies if depth writing should be forced

forceIrradianceInFragment: boolean

Force the shader to compute irradiance in the fragment shader in order to take bump in account.

forceNormalForward: boolean

Force normal to face away from face.

getRenderTargetTextures: Nullable<(() => SmartArray<RenderTargetTexture>)>

Callback triggered to get the render target textures

id: string

The ID of the material

inspectableCustomProperties: IInspectable[]

List of inspectable custom properties (used by the Inspector)

See

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

invertNormalMapX: boolean

If sets to true, x component of normal map value will invert (x = 1.0 - x).

invertNormalMapY: boolean

If sets to true, y component of normal map value will invert (y = 1.0 - y).

iridescence: PBRIridescenceConfiguration

Defines the iridescence layer parameters for the material.

lightmapTexture: Nullable<BaseTexture>

Stores the pre-calculated light information of a mesh in a texture.

maxSimultaneousLights: number

Number of Simultaneous lights allowed on the material.

metadata: any

Gets or sets user defined metadata

metallic: Nullable<number>

Specifies the metallic scalar of the metallic/roughness workflow. Can also be used to scale the metalness values of the metallic texture.

metallicF0Factor: number

In metallic workflow, specifies an F0 factor to help configuring the material F0. By default the indexOfrefraction is used to compute F0;

This is used as a factor against the default reflectance at normal incidence to tweak it.

F0 = defaultF0 * metallicF0Factor * metallicReflectanceColor; F90 = metallicReflectanceColor;

metallicReflectanceColor: Color3

In metallic workflow, specifies an F0 color. By default the F90 is always 1;

Please note that this factor is also used as a factor against the default reflectance at normal incidence.

F0 = defaultF0_from_IOR * metallicF0Factor * metallicReflectanceColor F90 = metallicF0Factor;

metallicReflectanceTexture: Nullable<BaseTexture>

Defines to store metallicReflectanceColor in RGB and metallicF0Factor in A This is multiplied against the scalar values defined in the material. If useOnlyMetallicFromMetallicReflectanceTexture is true, don't use the RGB channels, only A

metallicTexture: Nullable<BaseTexture>

Used to switch from specular/glossiness to metallic/roughness workflow.

microSurface: number

AKA Glossiness in other nomenclature.

microSurfaceTexture: Nullable<BaseTexture>

Used to enable roughness/glossiness fetch from a separate channel depending on the current mode. Gray Scale represents roughness in metallic mode and glossiness in specular mode.

name: string

The name of the material

onCompiled: Nullable<((effect: Effect) => void)>

Callback triggered when the material is compiled

onDisposeObservable: Observable<Material>

An event triggered when the material is disposed

onError: Nullable<((effect: Effect, errors: string) => void)>

Callback triggered when an error occurs

opacityTexture: Nullable<BaseTexture>

Stores the alpha values in a texture. Use luminance if texture.getAlphaFromRGB is true.

parallaxScaleBias: number

Controls the scale bias of the parallax mode.

pluginManager?: MaterialPluginManager

Plugin manager for this material

pointSize: number

Stores the size of points

prePassConfiguration: PrePassConfiguration

Defines additional PrePass parameters for the material.

reflectanceTexture: Nullable<BaseTexture>

Defines to store reflectanceColor in RGB This is multiplied against the scalar values defined in the material. If both reflectanceTexture and metallicReflectanceTexture textures are provided and useOnlyMetallicFromMetallicReflectanceTexture is false, metallicReflectanceTexture takes priority and reflectanceTexture is not used

reflectionColor: Color3

The color reflected from the material.

reflectionTexture: Nullable<BaseTexture>

Stores the reflection values in a texture.

reflectivityColor: Color3

AKA Specular Color in other nomenclature.

reflectivityTexture: Nullable<BaseTexture>

AKA Specular texture in other nomenclature.

reservedDataStore: any

For internal use only. Please do not use.

roughness: Nullable<number>

Specifies the roughness scalar of the metallic/roughness workflow. Can also be used to scale the roughness values of the metallic texture.

separateCullingPass: boolean

Specifies if there should be a separate pass for culling

shadowDepthWrapper: Nullable<ShadowDepthWrapper>

Custom shadow depth material to use for shadow rendering instead of the in-built one

sheen: PBRSheenConfiguration

Defines the Sheen parameters for the material.

sideOrientation: number

Stores the value for side orientation

specularIntensity: number

This is a special control allowing the reduction of the specular highlights coming from the four lights of the scene. Those highlights may not be needed in full environment lighting.

state: string

The state of the material

stencil: MaterialStencilState

Gives access to the stencil properties of the material

subSurface: PBRSubSurfaceConfiguration

Defines the SubSurface parameters for the material.

twoSidedLighting: boolean

If sets to true and backfaceCulling is false, normals will be flipped on the backside.

uniqueId: number

Gets or sets the unique id of the material

unlit: boolean

If set to true, no lighting calculations will be applied.

useAlphaFresnel: boolean

A fresnel is applied to the alpha of the model to ensure grazing angles edges are not alpha tested. And/Or occlude the blended part. (alpha is converted to gamma to compute the fresnel)

useAlphaFromAlbedoTexture: boolean

Specifies that the alpha is coming form the albedo channel alpha channel for alpha blending.

useAmbientInGrayScale: boolean

Specifies if the ambient texture contains the ambient occlusion information in its red channel only.

useAmbientOcclusionFromMetallicTextureRed: boolean

Specifies if the metallic texture contains the ambient occlusion information in its red channel.

useAutoMicroSurfaceFromReflectivityMap: boolean

In case the reflectivity map does not contain the microsurface information in its alpha channel, The material will try to infer what glossiness each pixel should be.

useHorizonOcclusion: boolean

This parameters will enable/disable Horizon occlusion to prevent normal maps to look shiny when the normal makes the reflect vector face the model (under horizon).

useLightmapAsShadowmap: boolean

If true, the light map contains occlusion information instead of lighting info.

useLinearAlphaFresnel: boolean

A fresnel is applied to the alpha of the model to ensure grazing angles edges are not alpha tested. And/Or occlude the blended part. (alpha stays linear to compute the fresnel)

useMetallnessFromMetallicTextureBlue: boolean

Specifies if the metallic texture contains the metallness information in its blue channel.

useMicroSurfaceFromReflectivityMapAlpha: boolean

Specifies if the reflectivity texture contains the glossiness information in its alpha channel.

useObjectSpaceNormalMap: boolean

Allows using an object space normal map (instead of tangent space).

useOnlyMetallicFromMetallicReflectanceTexture: boolean

Specifies that only the A channel from metallicReflectanceTexture should be used. If false, both RGB and A channels will be used

useParallax: boolean

Allows using the bump map in parallax mode.

useParallaxOcclusion: boolean

Allows using the bump map in parallax occlusion mode.

useRadianceOcclusion: boolean

This parameters will enable/disable radiance occlusion by preventing the radiance to lit too much the area relying on ambient texture to define their ambient occlusion.

useRadianceOverAlpha: boolean

Specifies that the material will keeps the reflection highlights over a transparent surface (only the most luminous ones). A car glass is a good example of that. When the street lights reflects on it you can not see what is behind.

useRoughnessFromMetallicTextureAlpha: boolean

Specifies if the metallic texture contains the roughness information in its alpha channel.

useRoughnessFromMetallicTextureGreen: boolean

Specifies if the metallic texture contains the roughness information in its green channel.

useSpecularOverAlpha: boolean

Specifies that the material will keep the specular highlights over a transparent surface (only the most luminous ones). A car glass is a good example of that. When sun reflects on it you can not see what is behind.

zOffset: number

Stores the z offset Factor value

zOffsetUnits: number

Stores the z offset Units value

AllDirtyFlag: 63 = 63

The all dirty flag value

AttributesDirtyFlag: 8 = 8

The dirty attribute flag value

ClockWiseSideOrientation: 0 = 0

Stores the clock-wise side orientation

CounterClockWiseSideOrientation: 1 = 1

Stores the counter clock-wise side orientation

DEFAULT_AO_ON_ANALYTICAL_LIGHTS: number

Defines the default value of how much AO map is occluding the analytical lights (point spot...).

FresnelDirtyFlag: 4 = 4

The dirty fresnel flag value

LIGHTFALLOFF_GLTF: 1 = 1

PBRMaterialLightFalloff gltf: light is falling off as described in the gltf moving to PBR document to enhance interoperability with other engines.

LIGHTFALLOFF_PHYSICAL: 0 = 0

PBRMaterialLightFalloff Physical: light is falling off following the inverse squared distance law.

LIGHTFALLOFF_STANDARD: 2 = 2

PBRMaterialLightFalloff Standard: light is falling off like in the standard material to enhance interoperability with other materials.

LightDirtyFlag: 2 = 2

The dirty light flag value

LineListDrawMode: 4 = 4

Returns the line list draw mode

LineLoopDrawMode: 5 = 5

Returns the line loop draw mode

LineStripDrawMode: 6 = 6

Returns the line strip draw mode

MATERIAL_ALPHABLEND: 2 = 2

MaterialTransparencyMode: Pixels are blended (according to the alpha mode) with the already drawn pixels in the current frame buffer.

MATERIAL_ALPHATEST: 1 = 1

MaterialTransparencyMode: Alpha Test mode, pixel are discarded below a certain threshold defined by the alpha cutoff value.

MATERIAL_ALPHATESTANDBLEND: 3 = 3

MaterialTransparencyMode: Pixels are blended (according to the alpha mode) with the already drawn pixels in the current frame buffer. They are also discarded below the alpha cutoff threshold to improve performances.

MATERIAL_NORMALBLENDMETHOD_RNM: 1 = 1

The Reoriented Normal Mapping method is used to blend normals. Details of the algorithm can be found here: https://blog.selfshadow.com/publications/blending-in-detail/

MATERIAL_NORMALBLENDMETHOD_WHITEOUT: 0 = 0

The Whiteout method is used to blend normals. Details of the algorithm can be found here: https://blog.selfshadow.com/publications/blending-in-detail/

MATERIAL_OPAQUE: 0 = 0

MaterialTransparencyMode: No transparency mode, Alpha channel is not use.

MiscDirtyFlag: 16 = 16

The dirty misc flag value

OnEventObservable: Observable<Material>

Event observable which raises global events common to all materials (like MaterialPluginEvent.Created)

PBRMATERIAL_ALPHABLEND: 2 = 2

PBRMaterialTransparencyMode: Pixels are blended (according to the alpha mode) with the already drawn pixels in the current frame buffer.

PBRMATERIAL_ALPHATEST: 1 = 1

PBRMaterialTransparencyMode: Alpha Test mode, pixel are discarded below a certain threshold defined by the alpha cutoff value.

PBRMATERIAL_ALPHATESTANDBLEND: 3 = 3

PBRMaterialTransparencyMode: Pixels are blended (according to the alpha mode) with the already drawn pixels in the current frame buffer. They are also discarded below the alpha cutoff threshold to improve performances.

PBRMATERIAL_OPAQUE: 0 = 0

PBRMaterialTransparencyMode: No transparency mode, Alpha channel is not use.

PointFillMode: 2 = 2

Returns the point fill mode

PointListDrawMode: 3 = 3

Returns the point list draw mode

PrePassDirtyFlag: 32 = 32

The dirty prepass flag value

TextureDirtyFlag: 1 = 1

The dirty texture flag value

TriangleFanDrawMode: 8 = 8

Returns the triangle fan draw mode

TriangleFillMode: 0 = 0

Returns the triangle fill mode

TriangleStripDrawMode: 7 = 7

Returns the triangle strip draw mode

WireFrameFillMode: 1 = 1

Returns the wireframe mode

Accessors

  • get alpha(): number
  • Gets the alpha value of the material

    Returns number

  • set alpha(value: number): void
  • Sets the alpha value of the material

    Parameters

    • value: number

    Returns void

  • get alphaMode(): number
  • Gets the value of the alpha mode

    Returns number

  • set alphaMode(value: number): void
  • Sets the value of the alpha mode.

    Value Type Description
    0 ALPHA_DISABLE
    1 ALPHA_ADD
    2 ALPHA_COMBINE
    3 ALPHA_SUBTRACT
    4 ALPHA_MULTIPLY
    5 ALPHA_MAXIMIZED
    6 ALPHA_ONEONE
    7 ALPHA_PREMULTIPLIED
    8 ALPHA_PREMULTIPLIED_PORTERDUFF
    9 ALPHA_INTERPOLATE
    10 ALPHA_SCREENMODE

    Parameters

    • value: number

    Returns void

  • get backFaceCulling(): boolean
  • Gets the culling state

    Returns boolean

  • set backFaceCulling(value: boolean): void
  • Sets the culling state (true to enable culling, false to disable)

    Parameters

    • value: boolean

    Returns void

  • get blockDirtyMechanism(): boolean
  • Block the dirty-mechanism for this specific material When set to false after being true the material will be marked as dirty.

    Returns boolean

  • set blockDirtyMechanism(value: boolean): void
  • Parameters

    • value: boolean

    Returns void

  • get cameraColorCurves(): Nullable<ColorCurves>
  • The color grading curves provide additional color adjustment that is applied after any color grading transform (3D LUT). They allow basic adjustment of saturation and small exposure adjustments, along with color filter tinting to provide white balance adjustment or more stylistic effects. These are similar to controls found in many professional imaging or colorist software. The global controls are applied to the entire image. For advanced tuning, extra controls are provided to adjust the shadow, midtone and highlight areas of the image; corresponding to low luminance, medium luminance, and high luminance areas respectively.

    Returns Nullable<ColorCurves>

  • set cameraColorCurves(value: Nullable<ColorCurves>): void
  • The color grading curves provide additional color adjustment that is applied after any color grading transform (3D LUT). They allow basic adjustment of saturation and small exposure adjustments, along with color filter tinting to provide white balance adjustment or more stylistic effects. These are similar to controls found in many professional imaging or colorist software. The global controls are applied to the entire image. For advanced tuning, extra controls are provided to adjust the shadow, midtone and highlight areas of the image; corresponding to low luminance, medium luminance, and high luminance areas respectively.

    Parameters

    • value: Nullable<ColorCurves>

    Returns void

  • get cameraColorCurvesEnabled(): boolean
  • Gets whether the color curves effect is enabled.

    Returns boolean

  • set cameraColorCurvesEnabled(value: boolean): void
  • Sets whether the color curves effect is enabled.

    Parameters

    • value: boolean

    Returns void

  • get cameraColorGradingEnabled(): boolean
  • Gets whether the color grading effect is enabled.

    Returns boolean

  • set cameraColorGradingEnabled(value: boolean): void
  • Gets whether the color grading effect is enabled.

    Parameters

    • value: boolean

    Returns void

  • get cameraColorGradingTexture(): Nullable<BaseTexture>
  • Gets the Color Grading 2D Lookup Texture.

    Returns Nullable<BaseTexture>

  • set cameraColorGradingTexture(value: Nullable<BaseTexture>): void
  • Sets the Color Grading 2D Lookup Texture.

    Parameters

    • value: Nullable<BaseTexture>

    Returns void

  • get cameraContrast(): number
  • Gets The camera contrast used on this material.

    Returns number

  • set cameraContrast(value: number): void
  • Sets The camera contrast used on this material.

    Parameters

    • value: number

    Returns void

  • get cameraExposure(): number
  • The camera exposure used on this material. This property is here and not in the camera to allow controlling exposure without full screen post process. This corresponds to a photographic exposure.

    Returns number

  • set cameraExposure(value: number): void
  • The camera exposure used on this material. This property is here and not in the camera to allow controlling exposure without full screen post process. This corresponds to a photographic exposure.

    Parameters

    • value: number

    Returns void

  • get cameraToneMappingEnabled(): boolean
  • Gets whether tonemapping is enabled or not.

    Returns boolean

  • set cameraToneMappingEnabled(value: boolean): void
  • Sets whether tonemapping is enabled or not

    Parameters

    • value: boolean

    Returns void

  • get canRenderToMRT(): boolean
  • Can this material render to several textures at once

    Returns boolean

  • get cullBackFaces(): boolean
  • Gets the type of faces that should be culled

    Returns boolean

  • set cullBackFaces(value: boolean): void
  • Sets the type of faces that should be culled (true for back faces, false for front faces)

    Parameters

    • value: boolean

    Returns void

  • get fillMode(): number
  • Gets the material fill mode

    Returns number

  • set fillMode(value: number): void
  • Sets the material fill mode

    Parameters

    • value: number

    Returns void

  • get fogEnabled(): boolean
  • Gets the value of the fog enabled state

    Returns boolean

  • set fogEnabled(value: boolean): void
  • Sets the state for enabling fog

    Parameters

    • value: boolean

    Returns void

  • get hasRenderTargetTextures(): boolean
  • Gets a boolean indicating that current material needs to register RTT

    Returns boolean

  • get imageProcessingConfiguration(): ImageProcessingConfiguration
  • Gets the image processing configuration used either in this material.

    Returns ImageProcessingConfiguration

  • set imageProcessingConfiguration(value: ImageProcessingConfiguration): void
  • Sets the Default image processing configuration used either in the this material.

    If sets to null, the scene one is in use.

    Parameters

    • value: ImageProcessingConfiguration

    Returns void

  • get indexOfRefraction(): number
  • Index of refraction of the material base layer. https://en.wikipedia.org/wiki/List_of_refractive_indices

    This does not only impact refraction but also the Base F0 of Dielectric Materials.

    From dielectric fresnel rules: F0 = square((iorT - iorI) / (iorT + iorI))

    Returns number

  • set indexOfRefraction(value: number): void
  • Parameters

    • value: number

    Returns void

  • get invertRefractionY(): boolean
  • Controls if refraction needs to be inverted on Y. This could be useful for procedural texture.

    Returns boolean

  • set invertRefractionY(value: boolean): void
  • Parameters

    • value: boolean

    Returns void

  • get isFrozen(): boolean
  • Specifies if updates for the material been locked

    Returns boolean

  • get isPrePassCapable(): boolean
  • Can this material render to prepass

    Returns boolean

  • get linkRefractionWithTransparency(): boolean
  • This parameters will make the material used its opacity to control how much it is refracting against not. Materials half opaque for instance using refraction could benefit from this control.

    Returns boolean

  • set linkRefractionWithTransparency(value: boolean): void
  • Parameters

    • value: boolean

    Returns void

  • get needDepthPrePass(): boolean
  • Gets the depth pre-pass value

    Returns boolean

  • set needDepthPrePass(value: boolean): void
  • Sets the need depth pre-pass value

    Parameters

    • value: boolean

    Returns void

  • set onBind(callback: ((Mesh: AbstractMesh) => void)): void
  • Called during a bind event

    Parameters

    Returns void

  • get onBindObservable(): Observable<AbstractMesh>
  • An event triggered when the material is bound

    Returns Observable<AbstractMesh>

  • set onDispose(callback: (() => void)): void
  • Called during a dispose event

    Parameters

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

    Returns void

  • get onEffectCreatedObservable(): Observable<{ effect: Effect; subMesh: Nullable<SubMesh> }>
  • An event triggered when the effect is (re)created

    Returns Observable<{ effect: Effect; subMesh: Nullable<SubMesh> }>

  • get onUnBindObservable(): Observable<Material>
  • An event triggered when the material is unbound

    Returns Observable<Material>

  • get pointsCloud(): boolean
  • Gets the value specifying if point clouds are enabled

    Returns boolean

  • set pointsCloud(value: boolean): void
  • Sets the state of point cloud mode

    Parameters

    • value: boolean

    Returns void

  • get realTimeFiltering(): boolean
  • Enables realtime filtering on the texture.

    Returns boolean

  • set realTimeFiltering(b: boolean): void
  • Parameters

    • b: boolean

    Returns void

  • get realTimeFilteringQuality(): number
  • Quality switch for realtime filtering

    Returns number

  • set realTimeFilteringQuality(n: number): void
  • Parameters

    • n: number

    Returns void

  • get refractionTexture(): Nullable<BaseTexture>
  • Stores the refracted light information in a texture.

    Returns Nullable<BaseTexture>

  • set refractionTexture(value: Nullable<BaseTexture>): void
  • Parameters

    • value: Nullable<BaseTexture>

    Returns void

  • get transparencyMode(): Nullable<number>
  • Gets the current transparency mode.

    Returns Nullable<number>

  • set transparencyMode(value: Nullable<number>): void
  • Sets the transparency mode of the material.

    Value Type Description
    0 OPAQUE
    1 ALPHATEST
    2 ALPHABLEND
    3 ALPHATESTANDBLEND

    Parameters

    • value: Nullable<number>

    Returns void

  • get useGLTFLightFalloff(): boolean
  • In order to support the falloff compatibility with gltf, a special mode has been added to reproduce the gltf light falloff.

    Returns boolean

  • set useGLTFLightFalloff(value: boolean): void
  • In order to support the falloff compatibility with gltf, a special mode has been added to reproduce the gltf light falloff.

    Parameters

    • value: boolean

    Returns void

  • get useLogarithmicDepth(): boolean
  • Enabled the use of logarithmic depth buffers, which is good for wide depth buffers.

    Returns boolean

  • set useLogarithmicDepth(value: boolean): void
  • Enabled the use of logarithmic depth buffers, which is good for wide depth buffers.

    Parameters

    • value: boolean

    Returns void

  • get usePhysicalLightFalloff(): boolean
  • BJS is using an hardcoded light falloff based on a manually sets up range. In PBR, one way to represents the falloff is to use the inverse squared root algorithm. This parameter can help you switch back to the BJS mode in order to create scenes using both materials.

    Returns boolean

  • set usePhysicalLightFalloff(value: boolean): void
  • BJS is using an hardcoded light falloff based on a manually sets up range. In PBR, one way to represents the falloff is to use the inverse squared root algorithm. This parameter can help you switch back to the BJS mode in order to create scenes using both materials.

    Parameters

    • value: boolean

    Returns void

  • get wireframe(): boolean
  • Returns boolean

  • set wireframe(value: boolean): void
  • Sets the state of wireframe mode

    Parameters

    • value: boolean

    Returns void

Methods

  • This allows you to modify the material without marking it as dirty after every change. This function should be used if you need to make more than one dirty-enabling change to the material - adding a texture, setting a new fill mode and so on. The callback will pass the material as an argument, so you can make your changes to it.

    Parameters

    • callback: ((material: PBRMaterial) => void)

      the callback to be executed that will update the material

    Returns void

  • Parameters

    • world: Matrix
    • Optional mesh: Mesh

    Returns void

  • Binds the view matrix to the effect

    Parameters

    • effect: Effect

      defines the effect to bind the view matrix to

    • Optional variableName: string

      name of the shader variable that will hold the eye position

    Returns void

  • Binds the submesh data.

    Parameters

    • world: Matrix

      The world matrix.

    • mesh: Mesh

      The BJS mesh.

    • subMesh: SubMesh

      A submesh of the BJS mesh.

    Returns void

  • Binds the given normal matrix to the active effect

    Parameters

    • normalMatrix: Matrix

      the matrix to bind

    Returns void

  • Binds the given world matrix to the active effect

    Parameters

    • world: Matrix

      the matrix to bind

    Returns void

  • Binds the view matrix to the effect

    Parameters

    • effect: Effect

      defines the effect to bind the view matrix to

    Returns void

  • Binds the view projection and projection matrices to the effect

    Parameters

    • effect: Effect

      defines the effect to bind the view projection and projection matrices to

    Returns void

  • Initializes the uniform buffer layout for the shader.

    Returns void

  • Makes a duplicate of the current material.

    Parameters

    • name: string

      name to use for the new material.

    • Optional cloneTexturesOnlyOnce: boolean

      if a texture is used in more than one channel (e.g diffuse and opacity), only clone it once and reuse it on the other channels. Default false.

    • Optional rootUrl: string

      defines the root URL to use to load textures

    Returns PBRMaterial

  • Disposes the resources of the material.

    Parameters

    • Optional forceDisposeEffect: boolean

      Forces the disposal of effects.

    • Optional forceDisposeTextures: boolean

      Forces the disposal of all textures.

    Returns void

  • Force shader compilation

    Parameters

    • mesh: AbstractMesh
    • Optional onCompiled: ((material: Material) => void)
    • Optional options: Partial<IMaterialCompilationOptions>

    Returns void

  • Force shader compilation

    Returns

    a promise that resolves when the compilation completes

    Parameters

    • mesh: AbstractMesh

      defines the mesh that will use this material

    • Optional options: Partial<IMaterialCompilationOptions>

      defines additional options for compiling the shaders

    Returns Promise<void>

  • Locks updates for the material

    Returns void

  • Returns an array of the actively used textures.

    Returns

    • Array of BaseTextures

    Returns BaseTexture[]

  • Gets the texture used for the alpha test.

    Returns Nullable<BaseTexture>

  • Returns the animatable textures. If material have animatable metallic texture, then reflectivity texture will not be returned, even if it has animations.

    Returns

    • Array of animatable textures.

    Returns IAnimatable[]

  • Gets the meshes bound to the material

    Returns

    an array of meshes bound to the material

    Returns AbstractMesh[]

  • Returns the name of this material class.

    Returns string

  • Returns Effect

  • Returns the current scene

    Returns

    a Scene

    Returns Scene

  • Checks to see if a texture is used in the material.

    Returns

    • Boolean specifying if a texture is used in the material.

    Parameters

    • texture: BaseTexture

      Base texture to use.

    Returns boolean

  • Specifies if the material uses metallic roughness workflow.

    Returns

    boolean specifying if the material uses metallic roughness workflow.

    Returns boolean

  • Parameters

    Returns boolean

  • Specifies that the submesh is ready to be used.

    Returns

    • boolean indicating that the submesh is ready or not.

    Parameters

    • mesh: AbstractMesh

      BJS mesh.

    • subMesh: SubMesh

      A submesh of the BJS mesh. Used to check if it is ready.

    • Optional useInstances: boolean

      Specifies that instances should be used.

    Returns boolean

  • Marks a define in the material to indicate that it needs to be re-computed

    Parameters

    • flag: number

      defines a flag used to determine which parts of the material have to be marked as dirty

    Returns void

  • Marks the material to indicate that it needs to be re-calculated

    Parameters

    • Optional forceMaterialDirty: boolean

      Forces the material to be marked as dirty for all components (same as this.markAsDirty(Material.AllDirtyFlag)). You should use this flag if the material is frozen and you want to force a recompilation.

    Returns void

  • Specifies whether or not this material should be rendered in alpha blend mode.

    Returns boolean

  • Specifies if the mesh will require alpha blending

    Returns

    a boolean specifying if alpha blending is needed for the mesh

    Parameters

    Returns boolean

  • Specifies whether or not this material should be rendered in alpha test mode.

    Returns boolean

  • Resets the draw wrappers cache for all submeshes that are using this material

    Returns void

  • Serializes this PBR Material.

    Returns

    • An object with the serialized material.

    Returns any

  • Sets the required values to the prepass renderer. It can't be sets when subsurface scattering of this material is disabled. When scene have ability to enable subsurface prepass effect, it will enable.

    Returns boolean

  • Returns a string representation of the current material

    Returns

    a string with material information

    Parameters

    • Optional fullDetails: boolean

      defines a boolean indicating which levels of logging is desired

    Returns string

  • Unbinds the material from the mesh

    Returns void

  • Unlocks updates for the material

    Returns void

  • Parses a PBR Material from a serialized object.

    Returns

    • PBRMaterial

    Parameters

    • source: any

      Serialized object.

    • scene: Scene

      BJS scene instance.

    • rootUrl: string

      url for the scene object

    Returns PBRMaterial

Generated using TypeDoc