@wave3d/core 0.1.0

package/dist/standalone.d.ts

@@ -0,0 +1,13 @@
+import { BackgroundImageFit, BackgroundMode, BasicGradientType, BlendMode, ColorStop, DEFAULT_LIGHT_POSITION, GradientType, LightConfig, MAX_COLORS, MAX_LIGHTS, MAX_MESH_POINTS, MAX_NOISE_BANDS, MAX_WAVES, MeshGradientPoint, NoiseBand, PaletteSource, SceneConfig, StudioConfig, Vec2, Vec3, WaveConfig, createDefaultConfig, createDefaultMeshPoints, createLight, createNoiseBand, ensureCamera, ensureSceneDefaults, ensureStudioConfig, makeStops, makeWave, makeWaveSpread, normalizeBackground, normalizeWave, resizeWaves } from "./config/model.js";
+import { WaveRenderer } from "./renderer/WaveRenderer.js";
+import { FallbackReason, WaveHandle, WaveOptions, WaveState } from "./shell/createWave.js";
+import { PRESETS } from "./presets.js";
+
+//#region src/standalone.d.ts
+/** {@link createWaveImpl} with the engine already bundled in (synchronous upgrade). */
+declare function createWave(container: HTMLElement, config?: Partial<StudioConfig>, options?: WaveOptions): WaveHandle;
+/** The drop-in embed contract: an alias of {@link createWave}. */
+declare const mountWave: typeof createWave;
+//#endregion
+export { BackgroundImageFit, BackgroundMode, BasicGradientType, BlendMode, ColorStop, DEFAULT_LIGHT_POSITION, type FallbackReason, GradientType, LightConfig, MAX_COLORS, MAX_LIGHTS, MAX_MESH_POINTS, MAX_NOISE_BANDS, MAX_WAVES, MeshGradientPoint, NoiseBand, PRESETS, PaletteSource, SceneConfig, StudioConfig, Vec2, Vec3, WaveConfig, type WaveHandle, type WaveOptions, WaveRenderer, type WaveState, createDefaultConfig, createDefaultMeshPoints, createLight, createNoiseBand, createWave, ensureCamera, ensureSceneDefaults, ensureStudioConfig, makeStops, makeWave, makeWaveSpread, mountWave, normalizeBackground, normalizeWave, resizeWaves };
+//# sourceMappingURL=standalone.d.ts.map

package/dist/standalone.js

@@ -0,0 +1,17 @@
+import { DEFAULT_LIGHT_POSITION, MAX_COLORS, MAX_LIGHTS, MAX_MESH_POINTS, MAX_NOISE_BANDS, MAX_WAVES, createDefaultConfig, createDefaultMeshPoints, createLight, createNoiseBand, ensureCamera, ensureSceneDefaults, ensureStudioConfig, makeStops, makeWave, makeWaveSpread, normalizeBackground, normalizeWave, resizeWaves } from "./config/model.js";
+import { createWaveImpl } from "./shell/createWave.js";
+import { WaveRenderer } from "./renderer/WaveRenderer.js";
+import { PRESETS } from "./presets.js";
+import { core_loader_exports } from "./core-loader.js";
+//#region src/standalone.ts
+const loadCore = () => Promise.resolve(core_loader_exports);
+/** {@link createWaveImpl} with the engine already bundled in (synchronous upgrade). */
+function createWave(container, config = {}, options = {}) {
+	return createWaveImpl(loadCore, container, config, options);
+}
+/** The drop-in embed contract: an alias of {@link createWave}. */
+const mountWave = createWave;
+//#endregion
+export { DEFAULT_LIGHT_POSITION, MAX_COLORS, MAX_LIGHTS, MAX_MESH_POINTS, MAX_NOISE_BANDS, MAX_WAVES, PRESETS, WaveRenderer, createDefaultConfig, createDefaultMeshPoints, createLight, createNoiseBand, createWave, ensureCamera, ensureSceneDefaults, ensureStudioConfig, makeStops, makeWave, makeWaveSpread, mountWave, normalizeBackground, normalizeWave, resizeWaves };
+
+//# sourceMappingURL=standalone.js.map

