@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/core/Materials/PBR/pbrBaseMaterial.d.ts

@@ -0,0 +1,705 @@
+/**
+ * Manages the defines for the PBR Material.
+ * @internal
+ */
+export class PBRMaterialDefines extends MaterialDefines {
+    /**
+     * Initializes the PBR Material defines.
+     * @param externalProperties The external properties
+     */
+    constructor(externalProperties: any);
+    PBR: boolean;
+    NUM_SAMPLES: string;
+    REALTIME_FILTERING: boolean;
+    MAINUV1: boolean;
+    MAINUV2: boolean;
+    MAINUV3: boolean;
+    MAINUV4: boolean;
+    MAINUV5: boolean;
+    MAINUV6: boolean;
+    UV1: boolean;
+    UV2: boolean;
+    UV3: boolean;
+    UV4: boolean;
+    UV5: boolean;
+    UV6: boolean;
+    ALBEDO: boolean;
+    GAMMAALBEDO: boolean;
+    ALBEDODIRECTUV: number;
+    VERTEXCOLOR: boolean;
+    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;
+    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;
+    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_IRRADIANCE: boolean;
+    PREPASS_IRRADIANCE_INDEX: number;
+    PREPASS_ALBEDO_SQRT: boolean;
+    PREPASS_ALBEDO_SQRT_INDEX: number;
+    PREPASS_DEPTH: boolean;
+    PREPASS_DEPTH_INDEX: number;
+    PREPASS_NORMAL: boolean;
+    PREPASS_NORMAL_INDEX: number;
+    PREPASS_POSITION: boolean;
+    PREPASS_POSITION_INDEX: number;
+    PREPASS_VELOCITY: boolean;
+    PREPASS_VELOCITY_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_NORMAL: boolean;
+    MORPHTARGETS_TANGENT: boolean;
+    MORPHTARGETS_UV: boolean;
+    NUM_MORPH_INFLUENCERS: number;
+    MORPHTARGETS_TEXTURE: boolean;
+    IMAGEPROCESSING: boolean;
+    VIGNETTE: boolean;
+    VIGNETTEBLENDMODEMULTIPLY: boolean;
+    VIGNETTEBLENDMODEOPAQUE: boolean;
+    TONEMAPPING: boolean;
+    TONEMAPPING_ACES: boolean;
+    CONTRAST: boolean;
+    COLORCURVES: boolean;
+    COLORGRADING: boolean;
+    COLORGRADING3D: boolean;
+    SAMPLER3DGREENDEPTH: boolean;
+    SAMPLER3DBGRMAP: boolean;
+    DITHER: boolean;
+    IMAGEPROCESSINGPOSTPROCESS: boolean;
+    SKIPFINALCOLORCLAMP: boolean;
+    EXPOSURE: boolean;
+    MULTIVIEW: boolean;
+    ORDER_INDEPENDENT_TRANSPARENCY: boolean;
+    ORDER_INDEPENDENT_TRANSPARENCY_16BITS: boolean;
+    USEPHYSICALLIGHTFALLOFF: boolean;
+    USEGLTFLIGHTFALLOFF: boolean;
+    TWOSIDEDLIGHTING: boolean;
+    SHADOWFLOAT: boolean;
+    CLIPPLANE: boolean;
+    CLIPPLANE2: boolean;
+    CLIPPLANE3: boolean;
+    CLIPPLANE4: boolean;
+    CLIPPLANE5: boolean;
+    CLIPPLANE6: boolean;
+    POINTSIZE: boolean;
+    FOG: boolean;
+    LOGARITHMICDEPTH: boolean;
+    FORCENORMALFORWARD: boolean;
+    SPECULARAA: boolean;
+    UNLIT: boolean;
+    DEBUGMODE: number;
+}
+/**
+ * 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/how_to/physically_based_rendering
+ */
+export class PBRBaseMaterial extends PushMaterial {
+    /**
+     * Instantiates a new PBRMaterial instance.
+     *
+     * @param name The material name
+     * @param scene The scene the material will be use in.
+     */
+    constructor(name: any, scene: any);
+    /**
+     * 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.
+     */
+    _lightingInfos: Vector4;
+    /**
+     * Debug Control allowing disabling the bump map on this material.
+     * @internal
+     */
+    _disableBumpMap: boolean;
+    /**
+     * AKA Diffuse Texture in standard nomenclature.
+     * @internal
+     */
+    _albedoTexture: any;
+    /**
+     * AKA Occlusion Texture in other nomenclature.
+     * @internal
+     */
+    _ambientTexture: any;
+    /**
+     * 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: any;
+    /**
+     * Stores the reflection values in a texture.
+     * @internal
+     */
+    _reflectionTexture: any;
+    /**
+     * Stores the emissive values in a texture.
+     * @internal
+     */
+    _emissiveTexture: any;
+    /**
+     * AKA Specular texture in other nomenclature.
+     * @internal
+     */
+    _reflectivityTexture: any;
+    /**
+     * Used to switch from specular/glossiness to metallic/roughness workflow.
+     * @internal
+     */
+    _metallicTexture: any;
+    /**
+     * Specifies the metallic scalar of the metallic/roughness workflow.
+     * Can also be used to scale the metalness values of the metallic texture.
+     * @internal
+     */
+    _metallic: any;
+    /**
+     * Specifies the roughness scalar of the metallic/roughness workflow.
+     * Can also be used to scale the roughness values of the metallic texture.
+     * @internal
+     */
+    _roughness: any;
+    /**
+     * 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 F90 color to help configuring the material F90.
+     * 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 * metallicF0Factor * metallicReflectanceColor
+     * F90 = metallicReflectanceColor;
+     * @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: any;
+    /**
+     * 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: any;
+    /**
+     * 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: any;
+    /**
+     * Stores surface normal data used to displace a mesh in a texture.
+     * @internal
+     */
+    _bumpTexture: any;
+    /**
+     * Stores the pre-calculated light information of a mesh in a texture.
+     * @internal
+     */
+    _lightmapTexture: any;
+    /**
+     * The color of a material in ambient lighting.
+     * @internal
+     */
+    _ambientColor: Color3;
+    /**
+     * AKA Diffuse Color in other nomenclature.
+     * @internal
+     */
+    _albedoColor: Color3;
+    /**
+     * 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: import("@babylonjs/core").BaseTexture;
+    /**
+     * Force the shader to compute irradiance in the fragment shader in order to take bump in account.
+     * @internal
+     */
+    _forceIrradianceInFragment: boolean;
+    _realTimeFiltering: boolean;
+    _realTimeFilteringQuality: number;
+    /**
+     * 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;
+    /**
+     * Keep track of the image processing observer to allow dispose and replace.
+     */
+    _imageProcessingObserver: any;
+    /**
+     * Stores the available render targets.
+     */
+    _renderTargets: SmartArray<any>;
+    /**
+     * Sets the global ambient color for the material used in lighting calculations.
+     */
+    _globalAmbientColor: Color3;
+    /**
+     * Enables the use of logarithmic depth buffers, which is good for wide depth buffers.
+     */
+    _useLogarithmicDepth: boolean;
+    /**
+     * If set to true, no lighting calculations will be applied.
+     */
+    _unlit: boolean;
+    _debugMode: number;
+    /**
+     * @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;
+    _cacheHasRenderTargetTextures: boolean;
+    brdf: any;
+    clearCoat: any;
+    iridescence: any;
+    anisotropy: any;
+    sheen: any;
+    subSurface: PBRSubSurfaceConfiguration;
+    detailMap: any;
+    getRenderTargetTextures: () => SmartArray<any>;
+    prePassConfiguration: PrePassConfiguration;
+    set realTimeFiltering(arg: boolean);
+    /**
+     * Enables realtime filtering on the texture.
+     */
+    get realTimeFiltering(): boolean;
+    set realTimeFilteringQuality(arg: number);
+    /**
+     * Quality switch for realtime filtering
+     */
+    get realTimeFilteringQuality(): number;
+    /**
+     * Attaches a new image processing configuration to the PBR Material.
+     * @param configuration
+     */
+    _attachImageProcessingConfiguration(configuration: any): void;
+    _imageProcessingConfiguration: any;
+    /**
+     * Enabled the use of logarithmic depth buffers, which is good for wide depth buffers.
+     */
+    set useLogarithmicDepth(arg: boolean);
+    /**
+     * Enabled the use of logarithmic depth buffers, which is good for wide depth buffers.
+     */
+    get useLogarithmicDepth(): boolean;
+    /**
+     * Returns true if alpha blending should be disabled.
+     */
+    get _disableAlphaBlending(): boolean | undefined;
+    /**
+     * Specifies whether or not this material should be rendered in alpha blend mode.
+     */
+    needAlphaBlending(): any;
+    /**
+     * Specifies whether or not this material should be rendered in alpha test mode.
+     */
+    needAlphaTesting(): any;
+    /**
+     * Specifies whether or not the alpha value of the albedo texture should be used for alpha blending.
+     */
+    _shouldUseAlphaFromAlbedoTexture(): any;
+    /**
+     * Specifies whether or not there is a usable alpha channel for transparency.
+     */
+    _hasAlphaChannel(): any;
+    /**
+     * Gets the texture used for the alpha test.
+     */
+    getAlphaTestTexture(): any;
+    /**
+     * 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: any, subMesh: any, useInstances: any): boolean;
+    /**
+     * Specifies if the material uses metallic roughness workflow.
+     * @returns boolean specifying if the material uses metallic roughness workflow.
+     */
+    isMetallicWorkflow(): boolean;
+    _prepareEffect(mesh: any, defines: any, onCompiled: null | undefined, onError: null | undefined, useInstances: null | undefined, useClipPlane: null | undefined, useThinInstances: any): import("@babylonjs/core").Effect | null;
+    _prepareDefines(mesh: any, defines: any, useInstances?: null, useClipPlane?: null, useThinInstances?: boolean): void;
+    /**
+     * Force shader compilation
+     * @param mesh
+     * @param onCompiled
+     * @param options
+     */
+    forceCompilation(mesh: any, onCompiled: any, options: any): 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: any, mesh: any, subMesh: any): void;
+    /**
+     * Returns the texture used for reflections.
+     * @returns - Reflection texture if present.  Otherwise, returns the environment texture.
+     */
+    _getReflectionTexture(): any;
+    /**
+     * 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: any): boolean;
+    /**
+     * Sets the required values to the prepass renderer.
+     */
+    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: any, forceDisposeTextures: any): void;
+}
+export namespace PBRBaseMaterial {
+    const PBRMATERIAL_OPAQUE: number;
+    const PBRMATERIAL_ALPHATEST: number;
+    const PBRMATERIAL_ALPHABLEND: number;
+    const PBRMATERIAL_ALPHATESTANDBLEND: number;
+    const DEFAULT_AO_ON_ANALYTICAL_LIGHTS: number;
+    const LIGHTFALLOFF_PHYSICAL: number;
+    const LIGHTFALLOFF_GLTF: number;
+    const LIGHTFALLOFF_STANDARD: number;
+}
+import { MaterialDefines } from "../../Materials/materialDefines.js";
+import { PushMaterial } from "../../Materials/pushMaterial.js";
+import { Vector4 } from "../../Maths/math.vector.js";
+import { Color3 } from "../../Maths/math.color.js";
+import { SmartArray } from "../../Misc/smartArray.js";
+import { PBRSubSurfaceConfiguration } from "./pbrSubSurfaceConfiguration.js";
+import { PrePassConfiguration } from "../prePassConfiguration.js";