world.ts 0.2.0 → 0.2.2

package/dist/layers/billboard/index.d.ts

@@ -1,22 +1,18 @@
-import type { vec4 } from "gl-matrix";
-import type { vec3 } from "gl-matrix";
 import type { Viewport } from "../../viewport";
-import type { World } from "../../world";
-import type { LayerOptions } from "..";
-import { type BaseLayer, type Billboard } from "..";
-export type BillboardLayer = BaseLayer & Billboard;
-export declare const createBillboardLayer: (world: World, billboard?: Partial<Billboard>) => {
+import type { Properties } from "..";
+import { type Billboard } from "..";
+export declare const createBillboardLayer: (gl: WebGL2RenderingContext, properties?: Properties<Partial<Billboard>>) => {
+    onClick: ((_: import("../..").Pick) => void) | undefined;
+    onRightClick: ((_: import("../..").Pick) => void) | undefined;
+    onDoubleClick: ((_: import("../..").Pick) => void) | undefined;
+    onDrag: ((_: import("../..").Pick) => void) | undefined;
+    onDragFlat: ((_: import("../..").Pick) => void) | undefined;
+    onDragStart: ((_: import("../..").Pick) => void) | undefined;
+    onDragEnd: ((_: import("../..").Pick) => void) | undefined;
     render: ({ viewport: { projection, modelView, camera, screen }, depth, index, }: {
         viewport: Viewport;
         depth?: boolean | undefined;
         index?: number | undefined;
     }) => void;
     dispose: () => void;
-    options: Partial<LayerOptions>;
-    url: string;
-    position: vec3;
-    color: vec4;
-    size: number;
-    minSizePixels: number | undefined;
-    maxSizePixels: number | undefined;
 };

package/dist/layers/container.d.ts

@@ -0,0 +1,22 @@
+import type { Properties } from ".";
+import { type Layer } from ".";
+export declare const createContainer: (children: Layer[]) => {
+    children: Layer[];
+    dispose: () => void;
+};
+export type DynamicContainerProperties<K> = {
+    keys: K[];
+    create: (_: K) => Layer;
+};
+export declare const createDynamicContainer: <K>(properties: Properties<DynamicContainerProperties<K>>) => {
+    readonly children: Layer[];
+    render: () => void;
+    dispose: () => void;
+};
+export declare const createRenderLayer: (render: () => void) => {
+    render: () => void;
+    dispose: () => void;
+};
+export declare const createEmptyLayer: () => {
+    dispose: () => void;
+};

package/dist/layers/index.d.ts

@@ -1,41 +1,45 @@
 import type { quat, vec3, vec4 } from "gl-matrix";
 import type { Viewport } from "../viewport";
-import type { BillboardLayer } from "./billboard";
-import type { LineLayer } from "./line";
-import type { MeshLayer } from "./mesh";
-import type { PolygonLayer } from "./polygon";
-import type { TerrainLayer } from "./terrain";
 export * from "./billboard";
+export * from "./container";
 export * from "./line";
 export * from "./mesh";
 export * from "./polygon";
 export * from "./terrain";
+import type { Pick } from "../model";
+export type LayerEvents = {
+    onClick?: (_: Pick) => void;
+    onRightClick?: (_: Pick) => void;
+    onDoubleClick?: (_: Pick) => void;
+    onDragStart?: (_: Pick) => void;
+    onDrag?: (_: Pick) => void;
+    onDragFlat?: (_: Pick) => void;
+    onDragEnd?: (_: Pick) => void;
+};
 export type LayerOptions = {
     pickable: boolean;
     depth: boolean;
     polygonOffset: number;
-};
+} & LayerEvents;
+export declare const defaultLayerOptions: LayerOptions;
 export type Terrain = {
-    options: Partial<LayerOptions>;
     readonly terrainUrl: string;
-    readonly imageryUrl: string;
+    imageryUrl: string;
     color: vec4;
-};
+} & LayerOptions;
 export type Line = {
-    options: Partial<LayerOptions>;
     points: vec3[][];
     color: vec4;
     width: number;
     minWidthPixels?: number | undefined;
     maxWidthPixels?: number | undefined;
-};
+    depthWidthPixels?: number | undefined;
+} & LayerOptions;
 export type Polygon = {
-    options: Partial<LayerOptions>;
     points: vec3[][];
     color: vec4;
-};
+} & LayerOptions;
 export type Mesh = {
-    options: Partial<LayerOptions>;
     vertices: vec3[];
     indices: vec3[];
     position: vec3;
@@ -44,22 +48,36 @@ export type Mesh = {
     size: number;
     minSizePixels?: number;
     maxSizePixels?: number;
-};
+} & LayerOptions;
 export type Billboard = {
-    options: Partial<LayerOptions>;
     url: string;
     position: vec3;
     color: vec4;
     size: number;
     minSizePixels?: number;
     maxSizePixels?: number;
-};
-export type Layer = TerrainLayer | LineLayer | PolygonLayer | MeshLayer | BillboardLayer;
-export type BaseLayer = {
-    render: (_: {
+} & LayerOptions;
+export type Layer = {
+    children?: Layer[];
+    render?: (_: {
         viewport: Viewport;
         depth?: boolean;
         index?: number;
     }) => void;
     dispose: () => void;
+} & LayerEvents;
+export type Properties<T> = {
+    [K in keyof T]: T[K] extends Function | undefined ? T[K] : () => T[K];
+};
+export declare const resolve: <T>(_: Properties<T>) => T;
+export declare const combine: <T extends object>(properties: () => T) => Properties<T>;
+export declare const cache: <T, R>(_value: () => T, f: (_: T) => R) => () => R;
+export declare const createMouseEvents: (properties: Properties<Partial<LayerOptions>>) => {
+    onClick: ((_: Pick) => void) | undefined;
+    onRightClick: ((_: Pick) => void) | undefined;
+    onDoubleClick: ((_: Pick) => void) | undefined;
+    onDrag: ((_: Pick) => void) | undefined;
+    onDragFlat: ((_: Pick) => void) | undefined;
+    onDragStart: ((_: Pick) => void) | undefined;
+    onDragEnd: ((_: Pick) => void) | undefined;
 };

package/dist/layers/line/index.d.ts

@@ -1,21 +1,18 @@
-import type { vec4 } from "gl-matrix";
-import type { vec3 } from "gl-matrix";
 import type { Viewport } from "../../viewport";
-import type { World } from "../../world";
-import type { LayerOptions } from "../";
-import { type BaseLayer, type Line } from "../";
-export type LineLayer = BaseLayer & Line;
-export declare const createLineLayer: (world: World, line?: Partial<Line>) => {
+import type { Properties } from "../";
+import { type Line } from "../";
+export declare const createLineLayer: (gl: WebGL2RenderingContext, properties?: Properties<Partial<Line>>) => {
+    onClick: ((_: import("../..").Pick) => void) | undefined;
+    onRightClick: ((_: import("../..").Pick) => void) | undefined;
+    onDoubleClick: ((_: import("../..").Pick) => void) | undefined;
+    onDrag: ((_: import("../..").Pick) => void) | undefined;
+    onDragFlat: ((_: import("../..").Pick) => void) | undefined;
+    onDragStart: ((_: import("../..").Pick) => void) | undefined;
+    onDragEnd: ((_: import("../..").Pick) => void) | undefined;
     render: ({ viewport: { projection, modelView, camera, screen }, depth, index, }: {
         viewport: Viewport;
         depth?: boolean | undefined;
         index?: number | undefined;
     }) => void;
     dispose: () => void;
-    options: Partial<LayerOptions>;
-    points: vec3[][];
-    color: vec4;
-    width: number;
-    minWidthPixels: number | undefined;
-    maxWidthPixels: number | undefined;
 };

package/dist/layers/mesh/index.d.ts

@@ -1,23 +1,18 @@
-import type { quat, vec3, vec4 } from "gl-matrix";
+import type { Properties } from "../../layers";
 import { type Mesh } from "../../layers";
 import type { Viewport } from "../../viewport";
-import type { World } from "../../world";
-import type { BaseLayer, LayerOptions } from "..";
-export type MeshLayer = BaseLayer & Mesh;
-export declare const createMeshLayer: (world: World, mesh?: Partial<Mesh>) => {
+export declare const createMeshLayer: (gl: WebGL2RenderingContext, properties?: Properties<Partial<Mesh>>) => {
+    onClick: ((_: import("../..").Pick) => void) | undefined;
+    onRightClick: ((_: import("../..").Pick) => void) | undefined;
+    onDoubleClick: ((_: import("../..").Pick) => void) | undefined;
+    onDrag: ((_: import("../..").Pick) => void) | undefined;
+    onDragFlat: ((_: import("../..").Pick) => void) | undefined;
+    onDragStart: ((_: import("../..").Pick) => void) | undefined;
+    onDragEnd: ((_: import("../..").Pick) => void) | undefined;
     render: ({ viewport: { projection, modelView, camera, screen }, depth, index, }: {
         viewport: Viewport;
         depth?: boolean | undefined;
         index?: number | undefined;
     }) => void;
     dispose: () => void;
-    options: Partial<LayerOptions>;
-    vertices: vec3[];
-    indices: vec3[];
-    position: vec3;
-    orientation: quat;
-    color: vec4;
-    size: number;
-    minSizePixels: number | undefined;
-    maxSizePixels: number | undefined;
 };

package/dist/layers/polygon/index.d.ts

@@ -1,18 +1,18 @@
-import type { vec4 } from "gl-matrix";
-import type { vec3 } from "gl-matrix";
 import type { Viewport } from "../../viewport";
-import type { World } from "../../world";
-import type { LayerOptions } from "..";
-import { type BaseLayer, type Polygon } from "..";
-export type PolygonLayer = BaseLayer & Polygon;
-export declare const createPolygonLayer: (world: World, polygon?: Partial<Polygon>) => {
+import type { Properties } from "..";
+import { type Polygon } from "..";
+export declare const createPolygonLayer: (gl: WebGL2RenderingContext, properties?: Properties<Partial<Polygon>>) => {
+    onClick: ((_: import("../..").Pick) => void) | undefined;
+    onRightClick: ((_: import("../..").Pick) => void) | undefined;
+    onDoubleClick: ((_: import("../..").Pick) => void) | undefined;
+    onDrag: ((_: import("../..").Pick) => void) | undefined;
+    onDragFlat: ((_: import("../..").Pick) => void) | undefined;
+    onDragStart: ((_: import("../..").Pick) => void) | undefined;
+    onDragEnd: ((_: import("../..").Pick) => void) | undefined;
     render: ({ viewport: { projection, modelView, camera, screen }, depth, index, }: {
         viewport: Viewport;
         depth?: boolean | undefined;
         index?: number | undefined;
     }) => void;
     dispose: () => void;
-    options: Partial<LayerOptions>;
-    points: vec3[][];
-    color: vec4;
 };

package/dist/layers/terrain/index.d.ts

@@ -1,18 +1,18 @@
-import { vec4 } from "gl-matrix";
 import type { Viewport } from "../../viewport";
-import type { World } from "../../world";
-import type { LayerOptions } from "..";
-import { type BaseLayer, type Terrain } from "..";
-export type TerrainLayer = BaseLayer & Terrain;
-export declare const createTerrainLayer: (world: World, terrain?: Partial<Terrain>) => {
+import type { Properties } from "..";
+import { type Terrain } from "..";
+export declare const createTerrainLayer: (gl: WebGL2RenderingContext, properties?: Properties<Partial<Terrain>>) => {
+    onClick: ((_: import("../..").Pick) => void) | undefined;
+    onRightClick: ((_: import("../..").Pick) => void) | undefined;
+    onDoubleClick: ((_: import("../..").Pick) => void) | undefined;
+    onDrag: ((_: import("../..").Pick) => void) | undefined;
+    onDragFlat: ((_: import("../..").Pick) => void) | undefined;
+    onDragStart: ((_: import("../..").Pick) => void) | undefined;
+    onDragEnd: ((_: import("../..").Pick) => void) | undefined;
     render: ({ viewport, depth, index, }: {
         viewport: Viewport;
         depth?: boolean | undefined;
         index?: number | undefined;
     }) => void;
     dispose: () => void;
-    options: Partial<LayerOptions>;
-    terrainUrl: string;
-    imageryUrl: string;
-    color: vec4;
 };

package/dist/math.d.ts

@@ -7,5 +7,5 @@ export declare const quadratic: (a: number, b: number, c: number) => number[];
 export declare const mercator: ([lng, lat, alt]: vec3, out?: vec3) => vec3;
 export declare const geodetic: ([x, y, z]: vec3, out?: vec3) => vec3;
 export declare const tileToMercator: ([x, y, z]: vec3, out?: vec3) => vec3;
-export declare const toQuaternion: ([pitch, yaw, roll]: vec3) => [number, number, number, number];
+export declare const toQuaternion: ([pitch, roll, yaw]: vec3) => [number, number, number, number];
 export declare const toOrientation: ([x, y, z, w]: quat) => [number, number, number];

package/dist/model.d.ts

@@ -1,9 +1,15 @@
 import type { vec2, vec3 } from "gl-matrix";
+import type { Layer } from "./layers";
 export type View = {
     target: vec3;
     offset: vec2;
-    screen: vec2;
     distance: number;
     orientation: vec3;
     fieldOfView: number;
 };
+export declare const defaultView: View;
+export type Pick = {
+    point: vec2;
+    position: vec3;
+    layer: Layer | undefined;
+};

package/dist/transition.d.ts

@@ -1,4 +1,4 @@
-import { vec3, vec4 } from "gl-matrix";
+import { vec2, vec3, vec4 } from "gl-matrix";
 export type Transition<T> = {
     value: T;
     dispose: () => void;
@@ -7,27 +7,10 @@ export declare const createTransition: <T>(step: (_: {
     time: number;
     current: T;
     target: T;
-}) => T) => {
-    value: T | undefined;
-    dispose: () => void;
-};
-export declare const createNumberTransition: (update?: ((_: number, target: number) => void) | undefined) => {
-    value: number | undefined;
-    dispose: () => void;
-};
-export declare const createColorTransition: (update?: ((_: vec4, target: vec4) => void) | undefined) => {
-    value: vec4 | undefined;
-    dispose: () => void;
-};
-export declare const createPositionTransition: (update?: ((_: vec3, target: vec3) => void) | undefined) => {
-    value: vec3 | undefined;
-    dispose: () => void;
-};
-export declare const createPositionVelocityTransition: (update?: ((_: vec3, target: vec3) => void) | undefined) => {
-    value: vec3 | undefined;
-    dispose: () => void;
-};
-export declare const createOrientationTransition: (update?: ((_: vec3, target: vec3) => void) | undefined) => {
-    value: vec3 | undefined;
-    dispose: () => void;
-};
+}) => T) => (_target: () => T) => () => T;
+export declare const createNumberTransition: (_target: () => number) => () => number;
+export declare const createVec2Transition: (_target: () => vec2) => () => vec2;
+export declare const createVec4Transition: (_target: () => vec4) => () => vec4;
+export declare const createPositionTransition: (_target: () => vec3) => () => vec3;
+export declare const createPositionVelocityTransition: (target: () => vec3) => () => vec3;
+export declare const createOrientationTransition: (_target: () => vec3) => () => vec3;

package/dist/view-transition.d.ts

@@ -1,10 +1,2 @@
 import type { View } from "./model";
-import type { World } from "./world";
-export type ViewTransition = {
-    view: Partial<View>;
-    dispose: () => void;
-};
-export declare const createViewTransition: (world: World) => {
-    view: Partial<View>;
-    dispose: () => void;
-};
+export declare const createViewTransition: (view: () => View) => () => View;

package/dist/viewport.d.ts

@@ -1,5 +1,5 @@
 import { mat4, vec2, vec3, vec4 } from "gl-matrix";
-import type { View } from "./model";
+import { type View } from "./model";
 export type Viewport = {
     camera: vec3;
     screen: vec2;
@@ -13,5 +13,9 @@ export type Viewport = {
     localToClip: (_: vec3, out?: vec4) => vec4;
     localToWorld: (_: vec3, out?: vec3) => vec3;
     worldToLocal: (_: vec3, out?: vec3) => vec3;
+    project: (_: vec3) => vec2;
+    unproject: (_: vec2, options?: {
+        targetZ: number | undefined;
+    }) => vec3;
 };
-export declare const createViewport: (view: View) => Viewport;
+export declare const createViewport: (view: Partial<View>, screen: vec2) => Viewport;

package/dist/world.d.ts

@@ -1,39 +1,27 @@
-import type { vec2 } from "gl-matrix";
-import { vec3 } from "gl-matrix";
-import type { Layer } from "./layers";
-import type { View } from "./model";
-type Pick = {
-    screen: vec2;
-    position: vec3;
-    layer: Layer | undefined;
-};
+import type { vec2, vec3 } from "gl-matrix";
+import type { Layer, Properties } from "./layers";
+import type { Pick, View } from "./model";
 export type World = {
-    readonly canvas: HTMLCanvasElement;
-    readonly gl: WebGL2RenderingContext;
-    set view(_: View);
-    get view(): View;
-    add: (layer: Layer) => void;
-    remove: (layer: Layer) => void;
     project: (_: vec3) => vec2;
     unproject: (_: vec2) => vec3;
-    recenter: ([x, y]: [number, number]) => void;
-    pick: ([x, y]: [number, number]) => Pick;
+    pick: ([x, y]: vec2, _: {
+        terrain?: boolean;
+    }) => Pick;
     dispose: () => void;
 };
-export declare const createWorld: (canvas: HTMLCanvasElement) => {
-    canvas: HTMLCanvasElement;
-    gl: WebGL2RenderingContext;
-    view: View;
-    add: (layer: Layer) => void;
-    remove: (layer: Layer) => void;
+export type WorldProperties = {
+    view: Partial<View>;
+    layers: Layer[];
+};
+export declare const createWorld: (gl: WebGL2RenderingContext, properties: Properties<WorldProperties>) => {
     project: (_: vec3) => vec2;
     unproject: (_: vec2) => vec3;
-    recenter: ([cx, cy]: vec2) => void;
-    pick: (screen: vec2) => {
-        screen: vec2;
+    pick: (point: vec2, { terrain }?: {
+        terrain?: boolean | undefined;
+    }) => {
+        point: vec2;
         position: vec3;
-        layer: import("./layers").BillboardLayer | import("./layers").TerrainLayer | import("./layers").PolygonLayer | import("./layers").MeshLayer | undefined;
+        layer: Layer | undefined;
     };
     dispose: () => void;
 };
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "world.ts",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",