API
API|
@babylonjs/core|
StandardMaterial

Class StandardMaterial

This is the default material used in Babylon. It is the best trade off between quality and performances.

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

Hierarchy

  • StandardMaterialBase
    • StandardMaterial
Index
constructor
_imageProcessingConfiguration _imageProcessingObserver allowShaderHotSwapping alphaCutOff ambientColor animations checkReadyOnEveryCall checkReadyOnlyOnce clipPlane clipPlane2 clipPlane3 clipPlane4 clipPlane5 clipPlane6 customShaderNameResolve decalMap depthFunction detailMap diffuseColor disableColorWrite disableDepthWrite doNotSerialize emissiveColor forceDepthWrite getRenderTargetTextures id indexOfRefraction inspectableCustomProperties invertRefractionY metadata name onCompiled onDisposeObservable onError parallaxScaleBias pluginManager? pointSize prePassConfiguration reservedDataStore separateCullingPass shadowDepthWrapper sideOrientation specularColor specularPower state stencil textureRepetitionHexTilingParams uniqueId 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 TextureDirtyFlag TriangleFanDrawMode TriangleFillMode TriangleStripDrawMode WireFrameFillMode
alpha alphaMode alphaModes ambientTexture applyDecalMapAfterDetailMap backFaceCulling blockDirtyMechanism bumpTexture cameraColorCurves cameraColorCurvesEnabled cameraColorGradingEnabled cameraColorGradingTexture cameraContrast cameraExposure cameraToneMappingEnabled canRenderToMRT cullBackFaces diffuseFresnelParameters diffuseTexture disableLighting emissiveFresnelParameters emissiveTexture fillMode fogEnabled hasRenderTargetTextures imageProcessingConfiguration invertNormalMapX invertNormalMapY isFrozen isPrePassCapable isVertexOutputInvariant lightmapTexture linkEmissiveWithDiffuse maxSimultaneousLights needDepthPrePass onBind onBindObservable onDispose onEffectCreatedObservable onUnBindObservable opacityFresnelParameters opacityTexture pointsCloud reflectionFresnelParameters reflectionTexture refractionFresnelParameters refractionTexture roughness shaderLanguage skipOutOfRangeLighting specularTexture textureRepetitionMode transparencyMode twoSidedLighting useAlphaFromDiffuseTexture useEmissiveAsIllumination useGlossinessFromSpecularMapAlpha useLightmapAsShadowmap useLogarithmicDepth useObjectSpaceNormalMap useParallax useParallaxOcclusion useReflectionFresnelFromSpecular useReflectionOverAlpha useSpecularOverAlpha useVertexPulling wireframe AmbientTextureEnabled BumpTextureEnabled ColorGradingTextureEnabled DetailTextureEnabled DiffuseTextureEnabled EmissiveTextureEnabled FresnelEnabled LightmapTextureEnabled OpacityTextureEnabled ReflectionTextureEnabled RefractionTextureEnabled SpecularTextureEnabled
_attachImageProcessingConfiguration atomicMaterialsUpdate bind bindEyePosition bindForSubMesh bindOnlyNormalMatrix bindOnlyWorldMatrix 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.

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)

alphaCutOff: number = 0.4

Defines the alpha limits in alpha test mode.

ambientColor: Color3 = ...

The color of the material lit by the environmental background lighting.

https://doc.babylonjs.com/features/featuresDeepDive/materials/using/materials_introduction#ambient-color-example

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.

decalMap: Nullable<DecalMapConfiguration>

Defines the decal map parameters for the material.

depthFunction: number = 0

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

detailMap: DetailMapConfiguration

Defines the detail map parameters for the material.

diffuseColor: Color3 = ...

The basic color of the material as viewed under a light.

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

emissiveColor: Color3 = ...

Define the color of the material as if self lit. This will be mixed in the final result even in the absence of light.

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

indexOfRefraction: number = 0.98

In case of refraction, define the value of the index of refraction.

https://doc.babylonjs.com/features/featuresDeepDive/materials/using/reflectionTexture#how-to-obtain-reflections-and-refractions

inspectableCustomProperties: IInspectable[]

List of inspectable custom properties (used by the Inspector)

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

invertRefractionY: boolean = true

Invert the refraction texture alongside the y axis. It can be useful with procedural textures or probe for instance.

https://doc.babylonjs.com/features/featuresDeepDive/materials/using/reflectionTexture#how-to-obtain-reflections-and-refractions

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

parallaxScaleBias: number = 0.05

Apply a scaling factor that determine which "depth" the height map should reprensent. A value between 0.05 and 0.1 is reasonnable in Parallax, you can reach 0.2 using Parallax Occlusion.

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

specularColor: Color3 = ...

Define how the color and intensity of the highlight given by the light in the material.

specularPower: number = 64

Defines how sharp are the highlights in the material. The bigger the value the sharper giving a more glossy feeling to the result. Reversely, the smaller the value the blurrier giving a more rough feeling to the result.

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

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 standard 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

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

  • 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

ambientTexture: Nullable<BaseTexture>

AKA Occlusion Texture in other nomenclature, it helps adding baked shadows into your material.

applyDecalMapAfterDetailMap: boolean

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

bumpTexture: Nullable<BaseTexture>

