@cascadetui/core 0.1.4 → 0.1.6

package/3d/Advanced3D.d.ts

@@ -0,0 +1,161 @@
+import { AmbientLight, DirectionalLight, Euler, InstancedMesh, Object3D, PerspectiveCamera, Scene, Vector3, type BufferGeometry, type ColorRepresentation, type Material } from "three";
+export interface OrbitCameraControllerOptions {
+    target?: Vector3;
+    radius?: number;
+    minRadius?: number;
+    maxRadius?: number;
+    azimuth?: number;
+    polar?: number;
+    minPolar?: number;
+    maxPolar?: number;
+    rotateSpeed?: number;
+    zoomSpeed?: number;
+    panSpeed?: number;
+    damping?: number;
+}
+export interface OrbitCameraState {
+    target: Vector3;
+    radius: number;
+    azimuth: number;
+    polar: number;
+}
+export declare function createOrbitCameraRig(options?: OrbitCameraControllerOptions): {
+    camera: PerspectiveCamera;
+    orbit: OrbitCameraController;
+};
+export declare class OrbitCameraController {
+    private readonly camera;
+    private readonly state;
+    private readonly minRadius;
+    private readonly maxRadius;
+    private readonly minPolar;
+    private readonly maxPolar;
+    private readonly rotateSpeed;
+    private readonly zoomSpeed;
+    private readonly panSpeed;
+    private readonly damping;
+    private azimuthVelocity;
+    private polarVelocity;
+    private zoomVelocity;
+    private panVelocity;
+    constructor(camera: PerspectiveCamera, options?: OrbitCameraControllerOptions);
+    getState(): OrbitCameraState;
+    setTarget(target: Vector3): void;
+    rotate(deltaAzimuth: number, deltaPolar: number): void;
+    zoom(delta: number): void;
+    pan(deltaX: number, deltaY: number): void;
+    update(deltaSeconds: number): void;
+    private syncCamera;
+    private clamp;
+}
+export interface InstancedScatterOptions {
+    count: number;
+    seed?: number;
+    extent?: Vector3 | [number, number, number];
+    minScale?: number;
+    maxScale?: number;
+    yRotationOnly?: boolean;
+}
+export interface InstancedScatterResult {
+    mesh: InstancedMesh;
+    center: Vector3;
+    radius: number;
+}
+export interface MassiveScatterFieldOptions extends InstancedScatterOptions {
+    color?: ColorRepresentation;
+    geometry?: BufferGeometry;
+    material?: Material | Material[];
+}
+export declare function createInstancedScatter(geometry: BufferGeometry, material: Material | Material[], options: InstancedScatterOptions): InstancedScatterResult;
+export declare function createMassiveScatterField(options: MassiveScatterFieldOptions): InstancedScatterResult;
+export interface Keyframe {
+    time: number;
+    position?: Vector3;
+    rotation?: Euler;
+    scale?: Vector3;
+}
+export interface KeyframeAnimatorOptions {
+    loop?: boolean;
+    pingPong?: boolean;
+}
+export interface SimpleKeyframe {
+    time: number;
+    position?: [number, number, number];
+    rotation?: [number, number, number];
+    scale?: [number, number, number];
+}
+export declare class KeyframeAnimator {
+    private readonly target;
+    private readonly keyframes;
+    private readonly duration;
+    private readonly loop;
+    private readonly pingPong;
+    private time;
+    private direction;
+    constructor(target: Object3D, keyframes: Keyframe[], options?: KeyframeAnimatorOptions);
+    update(deltaSeconds: number): void;
+    getTime(): number;
+    private apply;
+    private clamp;
+}
+export declare function createAnimatedTransformNode(keyframes: SimpleKeyframe[], options?: KeyframeAnimatorOptions): {
+    node: Object3D;
+    animator: KeyframeAnimator;
+};
+export interface CinematicScenePresetOptions {
+    fogColor?: number;
+    fogNear?: number;
+    fogFar?: number;
+    cameraFov?: number;
+    cameraNear?: number;
+    cameraFar?: number;
+    cameraRadius?: number;
+    ambientIntensity?: number;
+    keyLightIntensity?: number;
+    fillLightIntensity?: number;
+    rimLightIntensity?: number;
+}
+export interface CinematicScenePreset {
+    scene: Scene;
+    camera: PerspectiveCamera;
+    orbit: OrbitCameraController;
+    keyLight: DirectionalLight;
+    fillLight: DirectionalLight;
+    rimLight: DirectionalLight;
+    ambientLight: AmbientLight;
+}
+export declare function createCinematicScenePreset(options?: CinematicScenePresetOptions): CinematicScenePreset;
+export interface CameraRailPoint {
+    position: [number, number, number];
+    lookAt?: [number, number, number];
+}
+export interface CameraRailControllerOptions {
+    loop?: boolean;
+    speed?: number;
+}
+export declare class CameraRailController {
+    private readonly camera;
+    private readonly path;
+    private readonly lookAtPath;
+    private readonly speed;
+    private readonly loop;
+    private t;
+    constructor(camera: PerspectiveCamera, points: CameraRailPoint[], options?: CameraRailControllerOptions);
+    update(deltaSeconds: number): void;
+    getProgress(): number;
+    setProgress(progress: number): void;
+}
+export interface ShowcaseSceneOptions {
+    instanceCount?: number;
+    worldExtent?: [number, number, number];
+    seed?: number;
+}
+export interface ShowcaseSceneRig {
+    scene: Scene;
+    camera: PerspectiveCamera;
+    orbit: OrbitCameraController;
+    rail: CameraRailController;
+    update: (deltaSeconds: number) => void;
+    focusNode: Object3D;
+}
+export declare function createShowcaseScene(options?: ShowcaseSceneOptions): ShowcaseSceneRig;

package/3d/WGPURenderer.d.ts

@@ -1,4 +1,4 @@
-import { PerspectiveCamera, OrthographicCamera, Scene } from "three";
+import { PerspectiveCamera, OrthographicCamera, Scene, type ColorSpace, type ToneMapping, type ShadowMapType } from "three";
 import type { OptimizedBuffer } from "../buffer";
 import { RGBA } from "../lib/RGBA";
 import { SuperSampleAlgorithm } from "./canvas";
@@ -17,6 +17,12 @@ export interface ThreeCliRendererOptions {
     alpha?: boolean;
     autoResize?: boolean;
     libPath?: string;
+    toneMapping?: ToneMapping;
+    toneMappingExposure?: number;
+    outputColorSpace?: ColorSpace;
+    shadows?: boolean;
+    shadowMapType?: ShadowMapType;
+    sortObjects?: boolean;
 }
 export declare class ThreeCliRenderer {
     private readonly cliRenderer;
@@ -27,6 +33,12 @@ export declare class ThreeCliRenderer {
     private superSample;
     private backgroundColor;
     private alpha;
+    private toneMapping;
+    private toneMappingExposure;
+    private outputColorSpace;
+    private shadows;
+    private shadowMapType;
+    private sortObjects;
     private threeRenderer?;
     private canvas?;
     private device;

package/3d/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./WGPURenderer";
 export * from "./ThreeRenderable";
+export * from "./Advanced3D";
 export * from "./TextureUtils";
 export * from "./canvas";
 export * from "./SpriteUtils";