API
API|
@babylonjs/core|
OpenPBRMaterial

Class OpenPBRMaterial

A Physically based material that follows the specification of OpenPBR.

For more information, please refer to the documentation : https://academysoftwarefoundation.github.io/OpenPBR/index.html

Hierarchy

  • OpenPBRMaterialBase
    • OpenPBRMaterial
Index
constructor
_imageProcessingConfiguration _imageProcessingObserver _useFuzzRoughnessFromTextureAlpha _useSubsurfaceWeightFromTextureAlpha allowShaderHotSwapping animations checkReadyOnEveryCall checkReadyOnlyOnce clipPlane clipPlane2 clipPlane3 clipPlane4 clipPlane5 clipPlane6 customShaderNameResolve depthFunction disableColorWrite disableDepthWrite doNotSerialize forceDepthWrite getRenderTargetTextures id inspectableCustomProperties metadata name onCompiled onDisposeObservable onError pluginManager? pointSize prePassConfiguration reservedDataStore separateCullingPass shadowDepthWrapper sideOrientation state stencil textureRepetitionHexTilingParams uniqueId useCoatRoughnessFromWeightTexture zOffset zOffsetUnits AllDirtyFlag AttributesDirtyFlag ClockWiseSideOrientation CounterClockWiseSideOrientation ForceGLSL ForceVertexOutputInvariant FresnelDirtyFlag ImageProcessingDirtyFlag LightDirtyFlag LIGHTFALLOFF_GLTF LIGHTFALLOFF_PHYSICAL LIGHTFALLOFF_STANDARD LineListDrawMode LineLoopDrawMode LineStripDrawMode MATERIAL_ALPHABLEND MATERIAL_ALPHATEST MATERIAL_ALPHATESTANDBLEND MATERIAL_NORMALBLENDMETHOD_RNM MATERIAL_NORMALBLENDMETHOD_WHITEOUT MATERIAL_OPAQUE MiscDirtyFlag OnEventObservable PointFillMode PointListDrawMode PrePassDirtyFlag SSS_QUALITY_HIGH SSS_QUALITY_LOW SSS_QUALITY_MEDIUM TextureDirtyFlag TriangleFanDrawMode TriangleFillMode TriangleStripDrawMode WireFrameFillMode
alpha alphaCutOff alphaMode alphaModes ambientOcclusionTexture applyDecalMapAfterDetailMap backFaceCulling backgroundRefractionTexture baseColor baseColorTexture baseDiffuseRoughness baseDiffuseRoughnessTexture baseMetalness baseMetalnessTexture baseWeight baseWeightTexture blockDirtyMechanism cameraColorCurves cameraColorCurvesEnabled cameraColorGradingEnabled cameraColorGradingTexture cameraContrast cameraExposure cameraToneMappingEnabled canRenderToMRT coatColor coatColorTexture coatDarkening coatDarkeningTexture coatIor coatRoughness coatRoughnessAnisotropy coatRoughnessAnisotropyTexture coatRoughnessTexture coatWeight coatWeightTexture cullBackFaces directIntensity disableLighting emissionColor emissionColorTexture emissionLuminance enableSpecularAntiAliasing environmentBRDFTexture environmentIntensity fillMode fogEnabled forceAlphaTest forceIrradianceInFragment forceNormalForward fuzzColor fuzzColorTexture fuzzRoughness fuzzRoughnessTexture fuzzSampleNumber fuzzWeight fuzzWeightTexture geometryCoatNormalTexture geometryCoatTangent geometryCoatTangentAngle geometryCoatTangentTexture geometryNormalTexture geometryOpacity geometryOpacityTexture geometryTangent geometryTangentAngle geometryTangentTexture geometryThickness geometryThicknessTexture geometryThinWalled hasRenderTargetTextures hasScattering hasTransparency imageProcessingConfiguration invertNormalMapX invertNormalMapY isFrozen isPrePassCapable isVertexOutputInvariant maxSimultaneousLights needDepthPrePass onBind onBindObservable onDispose onEffectCreatedObservable onUnBindObservable parallaxScaleBias pointsCloud realTimeFiltering realTimeFilteringQuality refractionHighQualityBlur shaderLanguage specularColor specularColorTexture specularIor specularRoughness specularRoughnessAnisotropy specularRoughnessAnisotropyTexture specularRoughnessTexture specularWeight specularWeightTexture sssDepthTexture sssIrradianceTexture sssQuality subsurfaceColor subsurfaceColorTexture subsurfaceRadius subsurfaceRadiusScale subsurfaceRadiusScaleTexture subsurfaceScatterAnisotropy subsurfaceWeight subsurfaceWeightTexture textureRepetitionMode thinFilmIor thinFilmThickness thinFilmThicknessMin thinFilmThicknessTexture thinFilmWeight thinFilmWeightTexture transmissionColor transmissionColorTexture transmissionDepth transmissionDepthTexture transmissionDispersionAbbeNumber transmissionDispersionScale transmissionDispersionScaleTexture transmissionScatter transmissionScatterAnisotropy transmissionScatterTexture transmissionWeight transmissionWeightTexture transparencyMode twoSidedLighting unlit useAlphaFresnel useAmbientInGrayScale useAmbientOcclusionFromMetallicTextureRed useGLTFLightFalloff useHorizonOcclusion useLinearAlphaFresnel useLogarithmicDepth useObjectSpaceNormalMap useParallax useParallaxOcclusion usePhysicalLightFalloff useRadianceOcclusion useSpecularWeightFromTextureAlpha useVertexPulling wireframe
_attachImageProcessingConfiguration atomicMaterialsUpdate bind bindEyePosition bindForSubMesh bindOnlyNormalMatrix bindOnlyWorldMatrix bindPropertiesForSubMesh bindView bindViewProjection buildUniformLayout clone dispose forceCompilation forceCompilationAsync freeze getActiveTextures getAlphaTestTexture getAnimatables getBindedMeshes getClassName getEffect getScene hasTexture isReady isReadyForSubMesh markAsDirty markDirty needAlphaBlending needAlphaBlendingForMesh needAlphaTesting needAlphaTestingForMesh resetDrawCache serialize setAlphaMode setPrePassRenderer toString unbind unfreeze Parse ParseAlphaMode

