uzay 0.1.0

package/dist/core/items/vector3d.d.ts

@@ -0,0 +1,52 @@
+import type { PointDraggableDir } from "../common-types/axes";
+import type { Color } from "../common-types/colors";
+import type { ItemTags } from "../common-types/tags";
+import { type Vec3 } from "../common-types/vec3";
+import { BaseItem } from "../item";
+import type { AtomLikeOptions, Field } from "../atom-wrapper";
+import type { Scene3D } from "../scene3d";
+import type { DragEvent } from "../common-types/interaction-events";
+export type PointerEvents = "auto" | "none";
+export type Vector3DFields = {
+    tags: ItemTags;
+    origin: Vec3;
+    vector: Vec3;
+    draggable: PointDraggableDir;
+    color: Color;
+    thickness: number;
+    headLength: number;
+    headWidth: number;
+    pointerEvents: PointerEvents;
+};
+export type Vector3DOptions = AtomLikeOptions<Vector3DFields>;
+export declare class Vector3D<Opts extends Vector3DOptions = {}> extends BaseItem<Vector3DFields, "vector3d"> {
+    kind: "vector3d";
+    warnedReadOnly: boolean;
+    private _dragOffset;
+    tags: Field<ItemTags, "tags", Opts>;
+    origin: Field<Vec3, "origin", Opts>;
+    vector: Field<Vec3, "vector", Opts>;
+    draggable: Field<PointDraggableDir, "draggable", Opts>;
+    color: Field<Color, "color", Opts>;
+    thickness: Field<number, "thickness", Opts>;
+    headLength: Field<number, "headLength", Opts>;
+    headWidth: Field<number, "headWidth", Opts>;
+    pointerEvents: Field<PointerEvents, "pointerEvents", Opts>;
+    constructor(scene: Scene3D, options?: Opts & Vector3DOptions);
+    getItemSnapshot(): {
+        id: string;
+        kind: "vector3d";
+        isDirty: boolean;
+        tags: ItemTags;
+        origin: Vec3;
+        vector: Vec3;
+        draggable: PointDraggableDir;
+        color: string;
+        thickness: number;
+        headLength: number;
+        headWidth: number;
+        pointerEvents: PointerEvents;
+    };
+    getCursorState(): "grab" | null;
+    handleDrag(event: DragEvent<"vector3d">): void;
+}

package/dist/core/renderers/axes3d.d.ts

@@ -0,0 +1,2 @@
+import type { ItemRenderer } from "./index";
+export declare const axes3dRenderer: ItemRenderer<"axes3d">;

package/dist/core/renderers/camera3d.d.ts

@@ -0,0 +1,2 @@
+import type { ItemRenderer } from "./index";
+export declare const camera3dRenderer: ItemRenderer<"camera3d">;

package/dist/core/renderers/grid3d.d.ts

@@ -0,0 +1,2 @@
+import { type ItemRenderer } from "./index";
+export declare const grid3dRenderer: ItemRenderer<"grid3d">;

package/dist/core/renderers/index.d.ts

