@mml-io/3d-web-client-core 0.21.6 → 0.23.0

package/build/input/KeyInputManager.d.ts

@@ -18,6 +18,7 @@ export declare class KeyInputManager {
     private onKeyUp;
     isKeyPressed(key: string): boolean;
     createKeyBinding(key: Key, callback: () => void): void;
+    removeKeyBinding(key: Key): void;
     isMovementKeyPressed(): boolean;
     private getForward;
     private getBackward;

package/build/math/Box.d.ts

@@ -0,0 +1,16 @@
+import { Matr4 } from "./Matr4";
+import { IVect3, Vect3 } from "./Vect3";
+export declare class Box {
+    min: Vect3;
+    max: Vect3;
+    constructor(min?: IVect3, max?: IVect3);
+    setStart(min: IVect3): this;
+    setEnd(max: IVect3): this;
+    length(): number;
+    clone(): Box;
+    copy(other: Box): this;
+    expandByPoint(point: Vect3): this;
+    makeEmpty(): this;
+    isEmpty(): boolean;
+    applyMatrix4(matr4: Matr4): this | undefined;
+}

package/build/math/EulXYZ.d.ts

@@ -0,0 +1,24 @@
+import { Matr4 } from "./Matr4";
+export declare class EulXYZ {
+    private static tempMatrix;
+    x: number;
+    y: number;
+    z: number;
+    constructor(x?: number | EulXYZ, y?: number, z?: number);
+    setFromRotationMatrix(m: Matr4): this;
+    setFromQuaternion(q: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    }): this;
+    copy(other: {
+        x?: number;
+        y?: number;
+        z?: number;
+    }): this;
+    length(): number;
+    lengthSquared(): number;
+    clone(): EulXYZ;
+    set(x: number, y: number, z: number): this;
+}

package/build/math/Line.d.ts

@@ -0,0 +1,19 @@
+import { Matr4 } from "./Matr4";
+import { IVect3, Vect3 } from "./Vect3";
+export declare class Line {
+    start: Vect3;
+    end: Vect3;
+    constructor(start?: IVect3, end?: IVect3);
+    setStart(start: IVect3): this;
+    setEnd(end: IVect3): this;
+    length(): number;
+    lengthSquared(): number;
+    clone(): Line;
+    copy(other: Line): this;
+    applyMatrix4(matr4: Matr4): this;
+    distance(): number;
+    at(t: number, target: Vect3): Vect3;
+    closestPointToPointParameter(point: Vect3, clampToLine: boolean): number;
+    closestPointToPoint(point: Vect3, clampToLine: boolean, target: Vect3): Vect3;
+    delta(target: Vect3): Vect3;
+}

package/build/math/Matr4.d.ts

@@ -0,0 +1,77 @@
+import { Quat } from "./Quat";
+import { Vect3 } from "./Vect3";
+export type Matr4Data = [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+export declare class Matr4 {
+    static tempMatr4: Matr4;
+    static tempVect3: Vect3;
+    static tempQuat: Quat;
+    data: Matr4Data;
+    constructor(data?: Matr4Data | Matr4 | Float32Array | Array<number>);
+    identity(): this;
+    copy(m: Matr4): Matr4;
+    set(...args: Matr4Data | [Float32Array] | [Matr4Data] | [Array<number>]): this;
+    setRotationFromQuaternion(q: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    }): this;
+    clone(): Matr4;
+    determinant(): number;
+    makeRotationX(theta: number): this;
+    makeRotationY(theta: number): this;
+    makeRotationZ(theta: number): this;
+    makeTranslation(x: number, y: number, z: number): this;
+    makeScale(x: number, y: number, z: number): this;
+    compose(position: {
+        x: number;
+        y: number;
+        z: number;
+    }, quaternion: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    }, scale: {
+        x: number;
+        y: number;
+        z: number;
+    }): this;
+    decompose(position: {
+        x: number;
+        y: number;
+        z: number;
+    }, quaternion: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    }, scale: {
+        x: number;
+        y: number;
+        z: number;
+    }): this;
+    multiply(m: Matr4): this;
+    premultiply(m: Matr4): this;
+    multiplyMatrices(a: Matr4, b: Matr4): this;
+    invert(): this;
+    equals(other: Matr4): boolean;
+    setPosition(x: number, y: number, z: number): this;
+}

package/build/math/Quat.d.ts