_imageProcessingConfiguration

_imageProcessingConfiguration: ImageProcessingConfiguration

Default configuration related to image processing available in the standard Material.

_imageProcessingObserver

_imageProcessingObserver: Nullable<Observer<ImageProcessingConfiguration>>

Keep track of the image processing observer to allow dispose and replace.

_useFuzzRoughnessFromTextureAlpha

_useFuzzRoughnessFromTextureAlpha: boolean = false

Specifies that the fuzz roughness is stored in the alpha channel of the texture. This is for compatibility with glTF where the fuzz roughness is often stored in the alpha channel of the fuzz color texture.

_useSubsurfaceWeightFromTextureAlpha

_useSubsurfaceWeightFromTextureAlpha: boolean = false

Specifies that the subsurface weight is stored in the alpha channel of the texture. This is for compatibility with glTF where the subsurface weight is stored in the alpha channel of the diffuseTransmissionTexture.

allowShaderHotSwapping: boolean = true

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)

animations: Nullable<Animation[]> = null

Stores the animations for the material

checkReadyOnEveryCall: boolean = false

Specifies if the ready state should be checked on each call

checkReadyOnlyOnce: boolean = false

Specifies if the ready state should be checked once

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

Custom callback helping to override the default shader used in the material.

depthFunction: number = 0

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

disableColorWrite: boolean = false

Specifies if color writing should be disabled

disableDepthWrite: boolean = false

Specifies if depth writing should be disabled

doNotSerialize: boolean = false

Specifies if the material should be serialized

forceDepthWrite: boolean = false

Specifies if depth writing should be forced

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

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)

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

metadata: any = null

Gets or sets user defined metadata

name: string

The name of the material

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

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> = null

Callback triggered when an error occurs

pluginManager?: MaterialPluginManager

Plugin manager for this material