Bump mapping is a technique to simulate bump and dents on a rendered surface. These are made by creating a normal map from an image. The means to do this can be found on the web, a search for 'normal map generator' will bring up free and paid for methods of doing this.

https://doc.babylonjs.com/features/featuresDeepDive/materials/using/moreMaterials#bump-map

  • 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

diffuseFresnelParameters: FresnelParameters

Define the diffuse fresnel parameters of the material.

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

diffuseTexture: Nullable<BaseTexture>

The basic texture of the material as viewed under a light.

disableLighting: boolean

Does lights from the scene impacts this material. It can be a nice trick for performance to disable lighting on a fully emissive material.

emissiveFresnelParameters: FresnelParameters

Define the emissive fresnel parameters of the material.

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

emissiveTexture: Nullable<BaseTexture>

Define texture of the material as if self lit. This will be mixed in the final result even in the absence of light.

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

lightmapTexture: Nullable<BaseTexture>

Complex lighting can be computationally expensive to compute at runtime. To save on computation, lightmaps may be used to store calculated lighting in a texture which will be applied to a given mesh.

https://doc.babylonjs.com/features/featuresDeepDive/lights/lights_introduction#lightmaps

linkEmissiveWithDiffuse: boolean

If true, some kind of energy conservation will prevent the end result to be more than 1 by reducing the emissive level when the final color is close to one.

maxSimultaneousLights: number

Defines the maximum number of lights that can be used in the material

opacityFresnelParameters: FresnelParameters

Define the opacity fresnel parameters of the material.

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

opacityTexture: Nullable<BaseTexture>

Define the transparency of the material from a texture. The final alpha value can be read either from the red channel (if texture.getAlphaFromRGB is false) or from the luminance or the current texel (if texture.getAlphaFromRGB is true)

reflectionFresnelParameters: FresnelParameters

Define the reflection fresnel parameters of the material.

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

reflectionTexture: Nullable<BaseTexture>

Define the texture used to display the reflection.

https://doc.babylonjs.com/features/featuresDeepDive/materials/using/reflectionTexture#how-to-obtain-reflections-and-refractions

refractionFresnelParameters: FresnelParameters

Define the refraction fresnel parameters of the material.

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

refractionTexture: Nullable<BaseTexture>

Define the texture used to display the refraction.

https://doc.babylonjs.com/features/featuresDeepDive/materials/using/reflectionTexture#how-to-obtain-reflections-and-refractions

roughness: number

Helps to define how blurry the reflections should appears in the material.

skipOutOfRangeLighting: boolean

If set to true, point and spot lights skip their lighting computations for fragments beyond the light range, where they contribute nothing. Only lights with a finite range are affected. The extra per-fragment test costs time when most fragments are within range of most lights, so only enable it for sparse lighting measured on the target devices (default: false).

specularTexture: Nullable<BaseTexture>

Define how the color and intensity of the highlight given by the light in the material.

twoSidedLighting: boolean

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

useAlphaFromDiffuseTexture: boolean

Does the transparency come from the diffuse texture alpha channel.

useEmissiveAsIllumination: boolean

If true, the emissive value is added into the end result, otherwise it is multiplied in.

useGlossinessFromSpecularMapAlpha: boolean

Defines if the glossiness/roughness of the material should be read from the specular map alpha channel

useLightmapAsShadowmap: boolean

In case of light mapping, define whether the map contains light or shadow informations.

useObjectSpaceNormalMap: boolean

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

useParallax: boolean

Is parallax enabled or not.

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

useParallaxOcclusion: boolean

Is parallax occlusion enabled or not. If true, the outcome is way more realistic than traditional Parallax but you can expect a performance hit that worthes consideration.

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

useReflectionFresnelFromSpecular: boolean

If true automatically deducts the fresnels values from the material specularity.

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

useReflectionOverAlpha: 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 exemple of that. When the street lights reflects on it you can not see what is behind.

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 exemple of that. When sun reflects on it you can not see what is behind.

  • 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 material, and gives it a new name

    Parameters

    • name: string

      defines the new name for the duplicated material

    • cloneTexturesOnlyOnce: boolean = true

      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.

    • rootUrl: string = ""

      defines the root URL to use to load textures

    Returns StandardMaterial

    the cloned material

  • Disposes the material

    Parameters

    • OptionalforceDisposeEffect: boolean

      specifies if effects should be forcefully disposed

    • OptionalforceDisposeTextures: boolean

      specifies if textures should be forcefully disposed

    Returns void

  • Force shader compilation

    Parameters

    • mesh: AbstractMesh

      defines the mesh associated with this material

    • OptionalonCompiled: (material: Material) => void

      defines a function to execute once the material is compiled

    • Optionaloptions: Partial<IMaterialCompilationOptions>

      defines the options to configure the compilation

    • OptionalonError: (reason: string) => void

      defines a function to execute if the material fails compiling

    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

  • Get if the submesh is ready to be used and all its information available. Child classes can use it to update shaders

    Parameters

    • mesh: AbstractMesh

      defines the mesh to check

    • subMesh: SubMesh

      defines which submesh to check

    • useInstances: boolean = false

      specifies that instances should be used

    Returns boolean

    a 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 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

  • 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