package/dist/standalone.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"standalone.js","names":["core"],"sources":["../src/standalone.ts"],"sourcesContent":["// The single-file CDN / standalone build entry. Unlike the `.` shell — which fetches the engine on\n// demand — this statically imports the engine (three bundled in) and pre-binds createWave/mountWave\n// with a synchronous loadCore, so a plain <script type=\"module\"> from a CDN upgrades with no extra\n// network round-trip. This is also the runtime the studio inlines into its exported embed HTML.\nimport * as core from \"./core-loader\";\nimport { createWaveImpl } from \"./shell/createWave\";\nimport type { WaveOptions, WaveHandle } from \"./shell/createWave\";\nimport type { StudioConfig } from \"./config/model\";\n\n// Synchronous core — the engine is already bundled into this file, so there is no dynamic import\n// (which is exactly why the standalone stays a single file: createWaveImpl never references the\n// public createWave's `import(\"./core-loader\")` default).\nconst loadCore = (): Promise<typeof core> => Promise.resolve(core);\n\n/** {@link createWaveImpl} with the engine already bundled in (synchronous upgrade). */\nexport function createWave(\n  container: HTMLElement,\n  config: Partial<StudioConfig> = {},\n  options: WaveOptions = {},\n): WaveHandle {\n  return createWaveImpl(loadCore, container, config, options);\n}\n\n/** The drop-in embed contract: an alias of {@link createWave}. */\nexport const mountWave = createWave;\n\n// CDN users get the raw engine, presets, and full model directly too.\nexport { WaveRenderer } from \"./renderer/WaveRenderer\";\nexport { PRESETS } from \"./presets\";\nexport * from \"./config/model\";\nexport type { WaveOptions, WaveHandle, WaveState, FallbackReason } from \"./shell/createWave\";\n"],"mappings":";;;;;;AAYA,MAAM,iBAAuC,QAAQ,QAAQA,mBAAI;;AAGjE,SAAgB,WACd,WACA,SAAgC,CAAC,GACjC,UAAuB,CAAC,GACZ;CACZ,OAAO,eAAe,UAAU,WAAW,QAAQ,OAAO;AAC5D;;AAGA,MAAa,YAAY"}

package/dist/studio/StudioWaveRenderer.d.ts