pointSize: number = 1.0

Stores the size of points

prePassConfiguration: PrePassConfiguration

Defines additional PrePass parameters for the material.

reservedDataStore: any = null

For internal use only. Please do not use.

separateCullingPass: boolean = false

Specifies if there should be a separate pass for culling

shadowDepthWrapper: Nullable<ShadowDepthWrapper> = null

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

sideOrientation: Nullable<number> = null

Stores the value for side orientation

state: string = ""

The state of the material

stencil: MaterialStencilState = ...

Gives access to the stencil properties of the material

textureRepetitionHexTilingParams: number[] = ...

Parameters for the hex tiling texture repetition mode (TEXTURE_REPETITION_HEX_TILING). x = rotation strength (0..1, default 1.0) — how much each hex tile is rotated. y = fall-off contrast (0..1, default 0.6) — how much luminance affects blending weight at tile borders. z = exponent (1..20, default 7.0) — controls the sharpness of weight falloff between tiles. w = contrast (0..1, default 0.5) — boost blending contrast via Gain3 (0.5 = neutral, >0.5 = higher contrast).

https://jcgt.org/published/0011/03/05/

uniqueId: number

Gets or sets the unique id of the material

useCoatRoughnessFromWeightTexture: boolean = false

Specifies whether the coat roughness is taken from the same texture as the coat_weight.

zOffset: number = 0

Stores the z offset Factor value

zOffsetUnits: number = 0

Stores the z offset Units value

AllDirtyFlag: 127 = Constants.MATERIAL_AllDirtyFlag

The all dirty flag value

AttributesDirtyFlag: 8 = Constants.MATERIAL_AttributesDirtyFlag

The dirty attribute flag value

ClockWiseSideOrientation: 0 = Constants.MATERIAL_ClockWiseSideOrientation

Stores the clock-wise side orientation

CounterClockWiseSideOrientation: 1 = Constants.MATERIAL_CounterClockWiseSideOrientation

Stores the counter clock-wise side orientation

ForceGLSL: boolean = false

Force all the PBR materials to compile to glsl even on WebGPU engines. False by default. This is mostly meant for backward compatibility.

ForceVertexOutputInvariant: boolean = false

If true, all materials will have their vertex output set to invariant (see the vertexOutputInvariant property).

FresnelDirtyFlag: 4 = Constants.MATERIAL_FresnelDirtyFlag

The dirty fresnel flag value

ImageProcessingDirtyFlag: 64 = Constants.MATERIAL_ImageProcessingDirtyFlag

The dirty image processing flag value

LightDirtyFlag: 2 = Constants.MATERIAL_LightDirtyFlag

The dirty light flag value

LIGHTFALLOFF_GLTF: 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

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

LIGHTFALLOFF_STANDARD: 2

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

LineListDrawMode: 4 = Constants.MATERIAL_LineListDrawMode

Returns the line list draw mode

LineLoopDrawMode: 5 = Constants.MATERIAL_LineLoopDrawMode

Returns the line loop draw mode

LineStripDrawMode: 6 = Constants.MATERIAL_LineStripDrawMode

Returns the line strip draw mode

MATERIAL_ALPHABLEND: 2

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

MATERIAL_ALPHATEST: 1

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

MATERIAL_ALPHATESTANDBLEND: 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

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

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

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

MiscDirtyFlag: 16 = Constants.MATERIAL_MiscDirtyFlag

The dirty misc flag value

OnEventObservable: Observable<Material> = ...

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

PointFillMode: 2 = Constants.MATERIAL_PointFillMode

Returns the point fill mode

PointListDrawMode: 3 = Constants.MATERIAL_PointListDrawMode

Returns the point list draw mode

PrePassDirtyFlag: 32 = Constants.MATERIAL_PrePassDirtyFlag

The dirty prepass flag value

SSS_QUALITY_HIGH: 2

SSS convolution uses 32 samples.

SSS_QUALITY_LOW: 0

SSS convolution uses 8 samples.

SSS_QUALITY_MEDIUM: 1

SSS convolution uses 16 samples (default).

