import { type Nullable } from "@onerjs/core/types.js"; import { type Matrix, Vector3 } from "@onerjs/core/Maths/math.vector.js"; import { type IAnimatable } from "@onerjs/core/Animations/animatable.interface.js"; import { type BaseTexture } from "@onerjs/core/Materials/Textures/baseTexture.js"; import { PushMaterial } from "@onerjs/core/Materials/pushMaterial.js"; import { type AbstractMesh } from "@onerjs/core/Meshes/abstractMesh.js"; import { type SubMesh } from "@onerjs/core/Meshes/subMesh.js"; import { type Mesh } from "@onerjs/core/Meshes/mesh.js"; import { Scene } from "@onerjs/core/scene.js"; /** * Max value the sky shader may write before the bound render target stores it as +Inf (which would * corrupt anything reading the texture back, e.g. an IBL CDF). Derived from the RT's texture type: * half-float caps at its 65504 ceiling; float is effectively unbounded (a huge finite +Inf guard); * anything else (8-bit LDR, or the default framebuffer when no RT is bound) is [0,1]. Only used when * `rawHdrOutput` is enabled. * @param textureType the bound render target's texture type (Constants.TEXTURETYPE_*), or undefined * @returns the maximum color value that can be stored without overflowing to +Inf * @internal */ export declare function _MaxColorValueForRenderTarget(textureType: number | undefined): number; /** * This is the sky material which allows to create dynamic and texture free effects for skyboxes. * @see https://doc.babylonjs.com/toolsAndResources/assetLibraries/materialsLibrary/skyMat */ export declare class SkyMaterial extends PushMaterial { /** * Defines the overall luminance of sky in interval ]0, 1[. */ luminance: number; /** * Defines the amount (scattering) of haze as opposed to molecules in atmosphere. */ turbidity: number; /** * Defines the sky appearance (light intensity). */ rayleigh: number; /** * Defines the mieCoefficient in interval [0, 0.1] which affects the property .mieDirectionalG. */ mieCoefficient: number; /** * Defines the amount of haze particles following the Mie scattering theory. */ mieDirectionalG: number; /** * Defines the distance of the sun according to the active scene camera. */ distance: number; /** * Defines the sun inclination, in interval [-0.5, 0.5]. When the inclination is not 0, the sun is said * "inclined". */ inclination: number; /** * Defines the solar azimuth in interval [0, 1]. The azimuth is the angle in the horizontal plan between * an object direction and a reference direction. */ azimuth: number; /** * Defines the sun position in the sky on (x,y,z). If the property .useSunPosition is set to false, then * the property is overridden by the inclination and the azimuth and can be read at any moment. */ sunPosition: Vector3; /** * Defines if the sun position should be computed (inclination and azimuth) according to the given * .sunPosition property. */ useSunPosition: boolean; /** * Defines an offset vector used to get a horizon offset. * @example skyMaterial.cameraOffset.y = camera.globalPosition.y // Set horizon relative to 0 on the Y axis */ cameraOffset: Vector3; /** * Defines the vector the skyMaterial should consider as up. (default is Vector3(0, 1, 0) as returned by Vector3.Up()) */ up: Vector3; /** * Defines if sky should be dithered. */ dithering: boolean; /** * When enabled, the material emits scene-referred linear HDR: `luminance` acts as a plain linear * gain (no filmic tonemap), the output is clamped to the bound render target's max representable * value rather than [0, 1] (so a bright sun cannot overflow to +Inf), and no sRGB encode is * applied. Enable this to bake the sky into an HDR (float / half-float) render target — e.g. an * IBL environment cube — where the full dynamic range of the sun disc must be preserved. The * clamp ceiling follows whatever target is bound at draw time (65504 for half-float, effectively * unbounded for float); if the sky is drawn to an LDR target or the default framebuffer it falls * back to [0, 1], so this flag is only meaningful when rendering into a float/half-float target. * When disabled, the material produces tonemapped, display-referred output for direct viewing. */ rawHdrOutput: boolean; /** * Cloud cover over the sun in [0, 1] (0 = clear direct sun, default; 1 = sun fully hidden). This * softens only the *sun disc* — the sky dome color itself is unchanged (there is no overcast * graying or whitening of the sky). At 0 the sun is a sharp solar disc; above 0 a physically- * based single-scattering cloud model attenuates the direct beam (Beer–Lambert) and redistributes * the removed energy into a dual-lobe Henyey–Greenstein aureole, energy-conserving as it broadens * (thin cloud → tight silver lining; heavy cloud → broad, directionless glow). See the sun-disc * branch in sky.fragment for the model + references. */ cloudiness: number; private _cameraPosition; private _skyOrientation; private static readonly _ShaderLoader; /** * Instantiates a new sky material. * This material allows to create dynamic and texture free * effects for skyboxes by taking care of the atmosphere state. * @see https://doc.babylonjs.com/toolsAndResources/assetLibraries/materialsLibrary/skyMat * @param name Define the name of the material in the scene * @param scene Define the scene the material belong to * @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false */ constructor(name: string, scene?: Scene, forceGLSL?: boolean); /** * Specifies if the material will require alpha blending * @returns a boolean specifying if alpha blending is needed */ needAlphaBlending(): boolean; /** * Specifies if this material should be rendered in alpha test mode * @returns false as the sky material doesn't need alpha testing. */ needAlphaTesting(): boolean; /** * Get the texture used for alpha test purpose. * @returns null as the sky material has no texture. */ getAlphaTestTexture(): Nullable; /** * Get if the submesh is ready to be used and all its information available. * Child classes can use it to update shaders * @param mesh defines the mesh to check * @param subMesh defines which submesh to check * @returns a boolean indicating that the submesh is ready or not */ isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh): boolean; /** * Binds the submesh to this material by preparing the effect and shader to draw * @param world defines the world transformation matrix * @param mesh defines the mesh containing the submesh * @param subMesh defines the submesh to bind the material to */ bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void; /** * Get the list of animatables in the material. * @returns the list of animatables object used in the material */ getAnimatables(): IAnimatable[]; /** * Disposes the material * @param forceDisposeEffect specifies if effects should be forcefully disposed */ dispose(forceDisposeEffect?: boolean): void; /** * Makes a duplicate of the material, and gives it a new name * @param name defines the new name for the duplicated material * @returns the cloned material */ clone(name: string): SkyMaterial; /** * Serializes this material in a JSON representation * @returns the serialized material object */ serialize(): any; /** * Gets the current class name of the material e.g. "SkyMaterial" * Mainly use in serialization. * @returns the class name */ getClassName(): string; /** * Creates a sky material from parsed material data * @param source defines the JSON representation of the material * @param scene defines the hosting scene * @param rootUrl defines the root URL to use to load textures and relative dependencies * @returns a new sky material */ static Parse(source: any, scene: Scene, rootUrl: string): SkyMaterial; }