@@ -0,0 +1,187 @@
+import { WaveRenderer } from "../renderer/WaveRenderer.js";
+
+//#region src/studio/StudioWaveRenderer.d.ts
+declare class StudioWaveRenderer extends WaveRenderer {
+  /** Set while the panel drives the camera, so orbit's 'change' doesn't re-refresh the
+   *  panel mid-drag (the panel already knows the new value). */
+  private suppressCameraChange;
+  private readonly miniBox;
+  private readonly miniSphere;
+  private readonly miniTmpA;
+  private readonly miniTmpB;
+  private readonly miniPrevColor;
+  private readonly miniSize;
+  private readonly miniBlendPrev;
+  private readonly miniTransPrev;
+  private cameraRigOn;
+  private cameraRigCollapsed;
+  private minimapCamera?;
+  private camMarker?;
+  /** Gold markers in the minimap, one per rig light (positions/colours tracked live). */
+  private minimapLights;
+  /** Shown in the rig when no light has been added yet, so the light is always visible there.
+   *  Matches where "drag in 3D" creates the first light, so the marker doesn't jump when added. */
+  private readonly defaultRigLight;
+  private minimapBtn?;
+  private readonly overlay;
+  private readonly raycaster;
+  private orbit?;
+  private transform?;
+  /** Whether the main view orbit/zoom/pan is on (studio); off for the embed. */
+  private mainOrbitOn;
+  private lightHelpers;
+  /** Which 3D-editing gizmo is active: none, dragging lights, or dragging the wave/waves. */
+  private editMode;
+  private selectedLight;
+  /** Wave/wave drag handles: index 0 = the whole-wave box (moves config.position); 1..N =
+   *  per-wave spheres (move each layer's offset), shown only when there's >1 wave. */
+  private waveHelpers;
+  private selectedWave;
+  /** Gizmo operation: "translate" moves the handle, "rotate" spins the whole wave. */
+  private gizmoMode;
+  /** Active free screen-plane drag of a handle (grab anywhere on the marker, camera locked). */
+  private dragState?;
+  private readonly dragPlane;
+  /** Active left-drag camera pan in edit mode (the press missed every handle → move the view). */
+  private panState?;
+  /** Camera snapshot taken when entering a 3D-edit mode and restored verbatim on exit, so the
+   *  view returns exactly where it was (position + ortho zoom + up) rather than snapping to the
+   *  authored hero framing. */
+  private returnCamera;
+  /** Set by the panel: fired after a gizmo drag/selection so sliders can refresh. */
+  onLightsChanged?: (selected: number) => void;
+  /** Set by the panel: fired after orbit moves the camera so sliders can refresh. */
+  onCameraChanged?: () => void;
+  /** Set by the panel: fired after a wave/wave gizmo drag/selection so the position and
+   *  per-wave offset sliders can refresh. */
+  onWaveChanged?: () => void;
+  /** True while any drag-in-3D gizmo owns the camera (light or wave). */
+  private get editing();
+  isLightEditMode(): boolean;
+  isWaveEditMode(): boolean;
+  /** Toggle 3D light editing: show draggable light handles; off restores the prior view. */
+  setLightEditMode(on: boolean): Promise<void>;
+  /** Toggle 3D wave/wave editing: drag the whole wave (and each wave when there's >1). */
+  setWaveEditMode(on: boolean): Promise<void>;
+  /** Enter/leave/switch a 3D-edit mode. Modes are mutually exclusive — turning one on turns
+   *  the other off. The camera is snapshotted on the first entry and restored on the final exit
+   *  (so light↔wave switches keep the same return view). */
+  private setEditMode;
+  /** In edit mode, take PAN off OrbitControls' left button so left-drag is free to grab handles;
+   *  onPointerDown/Move pan the camera manually when a left-press misses every handle (so panning
+   *  never fights the object drag). Right-drag still rotates the camera; scroll/middle zooms. */
+  private setOrbitForEdit;
+  /** Switch the wave-edit gizmo between moving handles and rotating the whole wave. Rotate
+   *  targets the whole-wave box (config.rotation), so selecting it makes the intent obvious. */
+  setGizmoMode(mode: "translate" | "rotate"): void;
+  getGizmoMode(): "translate" | "rotate";
+  /** Snapshot the live camera so leaving edit mode returns exactly here (incl. ortho zoom). */
+  private captureReturnCamera;
+  /** Restore the snapshot from captureReturnCamera (falls back to the authored hero camera). */
+  private restoreReturnCamera;
+  /** Turn on mouse/trackpad orbit + zoom + pan + arrow-key orbit (studio only). */
+  enableOrbit(): Promise<void>;
+  /** Arrow keys orbit the camera around the target (←/→ azimuth, ↑/↓ elevation). */
+  private onKeyDown;
+  /** Reset the camera to the straight-on hero framing at the configured distance. */
+  resetView(): void;
+  /** Dolly/aim the camera so the whole wave fills the viewport (keeps the view angle).
+   *  Fits the geometry box's actual *projected* screen extent — tighter than a bounding
+   *  sphere for a flat, diagonal ribbon. */
+  fitToView(): void;
+  /** Dolly the camera to a distance from the orbit target (or set z when no orbit). */
+  setCameraDistance(d: number): void;
+  /** The current look-at target (orbit's if present, else from config). */
+  private camTarget;
+  /** Read the camera as orbit values for the panel (angles in degrees). */
+  getCameraOrbit(): {
+    azimuth: number;
+    elevation: number;
+    distance: number;
+    panX: number;
+    panY: number;
+  };
+  /** Place the camera at azimuth/elevation (degrees) + distance around the target. */
+  setCameraOrbit(azimuthDeg: number, elevationDeg: number, distance: number): void;
+  /** Roll the camera around its view axis (degrees) — tilts the composition without
+   *  moving the camera. Applied after positioning; reset by any orbit interaction. */
+  rollView(deg: number): void;
+  /** Pan: move the look-at target (and camera with it) to (x, y) in world units. */
+  setCameraTarget(x: number, y: number): void;
+  /** Ortho zoom MULTIPLIER (the camera has no real fov). 1 = the responsive base framing (the hero crop). */
+  getZoom(): number;
+  setZoom(zoom: number): void;
+  duplicateOffset(): {
+    x: number;
+    y: number;
+    z: number;
+  };
+  /** Toggle the corner camera-rig minimap (studio aid; off in the embed). */
+  setCameraRig(on: boolean): void;
+  /** Corner rectangle (logical px) for the minimap viewport. */
+  private minimapRect;
+  /** Place the collapse button at the minimap's top-right (or bottom corner when collapsed). */
+  private positionMinimapBtn;
+  /** Build the minimap's fixed 3rd-person camera + the camera/light markers (once). */
+  private ensureMinimap;
+  /** The lights the rig should show: the configured lights, or a single default-position
+   *  marker when none has been added yet — so the light is always visible in the rig. */
+  private rigLights;
+  /** Reconcile the minimap's light markers with the rig lights (count, position, colour). */
+  private syncMinimapLights;
+  /** Fit the minimap's 3rd-person camera to the wave (+ lights) and size/place the camera
+   *  proxy, so the rig reads at any scene scale. The main camera is orthographic — its literal
+   *  distance is arbitrary — so the proxy sits a fixed multiple of the scene radius back along
+   *  the true view direction rather than at the far-away ortho position. */
+  private frameMinimap;
+  /** Draw the camera-rig minimap into a corner viewport (called after the main render). */
+  private renderMinimap;
+  private ensureOrbit;
+  private onCursorDown;
+  private onCursorUp;
+  private ensureGizmo;
+  private onControlsChange;
+  /** Persist the live camera (position/target/distance) into the config. */
+  private writeCameraToConfig;
+  /** Pointer position in normalized device coords (-1..1), from a canvas-relative event. */
+  private pointerNdc;
+  private onPointerDown;
+  private onPointerMove;
+  private onPointerUp;
+  private selectLight;
+  private selectWaveHandle;
+  /** Gizmo drag → route to the active mode's writer. */
+  private onGizmoMoved;
+  /** Light gizmo drag → write the moved handle back into the config + uniforms. */
+  private onLightGizmoMoved;
+  /** Wave gizmo drag → the whole-wave box writes config.position (and the wave handles
+   *  follow it); a per-wave sphere writes that layer's offset (relative to config.position). */
+  private onWaveGizmoMoved;
+  /** Reconcile the helper spheres with config.lights (count, position, colour). */
+  private syncLightHelpers;
+  private clearLightHelpers;
+  /** Reconcile the wave drag handles with config: one box handle per wave, sitting at that
+   *  wave's absolute position (and oriented to its rotation so the rotate gizmo starts there). */
+  private syncWaveHelpers;
+  private clearWaveHelpers;
+  /** Reposition just the wave MESHES from each wave's absolute transform — the transform
+   *  subset of refresh(), used live during a wave gizmo drag so the ribbon follows without a
+   *  full uniform re-push or a helper resync. */
+  private pushWaveTransforms;
+  /** Pull the camera back to a 3/4 angle that frames the edit target: the origin wave + all
+   *  lights (light mode), or a region around config.position + the handles (wave mode). */
+  private frameEditCamera;
+  /** Restore the authored camera (from config) — used when leaving light-edit. */
+  private restoreHeroCamera;
+  /** Push only the light uniforms (used live during a gizmo drag). */
+  private pushLightUniforms;
+  protected isCameraExternallyDriven(): boolean;
+  protected onAfterRefresh(): void;
+  protected onAfterRenderFrame(): void;
+  protected onAfterResize(): void;
+  protected applyCameraFromConfig(): void;
+  dispose(): void;
+}
+//#endregion
+export { StudioWaveRenderer };
+//# sourceMappingURL=StudioWaveRenderer.d.ts.map