TextureDirtyFlag: 1 = Constants.MATERIAL_TextureDirtyFlag

The dirty texture flag value

TriangleFanDrawMode: 8 = Constants.MATERIAL_TriangleFanDrawMode

Returns the triangle fan draw mode

TriangleFillMode: 0 = Constants.MATERIAL_TriangleFillMode

Returns the triangle fill mode

TriangleStripDrawMode: 7 = Constants.MATERIAL_TriangleStripDrawMode

Returns the triangle strip draw mode

WireFrameFillMode: 1 = Constants.MATERIAL_WireFrameFillMode

Returns the wireframe mode

alphaCutOff: number

Defines the alpha limits in alpha test mode.

  • get alphaMode(): number

    Gets the value of the alpha mode

    Returns number

  • set alphaMode(value: number): void

    Sets the value of the alpha mode.

    ValueTypeDescription
    0ALPHA_DISABLE
    1ALPHA_ADDDefines that alpha blending is COLOR=SRC_ALPHA * SRC + DEST, ALPHA=DEST_ALPHA
    2ALPHA_COMBINEDefines that alpha blending is COLOR=SRC_ALPHA * SRC + (1 - SRC_ALPHA) * DEST, ALPHA=SRC_ALPHA + DEST_ALPHA
    3ALPHA_SUBTRACTDefines that alpha blending is COLOR=(1 - SRC) * DEST, ALPHA=SRC_ALPHA + DEST_ALPHA
    4ALPHA_MULTIPLYDefines that alpha blending is COLOR=DEST * SRC, ALPHA=SRC_ALPHA + DEST_ALPHA
    5ALPHA_MAXIMIZEDDefines that alpha blending is COLOR=SRC_ALPHA * SRC + (1 - SRC) * DEST, ALPHA=SRC_ALPHA + DEST_ALPHA
    6ALPHA_ONEONEDefines that alpha blending is COLOR=SRC + DEST, ALPHA=DEST_ALPHA
    7ALPHA_PREMULTIPLIEDDefines that alpha blending is COLOR=SRC + (1 - SRC_ALPHA) * DEST, ALPHA=SRC_ALPHA + DEST_ALPHA
    8ALPHA_PREMULTIPLIED_PORTERDUFFDefines that alpha blending is COLOR=SRC + (1 - SRC_ALPHA) * DEST, ALPHA=SRC_ALPHA + (1 - SRC_ALPHA) * DEST_ALPHA
    9ALPHA_INTERPOLATEDefines that alpha blending is COLOR=CST * SRC + (1 - CST) * DEST, ALPHA=CST_ALPHA * SRC + (1 - CST_ALPHA) * DEST_ALPHA
    10ALPHA_SCREENMODEDefines that alpha blending is COLOR=SRC + (1 - SRC) * DEST, ALPHA=SRC_ALPHA + (1 - SRC_ALPHA) * DEST_ALPHA
    11ALPHA_ONEONE_ONEONEDefines that alpha blending is COLOR=SRC + DST, ALPHA=SRC_ALPHA + DEST_ALPHA
    12ALPHA_ALPHATOCOLORDefines that alpha blending is COLOR=DEST_ALPHA * SRC + DST, ALPHA=0
    13ALPHA_REVERSEONEMINUSDefines that alpha blending is COLOR=(1 - DEST) * SRC + (1 - SRC) * DEST, ALPHA=(1 - DEST_ALPHA) * SRC_ALPHA + (1 - SRC_ALPHA) * DEST_ALPHA
    14ALPHA_SRC_DSTONEMINUSSRCALPHADefines that alpha blending is ALPHA=SRC + (1 - SRC ALPHA) * DEST, ALPHA=SRC_ALPHA + (1 - SRC ALPHA) * DEST_ALPHA
    15ALPHA_ONEONE_ONEZERODefines that alpha blending is COLOR=SRC + DST, ALPHA=SRC_ALPHA
    16ALPHA_EXCLUSIONDefines that alpha blending is COLOR=(1 - DEST) * SRC + (1 - SRC) * DEST, ALPHA=DEST_ALPHA
    17ALPHA_LAYER_ACCUMULATEDefines that alpha blending is COLOR=SRC_ALPHA * SRC + (1 - SRC ALPHA) * DEST, ALPHA=SRC_ALPHA + (1 - SRC_ALPHA) * DEST_ALPHA
    18ALPHA_MINDefines that alpha blending is COLOR=MIN(SRC, DEST), ALPHA=MIN(SRC_ALPHA, DEST_ALPHA)
    19ALPHA_MAXDefines that alpha blending is COLOR=MAX(SRC, DEST), ALPHA=MAX(SRC_ALPHA, DEST_ALPHA)
    20ALPHA_DUAL_SRC0_ADD_SRC1xDSTDefines that alpha blending uses dual source blending and is COLOR=SRC + SRC1 * DEST, ALPHA=DST_ALPHA
    21ALPHA_REPLACE_COLORDefines that alpha blending is COLOR=SRC, ALPHA=SRC_ALPHA + (1 - SRC_ALPHA) * DEST_ALPHA

    Parameters

    • value: number

    Returns void

