@cgtk/gp 0.0.13 → 0.0.15

package/index.d.ts

@@ -1,77 +1,146 @@
-import type { Fn, FnV, Resource, TypedArray } from "@cgtk/std/types";
-import { type View, type Struct } from "@cgtk/std/struct";
-import { type Constructor } from "@cgtk/std/typedarray";
-import type { IndexedMesh } from "@cgtk/geometry/types";
+import type { Fn, FnV, NumberArray } from "@cgtk/std/types";
+import { type Struct } from "@cgtk/std/struct";
+import * as TA from "@cgtk/std/typedarray";
+import type { Vec2 } from "@cgtk/linalg/types";
+import { type Point } from "./point";
 export declare const wasmInit: <T>(source: Response | PromiseLike<Response>, imports?: WebAssembly.Imports) => Promise<T>;
 interface Mod {
     memory: WebAssembly.Memory;
-    malloc(size: number): number;
-    free(ptr: number, size: number): number;
-}
-interface Alloc<T> {
-    ptr: number;
-    value: T;
-}
-export interface GP extends Mod {
-    vertex_position_geometry: FnV<[number, number], number>;
-    free_vertex_position_geometry: Fn<number, void>;
-    n_faces: Fn<number, number>;
-    n_halfedges: Fn<number, number>;
-    h2f: FnV<[number, number], number>;
-    f2h: FnV<[number, number], number>;
-    h_next: FnV<[number, number], number>;
-    h_twin: FnV<[number, number], number>;
-    double_area: FnV<[number, number], number>;
-    double_areas: FnV<[number, number], void>;
-    face_normals: FnV<[number, number], void>;
-    internal_angles: FnV<[number, number], void>;
-    vertex_normals_area_weighted: FnV<[number, number], void>;
-    vertex_normals_angle_weighted: FnV<[number, number], void>;
-    angle_defects: FnV<[number, number], void>;
+    __heap_base: WebAssembly.Global;
+    malloc(size: number, align: number): number;
+    free(ptr: number, size: number, align: number): number;
 }
 export declare const allocators: (mod: Mod) => {
-    struct: <T extends Struct<any>>(s: T) => Resource<Alloc<View<T>>>;
-    array: <T extends TypedArray>(ctor: Constructor<T>, length: number) => Resource<Alloc<T>>;
-    data: <T extends TypedArray>(vals: T) => Resource<Alloc<T>>;
-    slice: <T extends TypedArray>(a: Alloc<T>) => Resource<Alloc<{
+    struct: <T extends Struct<any>>(s: T) => import("@cgtk/std/types").Resource<{
         ptr: number;
-        len: number;
-    }>>;
-    dataSlice: <T extends TypedArray>(data: T) => Resource<Alloc<{
+        value: import("@cgtk/std/struct").View<T>;
+    }>;
+    array: <T extends NumberArray>(ctor: TA.Constructor<T>, length: number) => import("@cgtk/std/types").Resource<{
         ptr: number;
-        len: number;
-    }>>;
+        value: T;
+        slice: bigint;
+    }>;
+    data: <T extends NumberArray>(vals: T) => import("@cgtk/std/types").Resource<{
+        ptr: number;
+        value: T;
+        slice: bigint;
+    }>;
 };