@@ -0,0 +1,57 @@
+import { Matr4 } from "./Matr4";
+export declare class Quat {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+    constructor(x?: number | Quat, y?: number, z?: number, w?: number);
+    copy(other: {
+        x?: number;
+        y?: number;
+        z?: number;
+        w?: number;
+    }): this;
+    multiply(q: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    }): this;
+    premultiply(q: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    }): this;
+    multiplyQuaternions(a: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    }, b: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    }): this;
+    setFromEulerXYZ(euler: {
+        x: number;
+        y: number;
+        z: number;
+    }): this;
+    setFromRotationMatrix(m: Matr4): this;
+    setFromAxisAngle(axis: {
+        x: number;
+        y: number;
+        z: number;
+    }, angle: number): this;
+    clone(): Quat;
+    set(x: number, y: number, z: number, w: number): this;
+    invert(): this;
+    dot(other: Quat): number;
+    rotateTowards(other: Quat, scalar: number): this;
+    angleTo(q: Quat): number;
+    slerp(qb: Quat, t: number): this;
+    length(): number;
+    normalize(): this;
+}

package/build/math/Ray.d.ts

@@ -0,0 +1,15 @@
+import { Matr4 } from "./Matr4";
+import { IVect3, Vect3 } from "./Vect3";
+export declare class Ray {
+    origin: Vect3;
+    direction: Vect3;
+    constructor(origin?: IVect3, direction?: IVect3);
+    setOrigin(origin: IVect3): this;
+    setDirection(direction: IVect3): this;
+    clone(): Ray;
+    set(origin: IVect3, direction: IVect3): this;
+    copy(ray: Ray): this;
+    applyMatrix4(matr4: Matr4): this;
+    intersectTriangle(a: Vect3, b: Vect3, c: Vect3, backfaceCulling: boolean, target: Vect3): Vect3 | null;
+    at(t: number, target: Vect3): Vect3;
+}

package/build/math/Vect3.d.ts

@@ -0,0 +1,45 @@
+import { EulXYZ } from "./EulXYZ";
+import { Matr4, Matr4Data } from "./Matr4";
+import { Quat } from "./Quat";
+export type IVect3 = {
+    x: number;
+    y: number;
+    z: number;
+};
+export declare class Vect3 {
+    x: number;
+    y: number;
+    z: number;
+    constructor(x?: number | IVect3, y?: number, z?: number);
+    copy(other: IVect3): this;
+    length(): number;
+    lengthSquared(): number;
+    clone(): Vect3;
+    set(x: number, y: number, z: number): this;
+    applyEulerXYZ(euler: EulXYZ): this;
+    applyMatrix4(matrix: {
+        data: Matr4Data;
+    }): this;
+    transformDirection(matrix: Matr4): this;
+    add(other: IVect3): this;
+    sub(other: IVect3): this;
+    applyQuat(q: Quat): this;
+    multiplyScalar(scalar: number): this;
+    normalize(): this;
+    addScaledVector(other: Vect3, scalar: number): this;
+    distanceTo(other: Vect3): number;
+    distanceToSquared(other: Vect3): number;
+    applyAxisAngle(axis: IVect3, angle: number): this;
+    min(point: IVect3): this;
+    max(point: IVect3): this;
+    subVectors(a: IVect3, b: IVect3): this;
+    dot(v: IVect3): number;
+    cross(other: Vect3): this;
+    crossVectors(a: Vect3, b: Vect3): this;
+    subScalar(s: number): this;
+    addScalar(s: number): this;
+    multiply(other: IVect3): this;
+    lerp(target: IVect3, alpha: number): Vect3;
+    lerpVectors(v1: IVect3, v2: IVect3, alpha: number): Vect3;
+    toArray(): number[];
+}

package/build/math/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./EulXYZ";
+export * from "./Matr4";
+export * from "./Ray";
+export * from "./Line";
+export * from "./Quat";
+export * from "./Box";
+export * from "./radToDeg";
+export * from "./Vect3";

package/build/math/radToDeg.d.ts

@@ -0,0 +1,2 @@
+export declare function radToDeg(rad: number): number;
+export declare function degToRad(deg: number): number;

package/build/mml/MMLCompositionScene.d.ts

@@ -1,6 +1,6 @@
 import { IMMLScene, MMLDocumentTimeManager, PositionAndRotation } from "@mml-io/mml-web";
 import { ThreeJSGraphicsAdapter } from "@mml-io/mml-web-threejs";