ambientOcclusionTexture: Nullable<BaseTexture>

Defines the ambient occlusion texture.

applyDecalMapAfterDetailMap: boolean

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

baseColor: Color3

Color of the base diffuse lobe. See OpenPBR's specs for base_color

baseColorTexture: Nullable<BaseTexture>

Base Color Texture property. See OpenPBR's specs for base_color

baseDiffuseRoughness: number

Roughness of the diffuse lobe. See OpenPBR's specs for base_diffuse_roughness

baseDiffuseRoughnessTexture: Nullable<BaseTexture>

Roughness texture of the diffuse lobe. See OpenPBR's specs for base_diffuse_roughness

baseMetalness: number

Metalness of the base lobe. See OpenPBR's specs for base_metalness

baseMetalnessTexture: Nullable<BaseTexture>

Metalness texture. See OpenPBR's specs for base_metalness

baseWeight: number

Base Weight is a multiplier on the diffuse and metal lobes. See OpenPBR's specs for base_weight

baseWeightTexture: Nullable<BaseTexture>

Base Weight is a multiplier on the diffuse and metal lobes. See OpenPBR's specs for base_weight

  • get cameraColorCurves(): Nullable<ColorCurves>

    The color grading curves provide additional color adjustmnent 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

    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

coatColor: Color3

Defines the color of the clear coat on the surface. See OpenPBR's specs for coat_color

coatColorTexture: Nullable<BaseTexture>

Color texture of the clear coat. See OpenPBR's specs for coat_color

coatDarkening: number

Defines the amount that interreflections within the coat allow the underlying surface to be darkened. A value of 1.0 means that the physically correct amount of darkening is applied, while a value of 0.0 means that no darkening is applied. See OpenPBR's specs for coat_darkening

coatDarkeningTexture: Nullable<BaseTexture>

Defines the amount that interreflections within the coat allow the underlying surface to be darkened. A value of 1.0 means that the physically correct amount of darkening is applied, while a value of 0.0 means that no darkening is applied. See OpenPBR's specs for coat_darkening

coatIor: number

Defines the IOR of the clear coat on the surface. See OpenPBR's specs for coat_ior

coatRoughness: number

Defines the roughness of the clear coat on the surface. See OpenPBR's specs for coat_roughness

coatRoughnessAnisotropy: number

Defines the anisotropy of the clear coat on the surface. See OpenPBR's specs for coat_roughness_anisotropy

coatRoughnessAnisotropyTexture: Nullable<BaseTexture>

Anisotropic Roughness texture of the clear coat. See OpenPBR's specs for coat_roughness_anisotropy

coatRoughnessTexture: Nullable<BaseTexture>

Roughness texture of the clear coat. See OpenPBR's specs for coat_roughness

coatWeight: number

Defines the amount of clear coat on the surface. See OpenPBR's specs for coat_weight

coatWeightTexture: Nullable<BaseTexture>