-export declare const init: (url?: any, imports?: WebAssembly.Imports) => Promise<{
+export interface GP extends Mod {
+    surface_new: Fn<bigint, number>;
+    surface_free: Fn<number, void>;
+    surface_n_faces: Fn<number, number>;
+    surface_n_halfedges: Fn<number, number>;
+    surface_h2f: FnV<[number, number], number>;
+    surface_f2h: FnV<[number, number], number>;
+    surface_h_next: FnV<[number, number], number>;
+    surface_h_twin: FnV<[number, number], number>;
+    surface_double_area: FnV<[number, number], number>;
+    surface_double_areas: FnV<[number, bigint], void>;
+    surface_face_normal: FnV<[number, number, bigint], void>;
+    surface_face_normals: FnV<[number, bigint], void>;
+    surface_internal_angles: FnV<[number, bigint], void>;
+    surface_vertex_normals_area_weighted: FnV<[number, bigint], void>;
+    surface_vertex_normals_angle_weighted: FnV<[number, bigint], void>;
+    surface_angle_defects: FnV<[number, bigint], void>;
+    manifold_new: Fn<bigint, number>;
+    manifold_free: Fn<number, void>;
+    manifold_n_faces: Fn<number, number>;
+    manifold_n_halfedges: Fn<number, number>;
+    manifold_h2f: FnV<[number, number], number>;
+    manifold_f2h: FnV<[number, number], number>;
+    manifold_h_next: FnV<[number, number], number>;
+    manifold_h_twin: FnV<[number, number], number>;
+    manifold_face_area_f: FnV<[number, number], number>;
+    manifold_face_area_d: FnV<[number, number], number>;
+    signpost_f_new: Fn<number, number>;
+    signpost_f_free: Fn<number, void>;
+    signpost_f_flip_to_delaunay: Fn<number, number>;
+    signpost_f_trace_along_input: FnV<[number, number, number, number], bigint>;
+    free_points_f: Fn<bigint, void>;
+    signpost_d_new: Fn<number, number>;
+    signpost_d_free: Fn<number, void>;
+    signpost_d_flip_to_delaunay: Fn<number, number>;
+    signpost_d_trace_along_input: FnV<[number, number, number, number], bigint>;
+    free_points_d: Fn<bigint, void>;
+    geodesic_tracer_f_new: Fn<number, number>;
+    geodesic_tracer_f_free: Fn<number, void>;
+    geodesic_tracer_f_trace_start: FnV<[number, number, number, bigint], number>;
+    geodesic_tracer_f_trace_next: FnV<[number, number, number], number>;
+    geodesic_tracer_f_trace_result_free: Fn<number, void>;
+    geodesic_tracer_f_trace_state_free: Fn<number, void>;
+    geodesic_tracer_d_new: Fn<number, number>;
+    geodesic_tracer_d_free: Fn<number, void>;
+    geodesic_tracer_d_trace_start: FnV<[number, number, number, bigint], number>;
+    geodesic_tracer_d_trace_next: FnV<[number, number, number], number>;
+    geodesic_tracer_d_trace_result_free: Fn<number, void>;
+    geodesic_tracer_d_trace_state_free: Fn<number, void>;
+}
+type Float<T extends ArrayBufferLike = ArrayBufferLike> = Float32Array<T> | Float64Array<T>;
+export declare const init: (url?: string | URL | Request, imports?: WebAssembly.Imports) => Promise<{
     alloc: {
-        struct: <T extends Struct<any>>(s: T) => Resource<Alloc<View<T>>>;
-        array: <T extends TypedArray>(ctor: Constructor<T>, length: number) => Resource<Alloc<T>>;
-        data: <T extends TypedArray>(vals: T) => Resource<Alloc<T>>;
-        slice: <T extends TypedArray>(a: Alloc<T>) => Resource<Alloc<{
+        struct: <T extends Struct<any>>(s: T) => import("@cgtk/std/types").Resource<{
             ptr: number;
-            len: number;
-        }>>;
-        dataSlice: <T extends TypedArray>(data: T) => Resource<Alloc<{
+            value: import("@cgtk/std/struct").View<T>;
+        }>;
+        array: <T extends NumberArray>(ctor: TA.Constructor<T>, length: number) => import("@cgtk/std/types").Resource<{
             ptr: number;
-            len: number;
-        }>>;
+            value: T;
+            slice: bigint;
+        }>;
+        data: <T extends NumberArray>(vals: T) => import("@cgtk/std/types").Resource<{
+            ptr: number;
+            value: T;
+            slice: bigint;
+        }>;
     };
-    vertexPositionGeometry: (mesh: IndexedMesh<{
-        position: Float32Array;
-    }, Uint32Array>) => Resource<{
+    surface: (indices: Uint32Array) => import("@cgtk/std/types").Resource<{
+        nFaces: () => number;
+        nHalfedges: () => number;
+        h2f: (i: number) => number;
+        hNext: (i: number) => number;
+        hTwin: (i: number) => number;
+        f2h: (i: number) => number;
+        geometry: (positions: Float32Array) => import("@cgtk/std/types").Resource<{
+            doubleArea: (i: number) => number;
+            doubleAreas: <T extends Float = Float32Array<ArrayBufferLike>>(res?: T) => T;
+            faceNormal: <T extends Float = Float32Array<ArrayBufferLike>>(f: number, res?: T) => T;
+            faceNormals: <T extends Float = Float32Array<ArrayBufferLike>>(res?: T) => T;
+            internalAngles: <T extends Float = Float32Array<ArrayBufferLike>>(res?: T) => T;
+            angleDefects: <T extends Float = Float32Array<ArrayBufferLike>>(res?: T) => T;
+            vertexNormalsAreaWeighted: <T extends Float = Float32Array<ArrayBufferLike>>(res?: T) => T;
+            vertexNormalsAngleWeighted: <T extends Float = Float32Array<ArrayBufferLike>>(res?: T) => T;
+        }>;
+    }>;
+    manifold: (indices: Uint32Array) => import("@cgtk/std/types").Resource<{
         nFaces: () => number;
         nHalfedges: () => number;
         h2f: (i: number) => number;
         hNext: (i: number) => number;
         hTwin: (i: number) => number;
         f2h: (i: number) => number;
-        doubleArea: (i: number) => number;
-        doubleAreas: <T extends TypedArray>(res: T) => T;
-        faceNormals: <T extends TypedArray>(res: T) => T;
-        internalAngles: <T extends TypedArray>(res: T) => T;
-        vertexNormalsAreaWeighted: <T extends TypedArray>(res: T) => T;
-        vertexNormalsAngleWeighted: <T extends TypedArray>(res: T) => T;
-        angleDefects: <T extends TypedArray>(res: T) => T;
+        geometryF: (positions: Float32Array) => import("@cgtk/std/types").Resource<{
+            faceArea: (i: number) => number;
+            tracer: () => import("@cgtk/std/types").Resource<{
+                ptr: number;
+                trace: (p: Point<Float32Array>, tVec: Vec2<Float32Array>) => Generator<Point<Float32Array<ArrayBufferLike>>, void, unknown>;
+            }>;
+            signpost: () => import("@cgtk/std/types").Resource<{
+                flipToDelaunay: () => number;
+                traceAlongInput: (tracer: number, i: number) => Point<Float32Array<ArrayBufferLike>>[];
+            }>;
+        }>;
+        geometryD: (positions: Float64Array) => import("@cgtk/std/types").Resource<{
+            faceArea: (i: number) => number;
+            tracer: () => import("@cgtk/std/types").Resource<{
+                ptr: number;
+                trace: (p: Point<Float64Array>, tVec: Vec2<Float64Array>) => Generator<Point<Float64Array<ArrayBufferLike>>, void, unknown>;
+            }>;
+            signpost: () => import("@cgtk/std/types").Resource<{
+                flipToDelaunay: () => number;
+                traceAlongInput: (tracer: number, i: number) => Point<Float64Array<ArrayBufferLike>>[];
+            }>;
+        }>;
     }>;
 }>;
 export {};

package/index.js

@@ -1,75 +1,218 @@
-import { bind } from "@cgtk/std/fn";
-import { resource, map, flatMap, combine } from "@cgtk/std/resource";
-import { struct, view, u32 } from "@cgtk/std/struct";
-import { ctor } from "@cgtk/std/typedarray";
+import { resource, map, combine } from "@cgtk/std/resource";
+import { view, array } from "@cgtk/std/struct";
+import * as TA from "@cgtk/std/typedarray";
+import * as S from "./struct";
+import { from as fromPoint, PointType } from "./point";
 import wasmURL from './gp.wasm?url';
 export const wasmInit = async (source, imports) => (await WebAssembly.instantiateStreaming(source, imports)).instance.exports;
-;
+const packSlice = (ptr, len) => ((BigInt(len) & 0xffffffffn) << 32n) | (BigInt(ptr) & 0xffffffffn);
+const unpackSlice = (val) => ({ ptr: Number(val & 0xffffffffn), len: Number(val >> 32n) });
 const allocStruct = (mod, s) => {
-    const ptr = mod.malloc(s.size);
+    const ptr = mod.malloc(s.size, s.align);
     const value = view(s, mod.memory.buffer, ptr);
-    return resource({ ptr, value }, () => mod.free(ptr, s.size));
+    return resource({ ptr, value }, () => mod.free(ptr, s.size, s.align));
 };
 const allocArray = (mod, ctor, length) => {
-    const ptr = mod.malloc(ctor.BYTES_PER_ELEMENT * length);
+    const ptr = mod.malloc(ctor.BYTES_PER_ELEMENT * length, ctor.BYTES_PER_ELEMENT);
     const value = new ctor(mod.memory.buffer, ptr, length);
-    return resource({ ptr, value }, () => mod.free(ptr, value.byteLength));
+    const slice = packSlice(ptr, value.length);
+    return resource({ ptr, value, slice }, () => mod.free(ptr, value.byteLength, ctor.BYTES_PER_ELEMENT));
 };
-const allocdata = (mod, data) => map(allocArray(mod, ctor(data), data.length), p => {
+const allocdata = (mod, data) => map(allocArray(mod, TA.ctor(data), data.length), p => {
     p.value.set(data);
     return p;
 });
-const Slice = struct([["ptr", u32()], ["len", u32()]]);
-const allocSlice = (mod, a) => map(allocStruct(mod, Slice), x => {
-    x.value.ptr = a.ptr;
-    x.value.len = a.value.length;
-    return x;
-});
-const allocDataSlice = (mod, data) => flatMap(allocdata(mod, data), bind((allocSlice), mod));
 export const allocators = (mod) => ({
     struct: (s) => allocStruct(mod, s),
     array: (ctor, length) => allocArray(mod, ctor, length),
     data: (vals) => allocdata(mod, vals),
-    slice: (a) => allocSlice(mod, a),
-    dataSlice: (data) => allocDataSlice(mod, data),
 });
 export const init = async (url = wasmURL, imports = {
-    env: {
-        memory: new WebAssembly.Memory({ initial: 20, maximum: 100 })
-    },
     console: { log: console.log },
 }) => {
-    const mod = await wasmInit(fetch(url), imports);
+    const mod = await wasmInit(fetch(url), {
+        ...imports,
+        env: {
+            js_panic_logger(ptr, len, line) {
+                const data = new Uint8Array(mod.memory.buffer, ptr, len);
+                const fileName = new TextDecoder().decode(data);
+                console.error(`WASM PANIC: ${fileName}:${line}`);
+            },
+            js_oom_trap(size, align) {
+                console.error(`WASM Out of Memory! Failed to allocate ${size} bytes with ${align} alignment.`);
+            }
+        }
+    });
     const alloc = allocators(mod);
+    const withSlice = (res, f) => {
+        alloc.array(TA.ctor(res), res.length)(data => {
+            f(data.slice);
+            res.set(data.value);
+        })();
+        return res;
+    };
     return {
         alloc,
-        vertexPositionGeometry: (mesh) => flatMap(combine({
-            pFace: alloc.dataSlice(mesh.indices),
-            pPos: alloc.dataSlice(mesh.attribs.position)
-        }), ({ pFace, pPos }) => {
-            const ptr = mod.vertex_position_geometry(pFace.ptr, pPos.ptr);
-            const withResult = (res, f) => {
-                alloc.array(ctor(res), res.length)(data => alloc.slice(data)(s => {
-                    f(s);
-                    res.set(data.value);
-                }))();
-                return res;
-            };
+        surface: (indices) => {
+            let ptr;
+            alloc.data(indices)(x => { ptr = mod.surface_new(x.slice); })();
+            return resource({
+                nFaces: () => mod.surface_n_faces(ptr),
+                nHalfedges: () => mod.surface_n_halfedges(ptr),
+                h2f: (i) => mod.surface_h2f(ptr, i),
+                hNext: (i) => mod.surface_h_next(ptr, i),
+                hTwin: (i) => mod.surface_h_twin(ptr, i),
+                f2h: (i) => mod.surface_f2h(ptr, i),
+                geometry: (positions) => map(combine({
+                    pPos: alloc.data(positions),
+                    geom: alloc.struct(S.Geometry),
+                }), ({ pPos, geom }) => {
+                    geom.value.mesh = ptr;
+                    geom.value.data = pPos.slice;
+                    return {
+                        doubleArea: (i) => mod.surface_double_area(geom.ptr, i),
+                        doubleAreas: (res = new Float32Array(indices.length / 3)) => withSlice(res, s => mod.surface_double_areas(geom.ptr, s)),
+                        faceNormal: (f, res = new Float32Array(3)) => withSlice(res, s => mod.surface_face_normal(geom.ptr, f, s)),
+                        faceNormals: (res = new Float32Array(indices.length)) => withSlice(res, s => mod.surface_face_normals(geom.ptr, s)),
+                        internalAngles: (res = new Float32Array(indices.length)) => withSlice(res, s => mod.surface_internal_angles(geom.ptr, s)),
+                        angleDefects: (res = new Float32Array(positions.length / 3)) => withSlice(res, s => mod.surface_angle_defects(geom.ptr, s)),
+                        vertexNormalsAreaWeighted: (res = new Float32Array(positions.length)) => withSlice(res, s => mod.surface_vertex_normals_area_weighted(geom.ptr, s)),
+                        vertexNormalsAngleWeighted: (res = new Float32Array(positions.length)) => withSlice(res, s => mod.surface_vertex_normals_angle_weighted(geom.ptr, s)),
+                    };
+                })
+            }, () => mod.surface_free(ptr));
+        },
+        manifold: (indices) => {
+            let ptr;
+            alloc.data(indices)(x => { ptr = mod.manifold_new(x.slice); })();
             return resource({
-                nFaces: () => mod.n_faces(ptr),
-                nHalfedges: () => mod.n_halfedges(ptr),
-                h2f: (i) => mod.h2f(ptr, i),
-                hNext: (i) => mod.h_next(ptr, i),
-                hTwin: (i) => mod.h_twin(ptr, i),
-                f2h: (i) => mod.f2h(ptr, i),
-                doubleArea: (i) => mod.double_area(ptr, i),
-                doubleAreas: (res) => withResult(res, s => mod.double_areas(ptr, s.ptr)),
-                faceNormals: (res) => withResult(res, s => mod.face_normals(ptr, s.ptr)),
-                internalAngles: (res) => withResult(res, s => mod.internal_angles(ptr, s.ptr)),
-                vertexNormalsAreaWeighted: (res) => withResult(res, s => mod.vertex_normals_area_weighted(ptr, s.ptr)),
-                vertexNormalsAngleWeighted: (res) => withResult(res, s => mod.vertex_normals_angle_weighted(ptr, s.ptr)),
-                angleDefects: (res) => withResult(res, s => mod.angle_defects(ptr, s.ptr)),
-            }, () => mod.free_vertex_position_geometry(ptr));
-        })
+                nFaces: () => mod.manifold_n_faces(ptr),
+                nHalfedges: () => mod.manifold_n_halfedges(ptr),
+                h2f: (i) => mod.manifold_h2f(ptr, i),
+                hNext: (i) => mod.manifold_h_next(ptr, i),
+                hTwin: (i) => mod.manifold_h_twin(ptr, i),
+                f2h: (i) => mod.manifold_f2h(ptr, i),
+                geometryF: (positions) => map(combine({
+                    pPos: alloc.data(positions),
+                    geom: alloc.struct(S.Geometry),
+                }), ({ pPos, geom }) => {
+                    geom.value.mesh = ptr;
+                    geom.value.data = pPos.slice;
+                    return {
+                        faceArea: (i) => mod.manifold_face_area_f(geom.ptr, i),
+                        tracer: () => {
+                            const t = mod.geodesic_tracer_f_new(geom.ptr);
+                            const start = (p, tVec) => {
+                                let res;
+                                combine({
+                                    pt: alloc.struct(S.Point.F),
+                                    vec: alloc.data(tVec.data)
+                                })(({ pt, vec }) => {
+                                    pt.value.type = PointType[p.type];
+                                    pt.value.index = p.index;
+                                    const trPtr = mod.geodesic_tracer_f_trace_start(t, ptr, pt.ptr, vec.slice);
+                                    const tr = view(S.Trace.Result.F, mod.memory.buffer, trPtr);
+                                    res = { point: fromPoint(tr.point), state: tr.state };
+                                    mod.geodesic_tracer_f_trace_result_free(trPtr);
+                                })();
+                                return res;
+                            };
+                            const next = (state) => {
+                                const trPtr = mod.geodesic_tracer_f_trace_next(t, ptr, state);
+                                mod.geodesic_tracer_f_trace_state_free(state);
+                                const tr = view(S.Trace.Result.F, mod.memory.buffer, trPtr);
+                                const res = { point: fromPoint(tr.point), state: tr.state };
+                                mod.geodesic_tracer_f_trace_result_free(trPtr);
+                                return res;
+                            };
+                            return resource({
+                                ptr: t,
+                                trace: function* (p, tVec) {
+                                    let res = start(p, tVec);
+                                    yield res.point;
+                                    while (res.state != 0) {
+                                        res = next(res.state);
+                                        yield res.point;
+                                    }
+                                }
+                            }, () => mod.geodesic_tracer_f_free(t));
+                        },
+                        signpost: () => {
+                            const sp = mod.signpost_f_new(geom.ptr);
+                            return resource({
+                                flipToDelaunay: () => mod.signpost_f_flip_to_delaunay(sp),
+                                traceAlongInput: (tracer, i) => {
+                                    const slice = mod.signpost_f_trace_along_input(sp, tracer, ptr, i);
+                                    const unpacked = unpackSlice(slice);
+                                    const points = view(array(S.Point.F, unpacked.len), mod.memory.buffer, unpacked.ptr).map(fromPoint);
+                                    mod.free_points_f(slice);
+                                    return points;
+                                }
+                            }, () => mod.signpost_f_free(sp));
+                        }
+                    };
+                }),
+                geometryD: (positions) => map(combine({
+                    pPos: alloc.data(positions),
+                    geom: alloc.struct(S.Geometry),
+                }), ({ pPos, geom }) => {
+                    geom.value.mesh = ptr;
+                    geom.value.data = pPos.slice;
+                    return {
+                        faceArea: (i) => mod.manifold_face_area_d(geom.ptr, i),
+                        tracer: () => {
+                            const t = mod.geodesic_tracer_d_new(geom.ptr);
+                            const start = (p, tVec) => {
+                                let res;
+                                combine({
+                                    pt: alloc.struct(S.Point.D),
+                                    vec: alloc.data(tVec.data)
+                                })(({ pt, vec }) => {
+                                    pt.value.type = PointType[p.type];
+                                    pt.value.index = p.index;
+                                    const trPtr = mod.geodesic_tracer_d_trace_start(t, ptr, pt.ptr, vec.slice);
+                                    const tr = view(S.Trace.Result.D, mod.memory.buffer, trPtr);
+                                    res = { point: fromPoint(tr.point), state: tr.state };
+                                    mod.geodesic_tracer_d_trace_result_free(trPtr);
+                                })();
+                                return res;
+                            };
+                            const next = (state) => {
+                                const trPtr = mod.geodesic_tracer_d_trace_next(t, ptr, state);
+                                mod.geodesic_tracer_d_trace_state_free(state);
+                                const tr = view(S.Trace.Result.D, mod.memory.buffer, trPtr);
+                                const res = { point: fromPoint(tr.point), state: tr.state };
+                                mod.geodesic_tracer_d_trace_result_free(trPtr);
+                                return res;
+                            };
+                            return resource({
+                                ptr: t,
+                                trace: function* (p, tVec) {
+                                    let res = start(p, tVec);
+                                    yield res.point;
+                                    while (res.state != 0) {
+                                        res = next(res.state);
+                                        yield res.point;
+                                    }
+                                }
+                            }, () => mod.geodesic_tracer_d_free(t));
+                        },
+                        signpost: () => {
+                            const sp = mod.signpost_d_new(geom.ptr);
+                            return resource({
+                                flipToDelaunay: () => mod.signpost_d_flip_to_delaunay(sp),
+                                traceAlongInput: (tracer, i) => {
+                                    const slice = mod.signpost_d_trace_along_input(sp, tracer, ptr, i);
+                                    const unpacked = unpackSlice(slice);
+                                    const points = view(array(S.Point.D, unpacked.len), mod.memory.buffer, unpacked.ptr).map(fromPoint);
+                                    mod.free_points_d(slice);
+                                    return points;
+                                }
+                            }, () => mod.signpost_d_free(sp));
+                        }
+                    };
+                }),
+            }, () => mod.manifold_free(ptr));
+        }
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cgtk/gp",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "type": "module",
   "main": "./index.js",
   "exports": {
@@ -12,12 +12,14 @@
     "**/*.wasm"
   ],
   "dependencies": {
-    "@cgtk/geometry": "~0.0.19",
-    "@cgtk/std": "~0.0.188"
+    "@cgtk/std": "~0.0.192",
+    "@cgtk/linalg": "~0.0.6"
   },
   "devDependencies": {
-    "@types/bun": "^1.3.8",
-    "@types/node": "^25.2.1",
+    "@cgtk/geometry": "~0.0.23",
+    "@types/bun": "^1.3.10",
+    "@types/node": "^25.5.0",
+    "npm-check-updates": "^19.6.3",
     "typescript": "^5.9.3"
   },
   "publishConfig": {

package/point.d.ts

@@ -0,0 +1,32 @@
+import type { Vec3 } from "@cgtk/linalg/types";
+interface PointVertex {
+    type: "vertex";
+    index: number;
+}
+interface PointEdge {
+    type: "edge";
+    index: number;
+    t: number;
+}
+interface PointFace<T extends Float32Array | Float64Array> {
+    type: "face";
+    index: number;
+    p: Vec3<T>;
+}
+export type Point<T extends Float32Array | Float64Array> = PointVertex | PointEdge | PointFace<T>;
+export declare const point: {
+    readonly vertex: (index: number) => PointVertex;
+    readonly edge: (index: number, t: number) => PointEdge;
+    readonly face: <T extends Float32Array | Float64Array>(index: number, p: Vec3<T>) => PointFace<T>;
+};
+export declare const PointType: {
+    readonly vertex: 0;
+    readonly edge: 1;
+    readonly face: 2;
+};
+export declare const from: <T extends Float32Array | Float64Array>({ type, index, data }: {
+    type: number;
+    index: number;
+    data: T;
+}) => Point<T>;
+export {};

package/point.js

@@ -0,0 +1,18 @@
+import * as vec3 from "@cgtk/linalg/vec3";
+export const point = {
+    vertex: (index) => ({ type: "vertex", index }),
+    edge: (index, t) => ({ type: "edge", index, t }),
+    face: (index, p) => ({ type: "face", index, p }),
+};
+export const PointType = {
+    vertex: 0,
+    edge: 1,
+    face: 2
+};
+export const from = ({ type, index, data }) => {
+    if (type == 0)
+        return point.vertex(index);
+    else if (type == 1)
+        return point.edge(index, data[0]);
+    return point.face(index, vec3.from(data.slice()));
+};

package/struct.d.ts

@@ -0,0 +1,15 @@
+export declare const Geometry: import("@cgtk/std/struct").Struct<readonly [readonly ["mesh", import("@cgtk/std/struct").Vec<Uint32Array<ArrayBufferLike>, 1>], readonly ["data", import("@cgtk/std/struct").Vec<BigUint64Array<ArrayBufferLike>, 1>]]>;
+export declare const Point: {
+    readonly F: import("@cgtk/std/struct").Struct<readonly [readonly ["type", import("@cgtk/std/struct").Vec<Uint8Array<ArrayBufferLike>, 1>], readonly ["index", import("@cgtk/std/struct").Vec<Uint32Array<ArrayBufferLike>, 1>], readonly ["data", import("@cgtk/std/struct").Vec<Float32Array<ArrayBufferLike>, 3>]]>;
+    readonly D: import("@cgtk/std/struct").Struct<readonly [readonly ["type", import("@cgtk/std/struct").Vec<Uint8Array<ArrayBufferLike>, 1>], readonly ["index", import("@cgtk/std/struct").Vec<Uint32Array<ArrayBufferLike>, 1>], readonly ["data", import("@cgtk/std/struct").Vec<Float64Array<ArrayBufferLike>, 3>]]>;
+};
+export declare const Trace: {
+    readonly State: {
+        readonly F: import("@cgtk/std/struct").Struct<readonly [readonly ["f", import("@cgtk/std/struct").Vec<Uint32Array<ArrayBufferLike>, 1>], readonly ["p", import("@cgtk/std/struct").Vec<Float32Array<ArrayBufferLike>, 3>], readonly ["d_bary", import("@cgtk/std/struct").Vec<Float32Array<ArrayBufferLike>, 3>], readonly ["d_cart", import("@cgtk/std/struct").Vec<Float32Array<ArrayBufferLike>, 2>], readonly ["len", import("@cgtk/std/struct").Vec<Float32Array<ArrayBufferLike>, 1>]]>;
+        readonly D: import("@cgtk/std/struct").Struct<readonly [readonly ["f", import("@cgtk/std/struct").Vec<Uint32Array<ArrayBufferLike>, 1>], readonly ["p", import("@cgtk/std/struct").Vec<Float64Array<ArrayBufferLike>, 3>], readonly ["d_bary", import("@cgtk/std/struct").Vec<Float64Array<ArrayBufferLike>, 3>], readonly ["d_cart", import("@cgtk/std/struct").Vec<Float64Array<ArrayBufferLike>, 2>], readonly ["len", import("@cgtk/std/struct").Vec<Float64Array<ArrayBufferLike>, 1>]]>;
+    };
+    readonly Result: {
+        readonly F: import("@cgtk/std/struct").Struct<readonly [readonly ["point", import("@cgtk/std/struct").Struct<readonly [readonly ["type", import("@cgtk/std/struct").Vec<Uint8Array<ArrayBufferLike>, 1>], readonly ["index", import("@cgtk/std/struct").Vec<Uint32Array<ArrayBufferLike>, 1>], readonly ["data", import("@cgtk/std/struct").Vec<Float32Array<ArrayBufferLike>, 3>]]>], readonly ["state", import("@cgtk/std/struct").Vec<Uint32Array<ArrayBufferLike>, 1>]]>;
+        readonly D: import("@cgtk/std/struct").Struct<readonly [readonly ["point", import("@cgtk/std/struct").Struct<readonly [readonly ["type", import("@cgtk/std/struct").Vec<Uint8Array<ArrayBufferLike>, 1>], readonly ["index", import("@cgtk/std/struct").Vec<Uint32Array<ArrayBufferLike>, 1>], readonly ["data", import("@cgtk/std/struct").Vec<Float64Array<ArrayBufferLike>, 3>]]>], readonly ["state", import("@cgtk/std/struct").Vec<Uint32Array<ArrayBufferLike>, 1>]]>;
+    };
+};

package/struct.js

@@ -0,0 +1,45 @@
+import { struct, u32, u8, f32, f64, u64 } from "@cgtk/std/struct";
+export const Geometry = struct([
+    ["mesh", u32()],
+    ["data", u64()]
+]);
+export const Point = {
+    F: struct([
+        ["type", u8()],
+        ["index", u32()],
+        ["data", f32(3)]
+    ]),
+    D: struct([
+        ["type", u8()],
+        ["index", u32()],
+        ["data", f64(3)]
+    ])
+};
+export const Trace = {
+    State: {
+        F: struct([
+            ["f", u32()],
+            ["p", f32(3)],
+            ["d_bary", f32(3)],
+            ["d_cart", f32(2)],
+            ["len", f32()]
+        ]),
+        D: struct([
+            ["f", u32()],
+            ["p", f64(3)],
+            ["d_bary", f64(3)],
+            ["d_cart", f64(2)],
+            ["len", f64()]
+        ]),
+    },
+    Result: {
+        F: struct([
+            ["point", Point.F],
+            ["state", u32()]
+        ]),
+        D: struct([
+            ["point", Point.D],
+            ["state", u32()]
+        ])
+    }
+};