@@ -0,0 +1,99 @@
+import * as THREE from "three";
+import { CSS2DObject } from "three/addons/renderers/CSS2DRenderer.js";
+import type { ItemKind, ItemSnapshot } from "../common-types/item-registry";
+import { Line2 } from "three/addons/lines/Line2.js";
+import { LineGeometry } from "three/addons/lines/LineGeometry.js";
+import { LineMaterial } from "three/addons/lines/LineMaterial.js";
+export declare const pointScaleDown = 25;
+export declare const lineThicknessScaleDown = 25;
+export type ThreeSceneTypes = {
+    point3d: {
+        kind: "point3d";
+        geometry: THREE.SphereGeometry;
+        material: THREE.MeshPhongMaterial;
+        mesh: THREE.Mesh<THREE.SphereGeometry, THREE.MeshPhongMaterial>;
+    };
+    line3d: {
+        kind: "line3d";
+        curve: THREE.CatmullRomCurve3;
+        geometry: THREE.TubeGeometry;
+        material: THREE.MeshPhongMaterial;
+        mesh: THREE.Mesh<THREE.TubeGeometry, THREE.MeshPhongMaterial>;
+    };
+    camera3d: {
+        kind: "camera3d";
+    };
+    parametricfunction3d: {
+        kind: "parametricfunction3d";
+        curve: THREE.CatmullRomCurve3;
+        geometry: THREE.TubeGeometry;
+        material: THREE.MeshPhongMaterial;
+        mesh: THREE.Mesh<THREE.TubeGeometry, THREE.MeshPhongMaterial>;
+    };
+    axes3d: {
+        kind: "axes3d";
+        x: {
+            curve: THREE.CatmullRomCurve3;
+            geometry: THREE.TubeGeometry;
+            material: THREE.MeshBasicMaterial;
+            mesh: THREE.Mesh<THREE.TubeGeometry, THREE.MeshBasicMaterial>;
+        };
+        y: {
+            curve: THREE.CatmullRomCurve3;
+            geometry: THREE.TubeGeometry;
+            material: THREE.MeshBasicMaterial;
+            mesh: THREE.Mesh<THREE.TubeGeometry, THREE.MeshBasicMaterial>;
+        };
+        z: {
+            curve: THREE.CatmullRomCurve3;
+            geometry: THREE.TubeGeometry;
+            material: THREE.MeshBasicMaterial;
+            mesh: THREE.Mesh<THREE.TubeGeometry, THREE.MeshBasicMaterial>;
+        };
+    };
+    grid3d: {
+        kind: "grid3d";
+        geometry: LineGeometry;
+        material: LineMaterial;
+        mesh: Line2;
+    };
+    sphere3d: {
+        kind: "sphere3d";
+        geometry: THREE.SphereGeometry;
+        material: THREE.MeshPhongMaterial;
+        mesh: THREE.Mesh<THREE.SphereGeometry, THREE.MeshPhongMaterial>;
+    };
+    vector3d: {
+        kind: "vector3d";
+        group: THREE.Group;
+        shaftGeometry: THREE.CylinderGeometry;
+        headGeometry: THREE.ConeGeometry;
+        material: THREE.MeshPhongMaterial;
+        shaftMesh: THREE.Mesh;
+        headMesh: THREE.Mesh;
+    };
+    overlay3d: {
+        kind: "overlay3d";
+        cssObject: CSS2DObject;
+        element: HTMLDivElement;
+    };
+    plane3d: {
+        kind: "plane3d";
+        geometry: THREE.PlaneGeometry;
+        material: THREE.MeshPhongMaterial;
+        mesh: THREE.Mesh<THREE.PlaneGeometry, THREE.MeshPhongMaterial>;
+        edgeGeometry?: THREE.EdgesGeometry;
+        edgeMaterial?: THREE.LineBasicMaterial;
+        edgeLines?: THREE.LineSegments;
+    };
+};
+export type ThreeSceneObject<K extends ItemKind = ItemKind> = ThreeSceneTypes[K];
+export type ItemRenderer<K extends ItemKind> = {
+    create(item: ItemSnapshot<K>, threeScene: THREE.Scene): ThreeSceneTypes[K];
+    update(item: ItemSnapshot<K>, obj: ThreeSceneTypes[K]): void;
+    dispose?(obj: ThreeSceneTypes[K], threeScene: THREE.Scene): void;
+};
+export declare const rendererRegistry: {
+    [K in ItemKind]: ItemRenderer<K>;
+};
+export declare function getRenderer<K extends ItemKind>(kind: K): ItemRenderer<K>;

package/dist/core/renderers/line3d.d.ts

@@ -0,0 +1,2 @@
+import type { ItemRenderer } from "./index";
+export declare const line3dRenderer: ItemRenderer<"line3d">;

package/dist/core/renderers/overlay3d.d.ts