Coat weight texture. See OpenPBR's specs for coat_weight

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.

disableLighting: boolean

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

emissionColor: Color3

Defines the color of the material's emission. See OpenPBR's specs for emission_color

emissionColorTexture: Nullable<BaseTexture>

Defines the texture of the material's emission color. See OpenPBR's specs for emission_color

emissionLuminance: number

Defines the luminance of the material's emission. See OpenPBR's specs for emission_luminance

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 normalmap 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.

forceIrradianceInFragment: boolean

Force the shader to compute irradiance in the fragment shader in order to take normal mapping into account.

forceNormalForward: boolean

Force normal to face away from face.

fuzzColor: Color3

Defines the color of the fuzz layer on the surface. See OpenPBR's specs for fuzz_color

fuzzColorTexture: Nullable<BaseTexture>

Color texture of the fuzz layer. See OpenPBR's specs for fuzz_color

fuzzRoughness: number

Defines the roughness of the fuzz layer on the surface. See OpenPBR's specs for fuzz_roughness

fuzzRoughnessTexture: Nullable<BaseTexture>

Roughness texture of the fuzz layer. See OpenPBR's specs for fuzz_roughness

fuzzWeight: number

Defines the weight of the fuzz layer on the surface. See OpenPBR's specs for fuzz_weight

fuzzWeightTexture: Nullable<BaseTexture>

Weight texture of the fuzz layer. See OpenPBR's specs for fuzz_weight

geometryCoatNormalTexture: Nullable<BaseTexture>

Defines the normal of the material's coat layer. See OpenPBR's specs for geometry_coat_normal

geometryCoatTangent: Vector2

Defines the tangent of the material's coat layer. Used only for anisotropic reflections. See OpenPBR's specs for geometry_coat_tangent

geometryCoatTangentTexture: Nullable<BaseTexture>

Defines the tangent of the material's coat layer. Used only for anisotropic reflections. See OpenPBR's specs for geometry_coat_tangent

geometryNormalTexture: Nullable<BaseTexture>

Defines the normal of the material's geometry. See OpenPBR's specs for geometry_normal

geometryOpacity: number

Defines the opacity of the material's geometry. See OpenPBR's specs for geometry_opacity

geometryOpacityTexture: Nullable<BaseTexture>

Defines the opacity texture of the material's geometry. See OpenPBR's specs for geometry_opacity

geometryTangent: Vector2

Defines the tangent of the material's geometry. Used only for anisotropic reflections. See OpenPBR's specs for geometry_tangent

geometryTangentTexture: Nullable<BaseTexture>

Defines the tangent of the material's geometry. Used only for anisotropic reflections. See OpenPBR's specs for geometry_tangent

geometryThickness: number

Defines the thickness of the material's geometry. Not part of OpenPBR's specs but useful for rasterization approximations of volume.

geometryThicknessTexture: Nullable<BaseTexture>

Defines the thickness of the material's geometry. Not part of OpenPBR's specs but useful for rasterization approximations of volume.

geometryThinWalled: number

Defines whether the geometry is thin-walled (like a sheet of paper) or not. See OpenPBR's specs for geometry_thin_walled

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).

  • get isVertexOutputInvariant(): boolean

    Gets or sets the vertex output invariant state Setting this property to true will force the shader compiler to disable some optimization to make sure the vertex output is always calculated the same way across different compilation units. You may need to enable this option if you are seeing some depth artifacts when using a depth pre-pass, for e.g. Note that this may have an impact on performance, so leave this option disabled if not needed.

    Returns boolean

  • set isVertexOutputInvariant(value: boolean): void

    Parameters

    • value: boolean

    Returns void

maxSimultaneousLights: number

Number of Simultaneous lights allowed on the material.

parallaxScaleBias: number

Controls the scale bias of the parallax mode.

specularColor: Color3

Color of the specular lobe. See OpenPBR's specs for specular_color

specularColorTexture: Nullable<BaseTexture>

Specular Color Texture property. See OpenPBR's specs for specular_color

specularIor: number

IOR of the specular lobe. See OpenPBR's specs for specular_ior

