export { A as ALL_PICTURE_STYLES, P as PICTURE_STYLES, a as Picture, b as PictureOptions, c as PictureStyle, S as SURFACE_PRESETS, d as ScreenMode, e as ScreenOptions, f as ScreenPanel, g as ScreenPanelOptions, h as SurfaceKind, i as SurfaceOptions, j as SurfaceParams, k as createPicture, l as createScreenPanel, m as createSurface, p as pickPictureStyle } from './picture-xZNAPu7r.js';
import { Color, MeshStandardMaterial, Points } from 'three';

/**
 * Stylized architectural glass — the facade material for modern windows,
 * balustrades, doors and curtain walls.
 *
 * Real transmission is far too heavy for whole facades, so this is a
 * transparent `MeshStandardMaterial` with two shader tricks patched in:
 *
 * - **Fresnel opacity**: face-on the pane stays see-through; edge-on it
 *   turns opaque and reflective, exactly how glass reads in life.
 * - **A procedural sky streak**: the reflected view direction samples a tiny
 *   built-in sky gradient, so panes carry a believable reflection with no
 *   environment map, no cube camera, no setup.
 *
 * `nightGlow` follows the house-window convention: the material's emissive
 * is set at the intensity `createDayCycle` scans for, so listing the mesh
 * (or its building) in the cycle's `lamps` makes the glass ignite at dusk —
 * the classic lit-window skyline, free.
 */
interface GlassOptions {
    /** Glass tint. Default a cool clear blue-grey. */
    tint?: number | Color;
    /** Face-on opacity (0–1). Default 0.24 (clear); frosted overrides higher. */
    opacity?: number;
    /** Milky translucent finish: higher opacity, rough, muted reflection. */
    frosted?: boolean;
    /** Sky-reflection strength (0–1). Default 0.55. */
    reflect?: number;
    /**
     * Warm interior glow for `createDayCycle` to ignite at dusk (adds an
     * emissive at lamp-scan intensity). Default false.
     */
    nightGlow?: boolean;
    /** Sky gradient the reflection samples: zenith / horizon colours. */
    sky?: number;
    horizon?: number;
}
declare function createGlass(options?: GlassOptions): MeshStandardMaterial;

/**
 * Moving water — the shared material behind streams, spouts, showers and
 * spray.
 *
 * This is the same extraction `clothWave` was: the fountain has had falling
 * water and a jet since 0.9, and every tap, shower and cascade wants both.
 * Pulling them out here is what stops the bathroom set growing a second
 * water shader.
 *
 * It also fixes what was there. The fountain's "falling water" was a
 * **static** translucent cylinder — at rest it reads as a glass rod, and no
 * amount of tinting fixes that, because the thing that says *water* is not
 * the colour, it is that the surface is **travelling downward and breaking
 * up as it goes**. Real falling water accelerates, so it narrows and
 * stretches, and past a certain distance it stops being a sheet and becomes
 * strands.
 */
interface FlowOptions {
    /** Fall height in metres — sets how far down the break-up develops. */
    length?: number;
    /** Downward travel, in UV lengths per second. Default 1.6. */
    speed?: number;
    /**
     * How far down the fall it comes apart, 0–1. Default 0.35. Low for a thin
     * tap stream (it breaks up almost at once); high for a thick weir.
     */
    breakUp?: number;
    /** How many strands across the width. Default 7. */
    strands?: number;
    /** Base opacity at full flow. Default 0.55. */
    opacity?: number;
    color?: number | Color;
}
/**
 * A material for water in motion down a surface — a spout's stream, a weir,
 * a shower's column.
 *
 * Drive it with `material.userData.flowUniforms`: `uFlowTime` every frame,
 * `uFlowRate` for how hard it is running (0 turns it off completely, which is
 * what a closed tap should look like).
 */
declare function flowingWaterMaterial(options?: FlowOptions): MeshStandardMaterial;
interface DropletOptions {
    /** How many points. Default 24. Each is one billboard, so keep it small. */
    count?: number;
    /** How far out they spread from the origin, in metres. */
    spread?: number;
    /**
     * Ballistic rise before falling, in metres. A fountain jet throws water UP;
     * a shower and a splash do not. Zero gives a pure fall.
     */
    rise?: number;
    /** How far they fall, in metres. Default 0.4. */
    fall?: number;
    /** Point size. Default 0.28. */
    size?: number;
    /**
     * Largest a droplet may get on screen, in pixels. Default 22. Point sprites
     * scale with 1/distance and have no upper bound, so without this a splash
     * viewed from close up becomes a screenful of glowing beach balls.
     */
    maxPixels?: number;
    color?: number | Color;
    seed?: number;
}
interface Droplets {
    mesh: Points;
    /** Advance the simulation. */
    update(dt: number): void;
    /** How hard it is spraying, 0–1. At 0 nothing is drawn. */
    setRate(rate: number): void;
}
/**
 * A puff of droplets: a fountain jet, a shower's mist, the splash where a
 * stream lands.
 *
 * The only particles in the whole water set. Everything else here is shader
 * work on geometry that was going to be drawn anyway, so this is the one
 * piece with a real frame cost — keep the counts low.
 */
declare function createDroplets(options?: DropletOptions): Droplets;

export { type DropletOptions, type Droplets, type FlowOptions, type GlassOptions, createDroplets, createGlass, flowingWaterMaterial };