@@ -0,0 +1,2 @@
+import type { ItemRenderer } from "./index";
+export declare const overlay3dRenderer: ItemRenderer<"overlay3d">;

package/dist/core/renderers/parametric-function3d.d.ts

@@ -0,0 +1,2 @@
+import type { ItemRenderer } from "./index";
+export declare const parametricFunction3dRenderer: ItemRenderer<"parametricfunction3d">;

package/dist/core/renderers/plane3d.d.ts

@@ -0,0 +1,2 @@
+import type { ItemRenderer } from "./index";
+export declare const plane3dRenderer: ItemRenderer<"plane3d">;

package/dist/core/renderers/point3d.d.ts

@@ -0,0 +1,2 @@
+import type { ItemRenderer } from "./index";
+export declare const point3dRenderer: ItemRenderer<"point3d">;

package/dist/core/renderers/sphere3d.d.ts

@@ -0,0 +1,2 @@
+import type { ItemRenderer } from "./index";
+export declare const sphere3dRenderer: ItemRenderer<"sphere3d">;

package/dist/core/renderers/vector3d.d.ts

@@ -0,0 +1,2 @@
+import type { ItemRenderer } from "./index";
+export declare const vector3dRenderer: ItemRenderer<"vector3d">;

package/dist/core/scene3d.d.ts

@@ -0,0 +1,23 @@
+import { type ItemId, type ItemSnapshot } from "./common-types/item-registry";
+import { type ItemKind, type Item, type ItemOptions, type ItemInstance } from "./common-types/item-registry";
+import type { SceneAtomFunction, BoundAtom, Store } from "./atom-wrapper";
+import type { Atom, PrimitiveAtom } from "jotai";
+export type SceneSnapshot = {
+    itemSnapshots: Map<ItemId, ItemSnapshot>;
+};
+export declare class Scene3D {
+    store: Store;
+    items: Map<ItemId, Item>;
+    atom: SceneAtomFunction;
+    invalidateSceneListeners: Set<() => void>;
+    listenForSceneInvalidation(cb: () => void): () => void;
+    invalidateScene(): void;
+    constructor();
+    create<K extends ItemKind, Opts extends ItemOptions<K>>(kind: K, options: Opts, ..._check: Opts extends ItemOptions<K> ? [] : ["Invalid options for kind"]): ItemInstance<K, Opts>;
+    remove<T extends Item>(item: T): void;
+    atomize<V, A extends Atom<V>>(value: BoundAtom<A>): BoundAtom<A>;
+    atomize<T>(value: T): BoundAtom<PrimitiveAtom<T>>;
+    getSceneSnapshot(): SceneSnapshot;
+    getCamera(cameraId: ItemId): import("..").Camera3D<import("./atom-wrapper").AtomLikeOptions<import("./items/camera3d").Camera3DFields>>;
+    renderComplete(): void;
+}

package/dist/core/view3d.d.ts