specularRoughness: number

Roughness of the specular lobe. See OpenPBR's specs for specular_roughness

specularRoughnessAnisotropy: number

Anisotropic roughness of the specular lobe. See OpenPBR's specs for specular_roughness_anisotropy

specularRoughnessAnisotropyTexture: Nullable<BaseTexture>

Anisotropic Roughness texture. See OpenPBR's specs for specular_roughness

specularRoughnessTexture: Nullable<BaseTexture>

Roughness texture of the specular lobe. See OpenPBR's specs for specular_roughness

specularWeight: number

Weight of the specular lobe. See OpenPBR's specs for specular_weight

specularWeightTexture: Nullable<BaseTexture>

Weight texture of the specular lobe. See OpenPBR's specs for specular_weight

subsurfaceColor: Color3

Defines the color of the subsurface scattering in the volume. See OpenPBR's specs for subsurface_color

subsurfaceColorTexture: Nullable<BaseTexture>

Subsurface color texture. See OpenPBR's specs for subsurface_color

subsurfaceRadius: number

Defines the radius of the subsurface scattering in the volume. See OpenPBR's specs for subsurface_radius

subsurfaceRadiusScale: Color3

Defines the scale factor applied to the subsurface radius. See OpenPBR's specs for subsurface_radius_scale

subsurfaceRadiusScaleTexture: Nullable<BaseTexture>

Subsurface radius scale texture. See OpenPBR's specs for subsurface_radius_scale

subsurfaceScatterAnisotropy: number

Defines the anisotropy of the subsurface scattering in the volume. See OpenPBR's specs for subsurface_scatter_anisotropy

subsurfaceWeight: number

Defines the amount of subsurface scattering on the surface. See OpenPBR's specs for subsurface_weight

subsurfaceWeightTexture: Nullable<BaseTexture>

Subsurface weight texture. See OpenPBR's specs for subsurface_weight

thinFilmIor: number

Defines the index of refraction of the thin film layer.

thinFilmThickness: number

Defines the thickness of the thin film layer in μm. If a texture is provided for thinFilmWeightTexture, this value will act as a multiplier to the texture values. See OpenPBR's specs for thin_film_thickness

thinFilmThicknessMin: number

Defines the minimum thickness of the thin film layer in μm.

thinFilmThicknessTexture: Nullable<BaseTexture>

Defines the maximum thickness of the thin film layer in μm.

thinFilmWeight: number

Defines the weight of the thin film layer on top of the base layer for iridescent effects.

thinFilmWeightTexture: Nullable<BaseTexture>

Thin film weight texture.

transmissionColor: Color3

Transmission color of the surface. See OpenPBR's specs for transmission_color

transmissionColorTexture: Nullable<BaseTexture>

Transmission color texture. See OpenPBR's specs for transmission_color

transmissionDepth: number

Transmission depth of the volume See OpenPBR's specs for transmission_depth

transmissionDepthTexture: Nullable<BaseTexture>

Transmission depth texture. See OpenPBR's specs for transmission_depth

transmissionDispersionAbbeNumber: number

Transmission Dispersion Abbe number. See OpenPBR's specs for transmission_dispersion_abbe_number

transmissionDispersionScale: number

Transmission Dispersion Scale factor. See OpenPBR's specs for transmission_dispersion_scale

transmissionDispersionScaleTexture: Nullable<BaseTexture>

Transmission Dispersion Scale texture. See OpenPBR's specs for transmission_dispersion_scale

transmissionScatter: Color3

Transmission scatter of the surface. See OpenPBR's specs for transmission_scatter

transmissionScatterAnisotropy: number

Transmission scatter anisotropy See OpenPBR's specs for transmission_scatter_anisotropy

transmissionScatterTexture: Nullable<BaseTexture>

Transmission scatter texture. See OpenPBR's specs for transmission_scatter

transmissionWeight: number

Transmission weight of the surface. See OpenPBR's specs for transmission_weight

transmissionWeightTexture: Nullable<BaseTexture>

Transmission weight texture. See OpenPBR's specs for transmission_weight