-import { AudioListener, Group, PerspectiveCamera, Scene, WebGLRenderer } from "three";
+import { PerspectiveCamera, Scene, WebGLRenderer, AudioListener, Group } from "three";
 import { CollisionsManager } from "../collisions/CollisionsManager";
 type MMLCompositionSceneConfig = {
     targetElement: HTMLElement;

package/build/rendering/PostProcessingManager.d.ts

@@ -0,0 +1,92 @@
+import { BloomEffect, EffectComposer, EffectPass, ToneMappingEffect } from "postprocessing";
+import { PerspectiveCamera, Scene, Vector2, WebGLRenderer } from "three";
+import { TimeManager } from "../time/TimeManager";
+import { BrightnessContrastSaturation } from "./post-effects/bright-contrast-sat";
+import { GaussGrainEffect } from "./post-effects/gauss-grain";
+import { N8SSAOPass } from "./post-effects/n8-ssao/N8SSAOPass";
+export declare const PP_GLOBALLY_ENABLED = false;
+export interface EffectState {
+    name: string;
+    enabled: boolean;
+    wasEnabledBeforeGlobalDisable: boolean;
+    instance: any;
+    passIndex?: number;
+}
+export interface PostProcessingConfig {
+    enabled?: boolean;
+    bloom?: {
+        intensity?: number;
+    };
+    bcs?: {
+        brightness?: number;
+        contrast?: number;
+        saturation?: number;
+    };
+    grain?: {
+        amount?: number;
+    };
+    ssao?: {
+        enabled?: boolean;
+        halfRes?: boolean;
+        aoRadius?: number;
+        distanceFalloff?: number;
+        intensity?: number;
+        aoSamples?: number;
+        denoiseSamples?: number;
+        denoiseRadius?: number;
+    };
+    toneMapping?: {
+        mode?: number;
+        resolution?: number;
+        whitePoint?: number;
+        middleGrey?: number;
+        minLuminance?: number;
+        averageLuminance?: number;
+        adaptationRate?: number;
+    };
+}
+export declare class PostProcessingManager {
+    private renderer;
+    private scene;
+    private camera;
+    private width;
+    private height;
+    isGloballyEnabled: boolean;
+    effectComposer: EffectComposer;
+    private effectStates;
+    private renderPass;
+    private fxaaEffect;
+    private fxaaPass;
+    private bloomEffect;
+    private bloomPass;
+    private toneMappingEffect;
+    private toneMappingPass;
+    private n8aopass;
+    private bcs;
+    private bcsPass;
+    private gaussGrainEffect;
+    private gaussGrainPass;
+    resolution: Vector2;
+    constructor(renderer: WebGLRenderer, scene: Scene, camera: PerspectiveCamera, width: number, height: number, initialConfig?: PostProcessingConfig);
+    private initializeEffects;
+    private registerEffect;
+    private setupPipeline;
+    private rebuildPipeline;
+    enableEffect(name: string): void;
+    disableEffect(name: string): void;
+    toggleGlobalPostProcessing(enabled?: boolean): void;
+    updateEffectConfiguration(config: PostProcessingConfig): void;
+    updateCamera(camera: PerspectiveCamera): void;
+    resizeActiveEffects(width: number, height: number): void;
+    render(timeManager: TimeManager): void;
+    getEffectState(name: string): EffectState | undefined;
+    getAllEffectStates(): EffectState[];
+    isEffectEnabled(name: string): boolean;
+    get n8ssaoPass(): N8SSAOPass;
+    get toneMappingEffectInstance(): ToneMappingEffect;
+    get toneMappingPassInstance(): EffectPass;
+    get bcsInstance(): typeof BrightnessContrastSaturation;
+    get bloomEffectInstance(): BloomEffect;
+    get gaussGrainEffectInstance(): typeof GaussGrainEffect;
+    dispose(): void;
+}

package/build/rendering/composer.d.ts

@@ -1,5 +1,4 @@
-import { EffectComposer } from "postprocessing";
-import { Scene, Vector2, WebGLRenderer } from "three";
+import { Scene, WebGLRenderer } from "three";
 import { CameraManager } from "../camera/CameraManager";
 import { Sun } from "../sun/Sun";
 import { TimeManager } from "../time/TimeManager";
@@ -9,6 +8,7 @@ type ComposerContructorArgs = {
     cameraManager: CameraManager;
     spawnSun: boolean;
     environmentConfiguration?: EnvironmentConfiguration;
+    postProcessingEnabled?: boolean;
 };
 export type EnvironmentConfiguration = {
     groundPlane?: boolean;
@@ -50,53 +50,55 @@ export declare class Composer {
     private width;
     private height;
     private resizeListener;
-    resolution: Vector2;
     private readonly scene;
     postPostScene: Scene;
     private readonly cameraManager;
     readonly renderer: WebGLRenderer;
-    readonly effectComposer: EffectComposer;
-    private readonly renderPass;
-    private readonly normalPass;
-    private readonly normalTextureEffect;
-    private readonly ppssaoEffect;
-    private readonly ppssaoPass;
-    private readonly n8aopass;
-    private readonly fxaaEffect;
-    private readonly fxaaPass;
-    private readonly bloomEffect;
-    private readonly bloomPass;
-    private readonly toneMappingEffect;
-    private readonly smaaEffect;
-    private readonly toneMappingPass;
-    private readonly smaaPass;
-    private readonly bcs;
-    private readonly bcsPass;
-    private readonly gaussGrainEffect;
-    private readonly gaussGrainPass;
+    private postProcessingManager;
+    private currentCamera;
     private ambientLight;
     private environmentConfiguration?;
     private skyboxState;
     sun: Sun | null;
     spawnSun: boolean;
-    constructor({ scene, cameraManager, spawnSun, environmentConfiguration, }: ComposerContructorArgs);
+    private sky;
+    private skyCubeCamera;
+    private skyRenderTarget;
+    private currentAzimuthalAngle;
+    private currentPolarAngle;
+    private targetAzimuthalAngle;
+    private targetPolarAngle;
+    private currentIntensity;
+    private targetIntensity;
+    private readonly lerpSpeed;
+    private postProcessingEnabled;
+    constructor({ scene, cameraManager, spawnSun, environmentConfiguration, postProcessingEnabled, }: ComposerContructorArgs);
+    private setupSkyShader;
     updateEnvironmentConfiguration(environmentConfiguration: EnvironmentConfiguration): void;
     setupTweakPane(tweakPane: TweakPane): void;
     dispose(): void;
     fitContainer(): void;
     render(timeManager: TimeManager): void;
+    private hasHDR;
     updateSkyboxRotation(): void;
     private loadHDRJPG;
     private loadHDRi;
-    useHDRJPG(url: string, fromFile?: boolean): void;
+    useHDRJPG(url: string): void;
     useHDRI(url: string): void;
     setHDRIFromFile(): void;
     setFog(): void;
     setAmbientLight(): void;
-    private updateSunValues;
+    updateSkyShaderValues(): void;
+    updateSunValues(): void;
+    updateSun(): void;
+    private lerp;
+    private lerpAngle;
+    private updateSkyShaderValuesWithLerpedAngles;
     private updateFogValues;
     private updateSkyboxAndEnvValues;
+    private updateBloomValues;
     private updateAmbientLightValues;
+    togglePostProcessing(enabled: boolean): void;
     private applyEnvMap;
 }
 export {};

package/build/time/TimeManager.d.ts

@@ -1,5 +1,4 @@
 export declare class TimeManager {
-    private clock;
     private roundMagnitude;
     private maxAverageFrames;
     private deltaTimes;
@@ -7,6 +6,7 @@ export declare class TimeManager {
     private lerpedAverageMagDelta;
     private fpsUpdateTime;
     private framesSinceLastFPSUpdate;
+    private previousTime;
     time: number;
     deltaTime: number;
     rawDeltaTime: number;
@@ -15,5 +15,6 @@ export declare class TimeManager {
     fps: number;
     averageFPS: number;
     static maxDeltaTime: number;
+    static MILLISECONDS_TO_SECONDS: number;
     update(): void;
 }

package/build/tweakpane/TweakPane.d.ts

@@ -1,23 +1,27 @@
-import { BloomEffect, EffectComposer, EffectPass, NormalPass, SSAOEffect, ToneMappingEffect } from "postprocessing";
+import { BloomEffect, EffectComposer, EffectPass, ToneMappingEffect } from "postprocessing";
 import { Scene, WebGLRenderer } from "three";
 import { CameraManager } from "../camera/CameraManager";
 import { LocalController } from "../character/LocalController";
+import type { Composer } from "../rendering/composer";
 import { BrightnessContrastSaturation } from "../rendering/post-effects/bright-contrast-sat";
 import { GaussGrainEffect } from "../rendering/post-effects/gauss-grain";
-import { Sun } from "../sun/Sun";
+import { PostProcessingManager } from "../rendering/PostProcessingManager";
 import { TimeManager } from "../time/TimeManager";
 export declare class TweakPane {
     private holderElement;
     private renderer;
     private scene;
     private composer;
+    private postProcessingEnabled;
     private gui;
     private renderStatsFolder;
     private rendererFolder;
+    private postProcessingFolder;
+    private postProcessingSettingsFolder;
     private toneMappingFolder;
     private ssaoFolder;
     private bcsFolder;
-    private postExtrasFolder;
+    private bloomAndGrainFolder;
     private character;
     private environment;
     private camera;
@@ -27,12 +31,13 @@ export declare class TweakPane {
     guiVisible: boolean;
     private tweakPaneWrapper;
     private eventHandlerCollection;
-    constructor(holderElement: HTMLElement, renderer: WebGLRenderer, scene: Scene, composer: EffectComposer);
+    constructor(holderElement: HTMLElement, renderer: WebGLRenderer, scene: Scene, composer: Composer, postProcessingEnabled: boolean | undefined);
     private processKey;
-    setupRenderPane(composer: EffectComposer, normalPass: NormalPass, ppssaoEffect: SSAOEffect, ppssaoPass: EffectPass, n8aopass: any, toneMappingEffect: ToneMappingEffect, toneMappingPass: EffectPass, brightnessContrastSaturation: typeof BrightnessContrastSaturation, bloomEffect: BloomEffect, gaussGrainEffect: typeof GaussGrainEffect, hasLighting: boolean, sun: Sun | null, setHDR: () => void, setSkyboxAzimuthalAngle: (azimuthalAngle: number) => void, setSkyboxPolarAngle: (azimuthalAngle: number) => void, setAmbientLight: () => void, setFog: () => void): void;
+    setupRenderPane(composer: EffectComposer, n8aopass: any, toneMappingEffect: ToneMappingEffect, toneMappingPass: EffectPass, brightnessContrastSaturation: typeof BrightnessContrastSaturation, bloomEffect: BloomEffect, gaussGrainEffect: typeof GaussGrainEffect, hasLighting: boolean, updateSunValues: () => void, setHDR: () => void, setSkyboxAzimuthalAngle: (azimuthalAngle: number) => void, setSkyboxPolarAngle: (azimuthalAngle: number) => void, setAmbientLight: () => void, setFog: () => void, setSkyShaderValues: () => void): void;
     dispose(): void;
     setupCamPane(cameraManager: CameraManager): void;
     setupCharacterController(localController: LocalController): void;
+    setupPostProcessingPane(postProcessingManager: PostProcessingManager): void;
     updateStats(timeManager: TimeManager): void;
     updateCameraData(cameraManager: CameraManager): void;
     updateCharacterData(localController: LocalController): void;

package/build/tweakpane/blades/{bcsFolder.d.ts → effects/bcsFolder.d.ts}

@@ -1,5 +1,5 @@
 import { FolderApi } from "tweakpane";
-import { BrightnessContrastSaturation } from "../../rendering/post-effects/bright-contrast-sat";
+import { BrightnessContrastSaturation } from "../../../rendering/post-effects/bright-contrast-sat";
 export declare const bcsValues: {
     brightness: number;
     contrast: number;
@@ -8,5 +8,5 @@ export declare const bcsValues: {
 export declare class BrightnessContrastSaturationFolder {
     private folder;
     constructor(parentFolder: FolderApi, expand?: boolean);
-    setupChangeEvent(brightnessContrastSaturation: typeof BrightnessContrastSaturation): void;
+    setupChangeEvent(brightnessContrastSaturation: typeof BrightnessContrastSaturation | any): void;
 }

package/build/tweakpane/blades/effects/bloomAndGrain.d.ts

@@ -0,0 +1,12 @@
+import { BloomEffect } from "postprocessing";
+import { FolderApi } from "tweakpane";
+import { GaussGrainEffect } from "../../../rendering/post-effects/gauss-grain";
+export declare const bloomAndGrainValues: {
+    grain: number;
+    bloom: number;
+};
+export declare class BloomAndGrainFolder {
+    private folder;
+    constructor(parentFolder: FolderApi, expand?: boolean);
+    setupChangeEvent(bloomEffect: BloomEffect | any, gaussGrainEffect: typeof GaussGrainEffect | any): void;
+}

package/build/tweakpane/blades/{ssaoFolder.d.ts → effects/ssaoFolder.d.ts}

@@ -1,34 +1,11 @@
-import { BlendFunction, EffectComposer, EffectPass, NormalPass, SSAOEffect } from "postprocessing";
+import { EffectComposer } from "postprocessing";
 import { FolderApi } from "tweakpane";
-export declare const ppssaoValues: {
-    enabled: boolean;
-    blendFunction: BlendFunction;
-    distanceScaling: boolean;
-    depthAwareUpsampling: boolean;
-    samples: number;
-    rings: number;
-    luminanceInfluence: number;
-    radius: number;
-    intensity: number;
-    bias: number;
-    fade: number;
-    resolutionScale: number;
-    color: {
-        r: number;
-        g: number;
-        b: number;
-    };
-    worldDistanceThreshold: number;
-    worldDistanceFalloff: number;
-    worldProximityThreshold: number;
-    worldProximityFalloff: number;
-};
 export declare const n8ssaoValues: {
     enabled: boolean;
     halfRes: boolean;
+    intensity: number;
     aoRadius: number;
     distanceFalloff: number;
-    intensity: number;
     color: {
         r: number;
         g: number;
@@ -40,17 +17,17 @@ export declare const n8ssaoValues: {
     viewMode: string;
 };
 export declare const n8ssaoOptions: {
-    radius: {
+    intensity: {
         min: number;
         max: number;
         step: number;
     };
-    distanceFalloff: {
+    radius: {
         min: number;
         max: number;
         step: number;
     };
-    intensity: {
+    distanceFalloff: {
         min: number;
         max: number;
         step: number;
@@ -62,13 +39,11 @@ export declare const n8ssaoOptions: {
 };
 export declare class SSAOFolder {
     private folder;
-    private ppssao;
-    private n8ssao;
     private aoSamples;
     private denoiseSamples;
     private denoiseRadius;
     private aoDisplay;
     private postProcessingSSAOIndex;
     constructor(parentFolder: FolderApi, expand?: boolean);
-    setupChangeEvent(composer: EffectComposer, normalPass: NormalPass, ppssaoEffect: SSAOEffect, ppssaoPass: EffectPass, n8aopass: any): void;
+    setupChangeEvent(composer: EffectComposer | any, n8aopass: any): void;
 }

package/build/tweakpane/blades/{toneMappingFolder.d.ts → effects/toneMappingFolder.d.ts}

@@ -14,5 +14,5 @@ export declare class ToneMappingFolder {
     private minLuminance;
     private avgLuminance;
     constructor(parentFolder: FolderApi, expand?: boolean);
-    setupChangeEvent(toneMappingEffect: ToneMappingEffect): void;
+    setupChangeEvent(toneMappingEffect: ToneMappingEffect | any): void;
 }

package/build/tweakpane/blades/environmentFolder.d.ts

@@ -1,12 +1,15 @@
 import { Scene } from "three";
 import { FolderApi } from "tweakpane";
-import { Sun } from "../../sun/Sun";
 export declare const sunValues: {
+    sunIntensity: number;
     sunPosition: {
         sunAzimuthalAngle: number;
         sunPolarAngle: number;
     };
-    sunIntensity: number;
+    skyTurbidity: number;
+    skyRayleigh: number;
+    skyMieCoefficient: number;
+    skyMieDirectionalG: number;
     sunColor: {
         r: number;
         g: number;
@@ -46,5 +49,5 @@ export declare class EnvironmentFolder {
     private ambient;
     private fog;
     constructor(parentFolder: FolderApi, expand?: boolean);
-    setupChangeEvent(scene: Scene, setHDR: () => void, setSkyboxAzimuthalAngle: (azimuthalAngle: number) => void, setSkyboxPolarAngle: (polarAngle: number) => void, setAmbientLight: () => void, setFog: () => void, sun: Sun | null): void;
+    setupChangeEvent(scene: Scene, setHDR: () => void, setSkyboxAzimuthalAngle: (azimuthalAngle: number) => void, setSkyboxPolarAngle: (polarAngle: number) => void, setAmbientLight: () => void, setFog: () => void, updateSkyShaderValues: () => void, updateSunValues: () => void): void;
 }