import { type Nullable } from "../../types.js"; import { Scene } from "../../scene.js"; import { type Matrix } from "../../Maths/math.vector.js"; import { type SubMesh } from "../../Meshes/subMesh.js"; import { type AbstractMesh } from "../../Meshes/abstractMesh.js"; import { type Mesh } from "../../Meshes/mesh.js"; import { PBRBRDFConfiguration } from "./pbrBRDFConfiguration.js"; import { PrePassConfiguration } from "../prePassConfiguration.js"; import { Color3 } from "../../Maths/math.color.js"; import { ImageProcessingConfiguration } from "../../Materials/imageProcessingConfiguration.js"; import { type IMaterialCompilationOptions, Material } from "../../Materials/material.js"; import { MaterialDefines } from "../../Materials/materialDefines.js"; import { PushMaterial } from "../../Materials/pushMaterial.js"; import { type BaseTexture } from "../../Materials/Textures/baseTexture.js"; import { type IAnimatable } from "../../Animations/animatable.interface.js"; import "../../Materials/Textures/baseTexture.polynomial.js"; import { PBRClearCoatConfiguration } from "./pbrClearCoatConfiguration.js"; import { PBRIridescenceConfiguration } from "./pbrIridescenceConfiguration.js"; import { PBRAnisotropicConfiguration } from "./pbrAnisotropicConfiguration.js"; import { PBRSheenConfiguration } from "./pbrSheenConfiguration.js"; import { PBRSubSurfaceConfiguration } from "./pbrSubSurfaceConfiguration.js"; import { DetailMapConfiguration } from "../material.detailMapConfiguration.js"; declare const PBRMaterialDefinesBase_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 PBRMaterialDefinesBase extends PBRMaterialDefinesBase_base { } declare const PBRMaterialDefines_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 PBRMaterialDefinesBase; /** * Manages the defines for the PBR Material. * @internal */ export declare class PBRMaterialDefines extends PBRMaterialDefines_base { PBR: boolean; NUM_SAMPLES: string; REALTIME_FILTERING: boolean; IBL_CDF_FILTERING: boolean; ALBEDO: boolean; GAMMAALBEDO: boolean; ALBEDODIRECTUV: number; VERTEXCOLOR: boolean; BASE_WEIGHT: boolean; BASE_WEIGHTDIRECTUV: number; BASE_DIFFUSE_ROUGHNESS: boolean; BASE_DIFFUSE_ROUGHNESSDIRECTUV: number; BAKED_VERTEX_ANIMATION_TEXTURE: boolean; AMBIENT: boolean; AMBIENTDIRECTUV: number; AMBIENTINGRAYSCALE: boolean; OPACITY: boolean; VERTEXALPHA: boolean; OPACITYDIRECTUV: number; OPACITYRGB: boolean; ALPHATEST: boolean; DEPTHPREPASS: boolean; ALPHABLEND: boolean; ALPHAFROMALBEDO: boolean; ALPHATESTVALUE: string; SPECULAROVERALPHA: boolean; RADIANCEOVERALPHA: boolean; ALPHAFRESNEL: boolean; LINEARALPHAFRESNEL: boolean; PREMULTIPLYALPHA: boolean; EMISSIVE: boolean; EMISSIVEDIRECTUV: number; GAMMAEMISSIVE: boolean; REFLECTIVITY: boolean; REFLECTIVITY_GAMMA: boolean; REFLECTIVITYDIRECTUV: number; SPECULARTERM: boolean; MICROSURFACEFROMREFLECTIVITYMAP: boolean; MICROSURFACEAUTOMATIC: boolean; LODBASEDMICROSFURACE: boolean; MICROSURFACEMAP: boolean; MICROSURFACEMAPDIRECTUV: number; METALLICWORKFLOW: boolean; ROUGHNESSSTOREINMETALMAPALPHA: boolean; ROUGHNESSSTOREINMETALMAPGREEN: boolean; METALLNESSSTOREINMETALMAPBLUE: boolean; AOSTOREINMETALMAPRED: boolean; METALLIC_REFLECTANCE: boolean; METALLIC_REFLECTANCE_GAMMA: boolean; METALLIC_REFLECTANCEDIRECTUV: number; METALLIC_REFLECTANCE_USE_ALPHA_ONLY: boolean; REFLECTANCE: boolean; REFLECTANCE_GAMMA: boolean; REFLECTANCEDIRECTUV: number; ENVIRONMENTBRDF: boolean; ENVIRONMENTBRDF_RGBD: boolean; NORMAL: boolean; TANGENT: boolean; BUMP: boolean; BUMPDIRECTUV: number; OBJECTSPACE_NORMALMAP: boolean; PARALLAX: boolean; PARALLAX_RHS: boolean; PARALLAXOCCLUSION: boolean; NORMALXYSCALE: boolean; LIGHTMAP: boolean; LIGHTMAPDIRECTUV: number; USELIGHTMAPASSHADOWMAP: boolean; GAMMALIGHTMAP: boolean; RGBDLIGHTMAP: 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; LINEARSPECULARREFLECTION: 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; MULTIVIEW: boolean; ORDER_INDEPENDENT_TRANSPARENCY: boolean; ORDER_INDEPENDENT_TRANSPARENCY_16BITS: 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; /** * 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 PBRBaseMaterialBase_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 PBRBaseMaterialBase extends PBRBaseMaterialBase_base { } /** * The Physically based material base class of BJS. * * This offers the main features of a standard PBR material. * For more information, please refer to the documentation : * https://doc.babylonjs.com/features/featuresDeepDive/materials/using/introToPBR * @see [WebGL](https://playground.babylonjs.com/#CGHTSM#1) * @see [WebGPU](https://playground.babylonjs.com/#CGHTSM#2) */ export declare abstract class PBRBaseMaterial extends PBRBaseMaterialBase { /** * PBRMaterialTransparencyMode: No transparency mode, Alpha channel is not use. */ static readonly PBRMATERIAL_OPAQUE = 0; /** * PBRMaterialTransparencyMode: Alpha Test mode, pixel are discarded below a certain threshold defined by the alpha cutoff value. */ static readonly PBRMATERIAL_ALPHATEST = 1; /** * PBRMaterialTransparencyMode: Pixels are blended (according to the alpha mode) with the already drawn pixels in the current frame buffer. */ static readonly PBRMATERIAL_ALPHABLEND = 2; /** * PBRMaterialTransparencyMode: Pixels are blended (according to the alpha mode) with the already drawn pixels in the current frame buffer. * They are also discarded below the alpha cutoff threshold to improve performances. */ static readonly PBRMATERIAL_ALPHATESTANDBLEND = 3; /** * Defines the default value of how much AO map is occluding the analytical lights * (point spot...). */ static DEFAULT_AO_ON_ANALYTICAL_LIGHTS: number; /** * PBRMaterialLightFalloff Physical: light is falling off following the inverse squared distance law. */ static readonly LIGHTFALLOFF_PHYSICAL = 0; /** * PBRMaterialLightFalloff gltf: light is falling off as described in the gltf moving to PBR document * to enhance interoperability with other engines. */ static readonly LIGHTFALLOFF_GLTF = 1; /** * PBRMaterialLightFalloff Standard: light is falling off like in the standard material * to enhance interoperability with other materials. */ static readonly LIGHTFALLOFF_STANDARD = 2; /** * 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; /** * Intensity of the direct lights e.g. the four lights available in your scene. * This impacts both the direct diffuse and specular highlights. * @internal */ _directIntensity: number; /** * Intensity of the emissive part of the material. * This helps controlling the emissive effect without modifying the emissive color. * @internal */ _emissiveIntensity: 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. * @internal */ _environmentIntensity: number; /** * This is a special control allowing the reduction of the specular highlights coming from the * four lights of the scene. Those highlights may not be needed in full environment lighting. * @internal */ _specularIntensity: number; /** * This stores the direct, emissive, environment, and specular light intensities into a Vector4. */ private _lightingInfos; /** * Debug Control allowing disabling the bump map on this material. * @internal */ _disableBumpMap: boolean; /** * AKA Diffuse Texture in standard nomenclature. * @internal */ _albedoTexture: Nullable; /** * Base Weight texture (multiplier to the diffuse and metal lobes). * @internal */ _baseWeightTexture: Nullable; /** * Base Diffuse Roughness texture (roughness of the diffuse lobe). * @internal */ _baseDiffuseRoughnessTexture: Nullable; /** * AKA Occlusion Texture in other nomenclature. * @internal */ _ambientTexture: Nullable; /** * AKA Occlusion Texture Intensity in other nomenclature. * @internal */ _ambientTextureStrength: number; /** * Defines how much the AO map is occluding the analytical lights (point spot...). * 1 means it completely occludes it * 0 mean it has no impact * @internal */ _ambientTextureImpactOnAnalyticalLights: number; /** * Stores the alpha values in a texture. * @internal */ _opacityTexture: Nullable; /** * Stores the reflection values in a texture. * @internal */ _reflectionTexture: Nullable; /** * Stores the emissive values in a texture. * @internal */ _emissiveTexture: Nullable; /** * AKA Specular texture in other nomenclature. * @internal */ _reflectivityTexture: Nullable; /** * Used to switch from specular/glossiness to metallic/roughness workflow. * @internal */ _metallicTexture: Nullable; /** * Specifies the metallic scalar of the metallic/roughness workflow. * Can also be used to scale the metalness values of the metallic texture. * @internal */ _metallic: Nullable; /** * Specifies the roughness scalar of the metallic/roughness workflow. * Can also be used to scale the roughness values of the metallic texture. * @internal */ _roughness: Nullable; /** * In metallic workflow, specifies an F0 factor to help configuring the material F0. * By default the indexOfrefraction is used to compute F0; * * This is used as a factor against the default reflectance at normal incidence to tweak it. * * F0 = defaultF0 * metallicF0Factor * metallicReflectanceColor; * F90 = metallicReflectanceColor; * @internal */ _metallicF0Factor: number; /** * In metallic workflow, specifies an F0 color. * By default the F90 is always 1; * * Please note that this factor is also used as a factor against the default reflectance at normal incidence. * * F0 = defaultF0_from_IOR * metallicF0Factor * metallicReflectanceColor * F90 = metallicF0Factor; * @internal */ _metallicReflectanceColor: Color3; /** * Specifies that only the A channel from _metallicReflectanceTexture should be used. * If false, both RGB and A channels will be used * @internal */ _useOnlyMetallicFromMetallicReflectanceTexture: boolean; /** * Defines to store metallicReflectanceColor in RGB and metallicF0Factor in A * This is multiply against the scalar values defined in the material. * @internal */ _metallicReflectanceTexture: Nullable; /** * Defines to store reflectanceColor in RGB * This is multiplied against the scalar values defined in the material. * If both _reflectanceTexture and _metallicReflectanceTexture textures are provided and _useOnlyMetallicFromMetallicReflectanceTexture * is false, _metallicReflectanceTexture takes precedence and _reflectanceTexture is not used * @internal */ _reflectanceTexture: Nullable; /** * Used to enable roughness/glossiness fetch from a separate channel depending on the current mode. * Gray Scale represents roughness in metallic mode and glossiness in specular mode. * @internal */ _microSurfaceTexture: Nullable; /** * Stores surface normal data used to displace a mesh in a texture. * @internal */ _bumpTexture: Nullable; /** * Stores the pre-calculated light information of a mesh in a texture. * @internal */ _lightmapTexture: Nullable; /** * The color of a material in ambient lighting. * @internal */ _ambientColor: Color3; /** * AKA Diffuse Color in other nomenclature. * @internal */ _albedoColor: Color3; /** * Base Weight (multiplier to the diffuse and metal lobes). * @internal */ _baseWeight: number; /** * Base Diffuse Roughness (roughness of the diffuse lobe). * Can also be used to scale the corresponding texture. * @internal */ _baseDiffuseRoughness: Nullable; /** * AKA Specular Color in other nomenclature. * @internal */ _reflectivityColor: Color3; /** * The color applied when light is reflected from a material. * @internal */ _reflectionColor: Color3; /** * The color applied when light is emitted from a material. * @internal */ _emissiveColor: Color3; /** * AKA Glossiness in other nomenclature. * @internal */ _microSurface: number; /** * Specifies that the material will use the light map as a show map. * @internal */ _useLightmapAsShadowmap: 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 form the albedo channel alpha channel for alpha blending. * @internal */ _useAlphaFromAlbedoTexture: boolean; /** * Specifies that the material will keeps the specular highlights over a transparent surface (only the most luminous ones). * A car glass is a good example of that. When sun reflects on it you can not see what is behind. * @internal */ _useSpecularOverAlpha: boolean; /** * Specifies if the reflectivity texture contains the glossiness information in its alpha channel. * @internal */ _useMicroSurfaceFromReflectivityMapAlpha: boolean; /** * Specifies if the metallic texture contains the roughness information in its alpha channel. * @internal */ _useRoughnessFromMetallicTextureAlpha: boolean; /** * Specifies if the metallic texture contains the roughness information in its green channel. * @internal */ _useRoughnessFromMetallicTextureGreen: boolean; /** * Specifies if the metallic texture contains the metallness information in its blue channel. * @internal */ _useMetallnessFromMetallicTextureBlue: boolean; /** * Specifies if the metallic texture contains the ambient occlusion information in its red channel. * @internal */ _useAmbientOcclusionFromMetallicTextureRed: boolean; /** * Specifies if the ambient texture contains the ambient occlusion information in its red channel only. * @internal */ _useAmbientInGrayScale: boolean; /** * In case the reflectivity map does not contain the microsurface information in its alpha channel, * The material will try to infer what glossiness each pixel should be. * @internal */ _useAutoMicroSurfaceFromReflectivityMap: boolean; /** * Defines the falloff type used in this material. * It by default is Physical. * @internal */ _lightFalloff: number; /** * Specifies that the material will keeps the reflection highlights over a transparent surface (only the most luminous ones). * A car glass is a good example of that. When the street lights reflects on it you can not see what is behind. * @internal */ _useRadianceOverAlpha: boolean; /** * Allows using an object space normal map (instead of tangent space). * @internal */ _useObjectSpaceNormalMap: boolean; /** * Allows using the bump map in parallax mode. * @internal */ _useParallax: boolean; /** * Allows using the bump 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; /** * Force the shader to compute irradiance in the fragment shader in order to take bump in 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); /** * 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 bump values. * @internal */ _enableSpecularAntiAliasing: boolean; /** * Stores the available render targets. */ private _renderTargets; /** * Sets the global ambient color for the material used in lighting calculations. */ private _globalAmbientColor; /** * If set to true, no lighting calculations will be applied. * @internal */ _unlit: boolean; /** * 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 the clear coat layer parameters for the material. */ readonly clearCoat: PBRClearCoatConfiguration; /** * Defines the iridescence layer parameters for the material. */ readonly iridescence: PBRIridescenceConfiguration; /** * Defines the anisotropic parameters for the material. */ readonly anisotropy: PBRAnisotropicConfiguration; /** * Defines the BRDF parameters for the material. */ readonly brdf: PBRBRDFConfiguration; /** * Defines the Sheen parameters for the material. */ readonly sheen: PBRSheenConfiguration; /** * Defines the SubSurface parameters for the material. */ readonly subSurface: PBRSubSurfaceConfiguration; /** * Defines additional PrePass parameters for the material. */ readonly prePassConfiguration: PrePassConfiguration; /** * Defines the detail map parameters for the material. */ readonly detailMap: DetailMapConfiguration; protected _cacheHasRenderTargetTextures: boolean; /** * Instantiates a new PBRMaterial 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; /** * Returns true if alpha blending should be disabled. */ protected get _disableAlphaBlending(): boolean; /** * @returns whether or not this material should be rendered in alpha blend mode. */ needAlphaBlending(): boolean; /** * @returns whether or not this material should be rendered in alpha test mode. */ needAlphaTesting(): boolean; /** * @returns whether or not the alpha value of the albedo texture should be used for alpha blending. */ protected _shouldUseAlphaFromAlbedoTexture(): boolean; /** * @returns whether or not there is a usable alpha channel for transparency. */ protected _hasAlphaChannel(): boolean; /** * @returns the texture used for the alpha test. */ getAlphaTestTexture(): Nullable; /** * 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; /** * Specifies if the material uses metallic roughness workflow. * @returns boolean specifying if the material uses metallic roughness workflow. */ isMetallicWorkflow(): boolean; private _prepareEffect; private _prepareDefines; /** * 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; /** * Initializes the uniform buffer layout for the shader. */ buildUniformLayout(): 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 the texture used for reflections. * @returns - Reflection texture if present. Otherwise, returns the environment texture. */ private _getReflectionTexture; /** * 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; } export {};