twoSidedLighting: boolean

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

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)

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.

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).

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)

useObjectSpaceNormalMap: boolean

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

useParallax: boolean

Allows using the normal map in parallax mode.

useParallaxOcclusion: boolean

Allows using the normal map in parallax occlusion mode.

  • 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

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.

useSpecularWeightFromTextureAlpha: boolean

Specifies that the specular weight is stored in the alpha channel of the specular weight texture.

  • get useVertexPulling(): boolean

    Tells the engine to draw geometry using vertex pulling instead of index drawing. This will automatically set the vertex buffers as storage buffers and make them accessible to the vertex shader (WebGPU only).

    Returns boolean

  • set useVertexPulling(value: boolean): void

    Parameters

    • value: boolean

    Returns void

_attachImageProcessingConfiguration

  • 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: this) => void

      the callback to be executed that will update the material

    Returns void

  • Binds the view matrix to the effect

    Parameters

    • effect: Effect

      defines the effect to bind the view matrix to

    • OptionalvariableName: string

      name of the shader variable that will hold the eye position

    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

  • Makes a duplicate of the current material.

    Parameters

    • name: string

      name to use for the new material.

    • cloneTexturesOnlyOnce: boolean = true

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

    • rootUrl: string = ""

      defines the root URL to use to load textures

    Returns OpenPBRMaterial

    cloned material instance

  • Disposes the resources of the material.

    Parameters

    • OptionalforceDisposeEffect: boolean

      Forces the disposal of effects.

    • OptionalforceDisposeTextures: boolean

      Forces the disposal of all textures.

    Returns void

  • Locks updates for the material.

    Note: while a material is frozen, the scene can still rebind it at least once per camera render (and again whenever another material was bound in between). What can be skipped while the frozen material stays cached are per-mesh updates performed during a rebind.

    This includes per-mesh morph target influences. If the same frozen material is shared across several meshes that each have different per-mesh morph influences, only the mesh that triggers the rebind updates those values. Other meshes rendered afterward with the same cached frozen material may reuse stale influences and render with the wrong values.

    For that scenario either keep the material unfrozen, clone the material per mesh and freeze each clone, or unfreeze() before changing influences and freeze() again afterwards.

    Returns void

  • Specifies if the material is ready to be used

    Parameters

    • Optionalmesh: AbstractMesh

      defines the mesh to check

    • OptionaluseInstances: boolean

      specifies if instances should be used

    Returns boolean

    a boolean indicating if the material is ready to be used

  • Specifies that the submesh is ready to be used.

    Parameters

    • mesh: AbstractMesh

      BJS mesh.

    • subMesh: SubMesh

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

    • OptionaluseInstances: boolean

      Specifies that instances should be used.

    Returns boolean

    • boolean indicating that the submesh is ready or not.

  • 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

    • forceMaterialDirty: boolean = false

      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 if the mesh will require alpha blending. Overridden to check geometry_opacity before the _hasTransparencyMode short-circuit in the base class, which would otherwise always return false when _transparencyMode is MATERIAL_OPAQUE.

    Parameters

    Returns boolean

    true if alpha blending is needed for the mesh

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

    Returns boolean

    a boolean specifying if an alpha test is needed.

    Please use needAlphaTestingForMesh instead

  • Specifies if material alpha testing should be turned on for the mesh

    Parameters

    Returns boolean

    a boolean specifying if alpha testing should be turned on for the mesh

  • Sets the value of the alpha mode for a specific target index.

    Parameters

    • value: number

      The alpha mode value to set.

    • targetIndex: number = 0

      The index of the target to set the alpha mode for. Defaults to 0.

    Returns void

  • 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

    • If prepass is enabled or not.

  • Returns a string representation of the current material

    Parameters

    • OptionalfullDetails: boolean

      defines a boolean indicating which levels of logging is desired

    Returns string

    a string with material information

  • Parses the alpha mode from the material data to parse

    Parameters

    • parsedMaterial: any

      defines the material data to parse

    • material: Material

      defines the material to update

    Returns void