@@ -0,0 +1,78 @@
+import * as THREE from "three";
+import { OrbitControls } from "three/addons/controls/OrbitControls.js";
+import { CSS2DRenderer } from "three/addons/renderers/CSS2DRenderer.js";
+import type { Camera3D, Camera3DFields } from "./items/camera3d";
+import type { Scene3D, SceneSnapshot } from "./scene3d";
+import { Vec3 } from "./common-types/vec3";
+import type { ItemId, ItemSnapshot } from "./common-types/item-registry";
+import type { AtomLikeOptions } from "./atom-wrapper";
+import { type ThreeSceneObject } from "./renderers";
+import type { InteractionEvent, InteractionEventType } from "./common-types/interaction-events";
+import type { PointDraggableDir } from "./common-types/axes";
+export declare class View3D {
+    scene: Scene3D;
+    activeCam: Camera3D<AtomLikeOptions<Camera3DFields>>;
+    containerElem: HTMLElement;
+    threeScene: THREE.Scene;
+    threeCamera: THREE.PerspectiveCamera;
+    threeOrbitControls: OrbitControls;
+    threeRenderer: THREE.WebGLRenderer;
+    css2dRenderer: CSS2DRenderer;
+    frameScheduled: boolean;
+    threeMeshes: Map<ItemId, ThreeSceneObject>;
+    ambientLight: THREE.AmbientLight;
+    directionalLight: THREE.DirectionalLight;
+    unsubscribeSceneInvalidation: (() => void) | null;
+    lastSceneSnapshot: SceneSnapshot;
+    raycaster: THREE.Raycaster;
+    pointer: THREE.Vector2;
+    dragState: {
+        itemId: ItemId;
+        constraint: PointDraggableDir;
+        startWorldPosition: Vec3;
+        lastWorldPosition: Vec3;
+    } | null;
+    pointerDownInfo: {
+        itemId: ItemId;
+        screenPosition: {
+            x: number;
+            y: number;
+        };
+        time: number;
+    } | null;
+    hoveredItemId: ItemId | null;
+    sizer: ReturnType<typeof createResponsiveThreeSizer>;
+    constructor(scene: Scene3D, activeCamId: ItemId, containerElem: HTMLElement);
+    changeActiveCam(cameraId: ItemId): void;
+    onSceneChanged(): void;
+    createItem(item: ItemSnapshot): void;
+    updateItem(item: ItemSnapshot): void;
+    removeItem(id: ItemId): void;
+    requestRender(): void;
+    _render(): void;
+    raycastItem(event: PointerEvent): {
+        itemId: ItemId;
+        worldPosition: Vec3;
+    } | null;
+    dispatchEvent<E extends InteractionEventType>(eventType: E, event: InteractionEvent): void;
+    getItemDragConstraint(snapshot: ItemSnapshot): PointDraggableDir | null;
+    screenToWorld(event: PointerEvent, referencePoint: Vec3, constraint: PointDraggableDir): Vec3;
+    closestPointOnAxis(ray: THREE.Ray, axisOrigin: THREE.Vector3, axisDir: THREE.Vector3): THREE.Vector3;
+    private getCurrentRay;
+    updateCursor(): void;
+    onPointerDown: (event: PointerEvent) => void;
+    onPointerMove: (event: PointerEvent) => void;
+    onPointerUp: (event: PointerEvent) => void;
+    onPointerLeave: (_event: PointerEvent) => void;
+    dispose(): void;
+}
+declare function createResponsiveThreeSizer({ container, renderer, camera, onResize, }: {
+    container: HTMLElement;
+    renderer: THREE.WebGLRenderer;
+    camera: THREE.PerspectiveCamera;
+    onResize: () => void;
+}): {
+    applyIfNeeded: () => void;
+    dispose: () => void;
+};
+export {};

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export { Scene3D } from "./core/scene3d";
+export { View3D } from "./core/view3d";
+export { vec3, Vec3 } from "./core/common-types/vec3";
+export { vec2, Vec2 } from "./core/common-types/vec2";
+export { Point3D } from "./core/items/point3d";
+export { Line3D } from "./core/items/line3d";
+export { Sphere3D } from "./core/items/sphere3d";
+export { Axes3D } from "./core/items/axes3d";
+export { Grid3D } from "./core/items/grid3d";
+export { Camera3D } from "./core/items/camera3d";
+export { ParametricFunction3D } from "./core/items/parametric-function3d";
+export { Vector3D } from "./core/items/vector3d";
+export { Overlay3D } from "./core/items/overlay3d";
+export { Plane3D } from "./core/items/plane3d";
+export type { BoundAtom, SceneAtom, AtomLikeInput } from "./core/atom-wrapper";
+export type { ItemKind, ItemId, ItemOptions, ItemInstance, ItemSnapshot } from "./core/common-types/item-registry";
+export type { DragEvent, ClickEvent, HoverEvent, DragHandler, ClickHandler, HoverHandler } from "./core/common-types/interaction-events";
+export type { OverlayFormat, OverlayAnchor } from "./core/common-types/overlay";