import { type Nullable } from "../../types.js"; import { type Scene } from "../../scene.js"; import { Color3 } from "../../Maths/math.color.js"; import { ImageProcessingConfiguration } from "../imageProcessingConfiguration.js"; import { type BaseTexture } from "../../Materials/Textures/baseTexture.js"; import { Material } from "../material.js"; import { type Engine } from "../../Engines/engine.js"; import { type AbstractMesh } from "../../Meshes/abstractMesh.js"; import { MaterialDefines } from "../materialDefines.js"; import { PrePassConfiguration } from "../prePassConfiguration.js"; import { type IMaterialCompilationOptions } from "../../Materials/material.js"; import { type SubMesh } from "../../Meshes/subMesh.js"; import { Vector2, type Matrix } from "../../Maths/math.vector.js"; import { type Mesh } from "../../Meshes/mesh.js"; import { PushMaterial } from "../pushMaterial.js"; import { type IAnimatable } from "../../Animations/animatable.interface.js"; import { type UniformBuffer } from "../../Materials/uniformBuffer.js"; declare const OpenPBRMaterialDefinesBase_base: { new (...args: any[]): { MAINUV1: boolean; MAINUV2: boolean; MAINUV3: boolean; MAINUV4: boolean; MAINUV5: boolean; MAINUV6: boolean; UV1: boolean; UV2: boolean; UV3: boolean; UV4: boolean; UV5: boolean; UV6: boolean; }; } & typeof MaterialDefines; declare class OpenPBRMaterialDefinesBase extends OpenPBRMaterialDefinesBase_base { } declare const OpenPBRMaterialDefines_base: { new (...args: any[]): { IMAGEPROCESSING: boolean; VIGNETTE: boolean; VIGNETTEBLENDMODEMULTIPLY: boolean; VIGNETTEBLENDMODEOPAQUE: boolean; TONEMAPPING: number; CONTRAST: boolean; COLORCURVES: boolean; COLORGRADING: boolean; COLORGRADING3D: boolean; SAMPLER3DGREENDEPTH: boolean; SAMPLER3DBGRMAP: boolean; DITHER: boolean; IMAGEPROCESSINGPOSTPROCESS: boolean; SKIPFINALCOLORCLAMP: boolean; EXPOSURE: boolean; }; } & typeof OpenPBRMaterialDefinesBase; /** * Manages the defines for the PBR Material. * @internal */ export declare class OpenPBRMaterialDefines extends OpenPBRMaterialDefines_base { NUM_SAMPLES: string; REALTIME_FILTERING: boolean; IBL_CDF_FILTERING: boolean; VERTEXCOLOR: boolean; BAKED_VERTEX_ANIMATION_TEXTURE: boolean; VERTEXALPHA: boolean; ALPHATEST: boolean; DEPTHPREPASS: boolean; ALPHABLEND: boolean; ALPHA_FROM_BASE_COLOR_TEXTURE: boolean; ALPHATESTVALUE: string; PREMULTIPLYALPHA: boolean; REFLECTIVITY_GAMMA: boolean; REFLECTIVITYDIRECTUV: number; SPECULARTERM: boolean; LODBASEDMICROSFURACE: boolean; SPECULAR_ROUGHNESS_FROM_METALNESS_TEXTURE_GREEN: boolean; BASE_METALNESS_FROM_METALNESS_TEXTURE_BLUE: boolean; AOSTOREINMETALMAPRED: boolean; SPECULAR_WEIGHT_IN_ALPHA: boolean; SPECULAR_WEIGHT_FROM_SPECULAR_COLOR_TEXTURE: boolean; SPECULAR_ROUGHNESS_ANISOTROPY_FROM_TANGENT_TEXTURE: boolean; COAT_ROUGHNESS_FROM_GREEN_CHANNEL: boolean; COAT_ROUGHNESS_ANISOTROPY_FROM_TANGENT_TEXTURE: boolean; USE_GLTF_STYLE_ANISOTROPY: boolean; THIN_FILM_THICKNESS_FROM_THIN_FILM_TEXTURE: boolean; FUZZ_ROUGHNESS_FROM_TEXTURE_ALPHA: boolean; GEOMETRY_THICKNESS_FROM_GREEN_CHANNEL: boolean; ENVIRONMENTBRDF: boolean; ENVIRONMENTBRDF_RGBD: boolean; FUZZENVIRONMENTBRDF: boolean; NORMAL: boolean; TANGENT: boolean; OBJECTSPACE_NORMALMAP: boolean; PARALLAX: boolean; PARALLAX_RHS: boolean; PARALLAXOCCLUSION: boolean; NORMALXYSCALE: boolean; /** * Enables anisotropic logic. Still needed because it's used in pbrHelperFunctions */ ANISOTROPIC: boolean; /** * Tells the shader to use OpenPBR's anisotropic roughness remapping */ ANISOTROPIC_OPENPBR: boolean; /** * Tells the shader to apply anisotropy to the base layer */ ANISOTROPIC_BASE: boolean; /** * Tells the shader to apply anisotropy to the coat layer */ ANISOTROPIC_COAT: boolean; /** * Number of samples to use for the fuzz IBL lighting calculations */ FUZZ_IBL_SAMPLES: number; /** * Tells the shader to enable the fuzz layer */ FUZZ: boolean; /** * Tells the shader to enable the thin film layer */ THIN_FILM: boolean; /** * Tells the shader to enable the legacy iridescence code * Iridescence is the name of thin film interference in the PBR material. */ IRIDESCENCE: boolean; /** * Tells the shader to enable dispersion in refraction */ DISPERSION: boolean; /** * Enables subsurface scattering */ SCATTERING: boolean; /** * Refraction of the 2D background texture. Might include the rest of the scene or just the background. */ REFRACTED_BACKGROUND: boolean; /** * Refraction of direct lights. */ REFRACTED_LIGHTS: boolean; /** * Refraction of the environment texture (IBL). */ REFRACTED_ENVIRONMENT: boolean; REFRACTED_ENVIRONMENT_OPPOSITEZ: boolean; REFRACTED_ENVIRONMENT_LOCAL_CUBE: boolean; REFLECTION: boolean; REFLECTIONMAP_3D: boolean; REFLECTIONMAP_SPHERICAL: boolean; REFLECTIONMAP_PLANAR: boolean; REFLECTIONMAP_CUBIC: boolean; USE_LOCAL_REFLECTIONMAP_CUBIC: boolean; REFLECTIONMAP_PROJECTION: boolean; REFLECTIONMAP_SKYBOX: boolean; REFLECTIONMAP_EXPLICIT: boolean; REFLECTIONMAP_EQUIRECTANGULAR: boolean; REFLECTIONMAP_EQUIRECTANGULAR_FIXED: boolean; REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED: boolean; INVERTCUBICMAP: boolean; USESPHERICALFROMREFLECTIONMAP: boolean; USEIRRADIANCEMAP: boolean; USE_IRRADIANCE_DOMINANT_DIRECTION: boolean; USESPHERICALINVERTEX: boolean; REFLECTIONMAP_OPPOSITEZ: boolean; LODINREFLECTIONALPHA: boolean; GAMMAREFLECTION: boolean; RGBDREFLECTION: boolean; RADIANCEOCCLUSION: boolean; HORIZONOCCLUSION: boolean; INSTANCES: boolean; THIN_INSTANCES: boolean; INSTANCESCOLOR: boolean; PREPASS: boolean; PREPASS_COLOR: boolean; PREPASS_COLOR_INDEX: number; PREPASS_IRRADIANCE: boolean; PREPASS_IRRADIANCE_INDEX: number; PREPASS_ALBEDO: boolean; PREPASS_ALBEDO_INDEX: number; PREPASS_ALBEDO_SQRT: boolean; PREPASS_ALBEDO_SQRT_INDEX: number; PREPASS_DEPTH: boolean; PREPASS_DEPTH_INDEX: number; PREPASS_SCREENSPACE_DEPTH: boolean; PREPASS_SCREENSPACE_DEPTH_INDEX: number; PREPASS_NORMALIZED_VIEW_DEPTH: boolean; PREPASS_NORMALIZED_VIEW_DEPTH_INDEX: number; PREPASS_NORMAL: boolean; PREPASS_NORMAL_INDEX: number; PREPASS_NORMAL_WORLDSPACE: boolean; PREPASS_WORLD_NORMAL: boolean; PREPASS_WORLD_NORMAL_INDEX: number; PREPASS_POSITION: boolean; PREPASS_POSITION_INDEX: number; PREPASS_LOCAL_POSITION: boolean; PREPASS_LOCAL_POSITION_INDEX: number; PREPASS_VELOCITY: boolean; PREPASS_VELOCITY_INDEX: number; PREPASS_VELOCITY_LINEAR: boolean; PREPASS_VELOCITY_LINEAR_INDEX: number; PREPASS_REFLECTIVITY: boolean; PREPASS_REFLECTIVITY_INDEX: number; SCENE_MRT_COUNT: number; NUM_BONE_INFLUENCERS: number; BonesPerMesh: number; BONETEXTURE: boolean; BONES_VELOCITY_ENABLED: boolean; NONUNIFORMSCALING: boolean; MORPHTARGETS: boolean; MORPHTARGETS_POSITION: boolean; MORPHTARGETS_NORMAL: boolean; MORPHTARGETS_TANGENT: boolean; MORPHTARGETS_UV: boolean; MORPHTARGETS_UV2: boolean; MORPHTARGETS_COLOR: boolean; MORPHTARGETTEXTURE_HASPOSITIONS: boolean; MORPHTARGETTEXTURE_HASNORMALS: boolean; MORPHTARGETTEXTURE_HASTANGENTS: boolean; MORPHTARGETTEXTURE_HASUVS: boolean; MORPHTARGETTEXTURE_HASUV2S: boolean; MORPHTARGETTEXTURE_HASCOLORS: boolean; NUM_MORPH_INFLUENCERS: number; MORPHTARGETS_TEXTURE: boolean; USEPHYSICALLIGHTFALLOFF: boolean; USEGLTFLIGHTFALLOFF: boolean; TWOSIDEDLIGHTING: boolean; MIRRORED: boolean; SHADOWFLOAT: boolean; CLIPPLANE: boolean; CLIPPLANE2: boolean; CLIPPLANE3: boolean; CLIPPLANE4: boolean; CLIPPLANE5: boolean; CLIPPLANE6: boolean; POINTSIZE: boolean; FOG: boolean; LOGARITHMICDEPTH: boolean; CAMERA_ORTHOGRAPHIC: boolean; CAMERA_PERSPECTIVE: boolean; AREALIGHTSUPPORTED: boolean; FORCENORMALFORWARD: boolean; SPECULARAA: boolean; UNLIT: boolean; DECAL_AFTER_DETAIL: boolean; DEBUGMODE: number; USE_VERTEX_PULLING: boolean; VERTEX_PULLING_USE_INDEX_BUFFER: boolean; VERTEX_PULLING_INDEX_BUFFER_32BITS: boolean; RIGHT_HANDED: boolean; CLUSTLIGHT_SLICES: number; CLUSTLIGHT_BATCH: number; BRDF_V_HEIGHT_CORRELATED: boolean; MS_BRDF_ENERGY_CONSERVATION: boolean; SPHERICAL_HARMONICS: boolean; SPECULAR_GLOSSINESS_ENERGY_CONSERVATION: boolean; MIX_IBL_RADIANCE_WITH_IRRADIANCE: boolean; LEGACY_SPECULAR_ENERGY_CONSERVATION: boolean; BASE_DIFFUSE_MODEL: number; DIELECTRIC_SPECULAR_MODEL: number; CONDUCTOR_SPECULAR_MODEL: number; /** * Initializes the PBR Material defines. * @param externalProperties The external properties */ constructor(externalProperties?: { [name: string]: { type: string; default: any; }; }); /** * Resets the PBR Material defines. */ reset(): void; } declare const OpenPBRMaterialBase_base: { new (...args: any[]): { _imageProcessingConfiguration: ImageProcessingConfiguration; get imageProcessingConfiguration(): ImageProcessingConfiguration; set imageProcessingConfiguration(value: ImageProcessingConfiguration); _imageProcessingObserver: Nullable>; _attachImageProcessingConfiguration(configuration: Nullable): void; get cameraColorCurvesEnabled(): boolean; set cameraColorCurvesEnabled(value: boolean); get cameraColorGradingEnabled(): boolean; set cameraColorGradingEnabled(value: boolean); get cameraToneMappingEnabled(): boolean; set cameraToneMappingEnabled(value: boolean); get cameraExposure(): number; set cameraExposure(value: number); get cameraContrast(): number; set cameraContrast(value: number); get cameraColorGradingTexture(): Nullable; set cameraColorGradingTexture(value: Nullable); get cameraColorCurves(): Nullable; set cameraColorCurves(value: Nullable); }; } & typeof PushMaterial; declare class OpenPBRMaterialBase extends OpenPBRMaterialBase_base { } /** * 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 */ export declare class OpenPBRMaterial extends OpenPBRMaterialBase { /** * Base Weight is a multiplier on the diffuse and metal lobes. * See OpenPBR's specs for base_weight */ baseWeight: number; private _baseWeight; /** * Base Weight is a multiplier on the diffuse and metal lobes. * See OpenPBR's specs for base_weight */ baseWeightTexture: Nullable; private _baseWeightTexture; /** * Color of the base diffuse lobe. * See OpenPBR's specs for base_color */ baseColor: Color3; private _baseColor; /** * Base Color Texture property. * See OpenPBR's specs for base_color */ baseColorTexture: Nullable; private _baseColorTexture; /** * Roughness of the diffuse lobe. * See OpenPBR's specs for base_diffuse_roughness */ baseDiffuseRoughness: number; private _baseDiffuseRoughness; /** * Roughness texture of the diffuse lobe. * See OpenPBR's specs for base_diffuse_roughness */ baseDiffuseRoughnessTexture: Nullable; private _baseDiffuseRoughnessTexture; /** * Metalness of the base lobe. * See OpenPBR's specs for base_metalness */ baseMetalness: number; private _baseMetalness; /** * Metalness texture. * See OpenPBR's specs for base_metalness */ baseMetalnessTexture: Nullable; private _baseMetalnessTexture; /** * Weight of the specular lobe. * See OpenPBR's specs for specular_weight */ specularWeight: number; private _specularWeight; /** * Weight texture of the specular lobe. * See OpenPBR's specs for specular_weight */ specularWeightTexture: Nullable; private _specularWeightTexture; /** * Color of the specular lobe. * See OpenPBR's specs for specular_color */ specularColor: Color3; private _specularColor; /** * Specular Color Texture property. * See OpenPBR's specs for specular_color */ specularColorTexture: Nullable; private _specularColorTexture; /** * Roughness of the specular lobe. * See OpenPBR's specs for specular_roughness */ specularRoughness: number; private _specularRoughness; /** * Roughness texture of the specular lobe. * See OpenPBR's specs for specular_roughness */ specularRoughnessTexture: Nullable; private _specularRoughnessTexture; /** * Anisotropic roughness of the specular lobe. * See OpenPBR's specs for specular_roughness_anisotropy */ specularRoughnessAnisotropy: number; private _specularRoughnessAnisotropy; /** * Anisotropic Roughness texture. * See OpenPBR's specs for specular_roughness */ specularRoughnessAnisotropyTexture: Nullable; private _specularRoughnessAnisotropyTexture; /** * IOR of the specular lobe. * See OpenPBR's specs for specular_ior */ specularIor: number; private _specularIor; /** * Transmission weight of the surface. * See OpenPBR's specs for transmission_weight */ transmissionWeight: number; private _transmissionWeight; /** * Transmission weight texture. * See OpenPBR's specs for transmission_weight */ transmissionWeightTexture: Nullable; private _transmissionWeightTexture; /** * Transmission color of the surface. * See OpenPBR's specs for transmission_color */ transmissionColor: Color3; private _transmissionColor; /** * Transmission color texture. * See OpenPBR's specs for transmission_color */ transmissionColorTexture: Nullable; private _transmissionColorTexture; /** * Transmission depth of the volume * See OpenPBR's specs for transmission_depth */ transmissionDepth: number; private _transmissionDepth; /** * Transmission depth texture. * See OpenPBR's specs for transmission_depth */ transmissionDepthTexture: Nullable; private _transmissionDepthTexture; /** * Transmission scatter of the surface. * See OpenPBR's specs for transmission_scatter */ transmissionScatter: Color3; private _transmissionScatter; /** * Transmission scatter texture. * See OpenPBR's specs for transmission_scatter */ transmissionScatterTexture: Nullable; private _transmissionScatterTexture; /** * Transmission scatter anisotropy * See OpenPBR's specs for transmission_scatter_anisotropy */ transmissionScatterAnisotropy: number; private _transmissionScatterAnisotropy; /** * Transmission Dispersion Scale factor. * See OpenPBR's specs for transmission_dispersion_scale */ transmissionDispersionScale: number; private _transmissionDispersionScale; /** * Transmission Dispersion Scale texture. * See OpenPBR's specs for transmission_dispersion_scale */ transmissionDispersionScaleTexture: Nullable; private _transmissionDispersionScaleTexture; /** * Transmission Dispersion Abbe number. * See OpenPBR's specs for transmission_dispersion_abbe_number */ transmissionDispersionAbbeNumber: number; private _transmissionDispersionAbbeNumber; /** * Defines the amount of clear coat on the surface. * See OpenPBR's specs for coat_weight */ coatWeight: number; private _coatWeight; /** * Coat weight texture. * See OpenPBR's specs for coat_weight */ coatWeightTexture: Nullable; private _coatWeightTexture; /** * Defines the color of the clear coat on the surface. * See OpenPBR's specs for coat_color */ coatColor: Color3; private _coatColor; /** * Color texture of the clear coat. * See OpenPBR's specs for coat_color */ coatColorTexture: Nullable; private _coatColorTexture; /** * Defines the roughness of the clear coat on the surface. * See OpenPBR's specs for coat_roughness */ coatRoughness: number; private _coatRoughness; /** * Roughness texture of the clear coat. * See OpenPBR's specs for coat_roughness */ coatRoughnessTexture: Nullable; private _coatRoughnessTexture; /** * Defines the anisotropy of the clear coat on the surface. * See OpenPBR's specs for coat_roughness_anisotropy */ coatRoughnessAnisotropy: number; private _coatRoughnessAnisotropy; /** * Anisotropic Roughness texture of the clear coat. * See OpenPBR's specs for coat_roughness_anisotropy */ coatRoughnessAnisotropyTexture: Nullable; private _coatRoughnessAnisotropyTexture; /** * Defines the IOR of the clear coat on the surface. * See OpenPBR's specs for coat_ior */ coatIor: number; private _coatIor; /** * 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 */ coatDarkening: number; private _coatDarkening; /** * 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; private _coatDarkeningTexture; /** * Specifies whether the coat roughness is taken from the * same texture as the coat_weight. */ useCoatRoughnessFromWeightTexture: boolean; /** * Defines the weight of the fuzz layer on the surface. * See OpenPBR's specs for fuzz_weight */ fuzzWeight: number; private _fuzzWeight; /** * Weight texture of the fuzz layer. * See OpenPBR's specs for fuzz_weight */ fuzzWeightTexture: Nullable; private _fuzzWeightTexture; /** * Defines the color of the fuzz layer on the surface. * See OpenPBR's specs for fuzz_color */ fuzzColor: Color3; private _fuzzColor; /** * Color texture of the fuzz layer. * See OpenPBR's specs for fuzz_color */ fuzzColorTexture: Nullable; private _fuzzColorTexture; /** * Defines the roughness of the fuzz layer on the surface. * See OpenPBR's specs for fuzz_roughness */ fuzzRoughness: number; private _fuzzRoughness; /** * Roughness texture of the fuzz layer. * See OpenPBR's specs for fuzz_roughness */ fuzzRoughnessTexture: Nullable; private _fuzzRoughnessTexture; /** * Defines the normal of the material's geometry. * See OpenPBR's specs for geometry_normal */ geometryNormalTexture: Nullable; private _geometryNormalTexture; /** * Defines the tangent of the material's geometry. Used only for anisotropic reflections. * See OpenPBR's specs for geometry_tangent */ geometryTangent: Vector2; private _geometryTangent; /** * Defines the angle of the tangent of the material's geometry. Used only for anisotropic reflections. * See OpenPBR's specs for geometry_tangent */ get geometryTangentAngle(): number; set geometryTangentAngle(value: number); /** * Defines the tangent of the material's geometry. Used only for anisotropic reflections. * See OpenPBR's specs for geometry_tangent */ geometryTangentTexture: Nullable; private _geometryTangentTexture; /** * Defines the normal of the material's coat layer. * See OpenPBR's specs for geometry_coat_normal */ geometryCoatNormalTexture: Nullable; private _geometryCoatNormalTexture; /** * Defines the tangent of the material's coat layer. Used only for anisotropic reflections. * See OpenPBR's specs for geometry_coat_tangent */ geometryCoatTangent: Vector2; private _geometryCoatTangent; /** * Defines the angle of the tangent of the material's coat layer. */ get geometryCoatTangentAngle(): number; /** * Defines the angle of the tangent of the material's coat layer. */ set geometryCoatTangentAngle(value: number); /** * Defines the tangent of the material's coat layer. Used only for anisotropic reflections. * See OpenPBR's specs for geometry_coat_tangent */ geometryCoatTangentTexture: Nullable; private _geometryCoatTangentTexture; /** * Defines the opacity of the material's geometry. * See OpenPBR's specs for geometry_opacity */ geometryOpacity: number; private _geometryOpacity; /** * Defines the opacity texture of the material's geometry. * See OpenPBR's specs for geometry_opacity */ geometryOpacityTexture: Nullable; private _geometryOpacityTexture; /** * Defines the thickness of the material's geometry. * Not part of OpenPBR's specs but useful for rasterization approximations of volume. */ geometryThickness: number; private _geometryThickness; /** * Defines the thickness of the material's geometry. * Not part of OpenPBR's specs but useful for rasterization approximations of volume. */ geometryThicknessTexture: Nullable; private _geometryThicknessTexture; /** * Defines the luminance of the material's emission. * See OpenPBR's specs for emission_luminance */ emissionLuminance: number; private _emissionLuminance; /** * Defines the color of the material's emission. * See OpenPBR's specs for emission_color */ emissionColor: Color3; private _emissionColor; /** * Defines the texture of the material's emission color. * See OpenPBR's specs for emission_color */ emissionColorTexture: Nullable; private _emissionColorTexture; /** * Defines the weight of the thin film layer on top of the base layer for iridescent effects. */ thinFilmWeight: number; private _thinFilmWeight; /** * Thin film weight texture. */ thinFilmWeightTexture: Nullable; private _thinFilmWeightTexture; /** * 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 */ thinFilmThickness: number; private _thinFilmThickness; /** * Defines the minimum thickness of the thin film layer in μm. */ thinFilmThicknessMin: number; private _thinFilmThicknessMin; /** * Defines the maximum thickness of the thin film layer in μm. */ thinFilmThicknessTexture: Nullable; private _thinFilmThicknessTexture; /** * Defines the index of refraction of the thin film layer. */ thinFilmIor: number; private _thinFilmIor; /** * Defines the ambient occlusion texture. */ ambientOcclusionTexture: Nullable; private _ambientOcclusionTexture; private _propertyList; private _uniformsList; private _samplersList; private _samplerDefines; private static _noiseTextures; /** * Intensity of the direct lights e.g. the four lights available in your scene. * This impacts both the direct diffuse and specular highlights. */ directIntensity: 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. */ environmentIntensity: number; /** * Specifies that the specular weight is stored in the alpha channel of the specular weight texture. */ useSpecularWeightFromTextureAlpha: boolean; /** * Enforces alpha test in opaque or blend mode in order to improve the performances of some situations. */ forceAlphaTest: boolean; /** * Defines the alpha limits in alpha test mode. */ alphaCutOff: number; /** * Specifies if the metallic texture contains the ambient occlusion information in its red channel. */ useAmbientOcclusionFromMetallicTextureRed: boolean; /** * Specifies if the ambient texture contains the ambient occlusion information in its red channel only. */ useAmbientInGrayScale: 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. */ 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. */ set usePhysicalLightFalloff(value: boolean); /** * In order to support the falloff compatibility with gltf, a special mode has been added * to reproduce the gltf light falloff. */ get useGLTFLightFalloff(): boolean; /** * In order to support the falloff compatibility with gltf, a special mode has been added * to reproduce the gltf light falloff. */ set useGLTFLightFalloff(value: boolean); /** * Allows using an object space normal map (instead of tangent space). */ useObjectSpaceNormalMap: boolean; /** * Allows using the normal map in parallax mode. */ useParallax: boolean; /** * Allows using the normal map in parallax occlusion mode. */ useParallaxOcclusion: boolean; /** * Controls the scale bias of the parallax mode. */ parallaxScaleBias: number; /** * If sets to true, disables all the lights affecting the material. */ disableLighting: boolean; /** * Force the shader to compute irradiance in the fragment shader in order to take normal mapping into account. */ forceIrradianceInFragment: boolean; /** * Number of Simultaneous lights allowed on the material. */ maxSimultaneousLights: number; /** * If sets to true, x component of normal map value will invert (x = 1.0 - x). */ invertNormalMapX: boolean; /** * If sets to true, y component of normal map value will invert (y = 1.0 - y). */ invertNormalMapY: boolean; /** * If sets to true and backfaceCulling is false, normals will be flipped on the backside. */ twoSidedLighting: 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) */ 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 stays linear to compute the fresnel) */ useLinearAlphaFresnel: boolean; /** * Let user defines the brdf lookup texture used for IBL. * A default 8bit version is embedded but you could point at : * * Default texture: https://assets.babylonjs.com/environments/correlatedMSBRDF_RGBD.png * * Default 16bit pixel depth texture: https://assets.babylonjs.com/environments/correlatedMSBRDF.dds * * LEGACY Default None correlated https://assets.babylonjs.com/environments/uncorrelatedBRDF_RGBD.png * * LEGACY Default None correlated 16bit pixel depth https://assets.babylonjs.com/environments/uncorrelatedBRDF.dds */ environmentBRDFTexture: Nullable; /** * Force normal to face away from face. */ forceNormalForward: 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. */ enableSpecularAntiAliasing: 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). */ useHorizonOcclusion: 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. */ useRadianceOcclusion: boolean; /** * If set to true, no lighting calculations will be applied. */ unlit: boolean; /** * If sets to true, the decal map will be applied after the detail map. Else, it is applied before (default: false) */ applyDecalMapAfterDetailMap: boolean; /** * Force all the PBR materials to compile to glsl even on WebGPU engines. * False by default. This is mostly meant for backward compatibility. */ static ForceGLSL: boolean; /** * This stores the direct, emissive, environment, and specular light intensities into a Vector4. */ private _lightingInfos; /** * Stores the radiance (and, possibly, irradiance) values in a texture. * @internal */ _radianceTexture: Nullable; /** * Specifies that the specular weight will be read from the alpha channel. * This is for compatibility with glTF's KHR_materials_specular extension. * @internal */ _useSpecularWeightFromAlpha: boolean; /** * Specifies that the specular weight will be read from the alpha channel of the specular color texture. * This is for compatibility with glTF's KHR_materials_specular extension. * @internal */ _useSpecularWeightFromSpecularColorTexture: boolean; /** * Specifies if the material uses anisotropy weight read from the geometry tangent texture's blue channel. * This is for compatibility with glTF's anisotropy extension. * @internal */ _useSpecularRoughnessAnisotropyFromTangentTexture: boolean; /** * Specifies if the material uses coat anisotropy weight read from the coat's geometry tangent texture's blue channel. * This is for compatibility with glTF's clearcoat_anisotropy extension. * @internal */ _useCoatRoughnessAnisotropyFromTangentTexture: boolean; /** * Specifies whether the coat roughness is taken from the green channel of the coat texture. * This is for compatibility with glTF's KHR_materials_clearcoat and KHR_materials_coat extensions. * @internal */ _useCoatRoughnessFromGreenChannel: boolean; /** * Assume the anisotropy data is stored in the format specified by * KHR_materials_anisotropy. * @internal */ _useGltfStyleAnisotropy: boolean; /** * 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. */ _useFuzzRoughnessFromTextureAlpha: 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). * @internal */ _useHorizonOcclusion: 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. * @internal */ _useRadianceOcclusion: boolean; /** * Specifies that the alpha is coming from the base color texture's alpha channel. * This is for compatibility with glTF. * @internal */ _useAlphaFromBaseColorTexture: boolean; /** * Specifies if the metallic texture contains the ambient occlusion information in its red channel. * This is for compatibility with glTF. * @internal */ _useAmbientOcclusionFromMetallicTextureRed: boolean; /** * Specifies if the metallic texture contains the roughness information in its green channel. * This is for compatibility with glTF. * @internal */ _useRoughnessFromMetallicTextureGreen: boolean; /** * Specifies if the metallic texture contains the metallic information in its blue channel. * This is for compatibility with glTF. * @internal */ _useMetallicFromMetallicTextureBlue: boolean; /** * Specifies if the thin film thickness is stored in the green channel of the thin film thickness texture. * This is for compatibility with glTF. * @internal */ _useThinFilmThicknessFromTextureGreen: boolean; /** * Specifies if the geometry thickness is stored in the green channel of the geometry thickness texture. * This is for compatibility with glTF. * @internal */ _useGeometryThicknessFromGreenChannel: boolean; /** * Defines the falloff type used in this material. * It by default is Physical. * @internal */ _lightFalloff: number; /** * Allows using an object space normal map (instead of tangent space). * @internal */ _useObjectSpaceNormalMap: boolean; /** * Allows using the normal map in parallax mode. * @internal */ _useParallax: boolean; /** * Allows using the normal map in parallax occlusion mode. * @internal */ _useParallaxOcclusion: boolean; /** * Controls the scale bias of the parallax mode. * @internal */ _parallaxScaleBias: number; /** * If sets to true, disables all the lights affecting the material. * @internal */ _disableLighting: boolean; /** * Number of Simultaneous lights allowed on the material. * @internal */ _maxSimultaneousLights: number; /** * If sets to true, x component of normal map value will be inverted (x = 1.0 - x). * @internal */ _invertNormalMapX: boolean; /** * If sets to true, y component of normal map value will be inverted (y = 1.0 - y). * @internal */ _invertNormalMapY: boolean; /** * If sets to true and backfaceCulling is false, normals will be flipped on the backside. * @internal */ _twoSidedLighting: boolean; /** * Defines the alpha limits in alpha test mode. * @internal */ _alphaCutOff: number; /** * 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) * @internal */ _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 stays linear to compute the fresnel) * @internal */ _useLinearAlphaFresnel: boolean; /** * Specifies the environment BRDF texture used to compute the scale and offset roughness values * from cos theta and roughness: * http://blog.selfshadow.com/publications/s2013-shading-course/karis/s2013_pbs_epic_notes_v2.pdf * @internal */ _environmentBRDFTexture: Nullable; /** * Specifies the environment BRDF texture used to compute the scale and offset roughness values * from cos theta and roughness for the fuzz layer: * https://github.com/tizian/ltc-sheen?tab=readme-ov-file * @internal */ _environmentFuzzBRDFTexture: Nullable; private _backgroundRefractionTexture; /** * Set the texture used for refraction of the background of transparent materials * @internal */ get backgroundRefractionTexture(): Nullable; set backgroundRefractionTexture(texture: Nullable); /** * Force the shader to compute irradiance in the fragment shader in order to take normal mapping into account. * @internal */ _forceIrradianceInFragment: boolean; private _realTimeFiltering; /** * Enables realtime filtering on the texture. */ get realTimeFiltering(): boolean; set realTimeFiltering(b: boolean); private _realTimeFilteringQuality; /** * Quality switch for realtime filtering */ get realTimeFilteringQuality(): number; set realTimeFilteringQuality(n: number); private _fuzzSampleNumber; /** * The number of samples used to compute the fuzz IBL lighting. */ get fuzzSampleNumber(): number; set fuzzSampleNumber(n: number); /** * Can this material render to several textures at once */ get canRenderToMRT(): boolean; /** * Force normal to face away from face. * @internal */ _forceNormalForward: 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. * @internal */ _enableSpecularAntiAliasing: boolean; /** * Stores the available render targets. */ private _renderTargets; /** * If set to true, no lighting calculations will be applied. */ private _unlit; /** * If sets to true, the decal map will be applied after the detail map. Else, it is applied before (default: false) */ private _applyDecalMapAfterDetailMap; private _debugMode; private _shadersLoaded; private _breakShaderLoadedCheck; private _vertexPullingMetadata; /** * @internal * This is reserved for the inspector. * Defines the material debug mode. * It helps seeing only some components of the material while troubleshooting. */ debugMode: number; /** * @internal * This is reserved for the inspector. * Specify from where on screen the debug mode should start. * The value goes from -1 (full screen) to 1 (not visible) * It helps with side by side comparison against the final render * This defaults to -1 */ debugLimit: number; /** * @internal * This is reserved for the inspector. * As the default viewing range might not be enough (if the ambient is really small for instance) * You can use the factor to better multiply the final value. */ debugFactor: number; /** * Defines additional PrePass parameters for the material. */ readonly prePassConfiguration: PrePassConfiguration; protected _cacheHasRenderTargetTextures: boolean; /** * Instantiates a new OpenPBRMaterial instance. * * @param name The material name * @param scene The scene the material will be use in. * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false */ constructor(name: string, scene?: Scene, forceGLSL?: boolean); /** * Gets a boolean indicating that current material needs to register RTT */ get hasRenderTargetTextures(): boolean; /** * Can this material render to prepass */ get isPrePassCapable(): boolean; /** * @returns the name of the material class. */ getClassName(): string; protected _transparencyMode: number; get transparencyMode(): number; set transparencyMode(value: number); /** * @returns whether or not the alpha value of the albedo texture should be used for alpha blending. */ protected _shouldUseAlphaFromBaseColorTexture(): boolean; /** * @returns whether or not there is a usable alpha channel for transparency. */ protected _hasAlphaChannel(): boolean; /** * Makes a duplicate of the current material. * @param name - name to use for the new material. * @param cloneTexturesOnlyOnce - 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. * @param rootUrl defines the root URL to use to load textures * @returns cloned material instance */ clone(name: string, cloneTexturesOnlyOnce?: boolean, rootUrl?: string): OpenPBRMaterial; /** * Serializes this PBR Material. * @returns - An object with the serialized material. */ serialize(): any; /** * Parses a PBR Material from a serialized object. * @param source - Serialized object. * @param scene - BJS scene instance. * @param rootUrl - url for the scene object * @returns - OpenPBRMaterial */ static Parse(source: any, scene: Scene, rootUrl: string): OpenPBRMaterial; /** * Force shader compilation * @param mesh - Define the mesh we want to force the compilation for * @param onCompiled - Define a callback triggered when the compilation completes * @param options - Define the options used to create the compilation */ forceCompilation(mesh: AbstractMesh, onCompiled?: (material: Material) => void, options?: Partial): void; /** * Specifies that the submesh is ready to be used. * @param mesh - BJS mesh. * @param subMesh - A submesh of the BJS mesh. Used to check if it is ready. * @param useInstances - Specifies that instances should be used. * @returns - boolean indicating that the submesh is ready or not. */ isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean; /** * Initializes the uniform buffer layout for the shader. */ buildUniformLayout(): void; /** * Binds the material data (this function is called even if mustRebind() returns false) * @param uniformBuffer defines the Uniform buffer to fill in. * @param scene defines the scene the material belongs to. * @param engine defines the engine the material belongs to. * @param subMesh the submesh to bind data for */ bindPropertiesForSubMesh(uniformBuffer: UniformBuffer, scene: Scene, engine: Engine, subMesh: SubMesh): void; /** * Binds the submesh data. * @param world - The world matrix. * @param mesh - The BJS mesh. * @param subMesh - A submesh of the BJS mesh. */ bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void; /** * 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. */ getAnimatables(): IAnimatable[]; /** * Returns an array of the actively used textures. * @returns - Array of BaseTextures */ getActiveTextures(): BaseTexture[]; /** * Checks to see if a texture is used in the material. * @param texture - Base texture to use. * @returns - Boolean specifying if a texture is used in the material. */ hasTexture(texture: BaseTexture): boolean; /** * 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 - If prepass is enabled or not. */ setPrePassRenderer(): boolean; /** * Disposes the resources of the material. * @param forceDisposeEffect - Forces the disposal of effects. * @param forceDisposeTextures - Forces the disposal of all textures. */ dispose(forceDisposeEffect?: boolean, forceDisposeTextures?: boolean): void; /** * Returns the texture used for reflections. * @returns - Reflection texture if present. Otherwise, returns the environment texture. */ private _getRadianceTexture; private _prepareEffect; private _prepareDefines; } export {};