@cgtk/gp 0.0.13

package/index.d.ts

@@ -0,0 +1,77 @@
+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";
+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>;
+}
+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<{
+        ptr: number;
+        len: number;
+    }>>;
+    dataSlice: <T extends TypedArray>(data: T) => Resource<Alloc<{
+        ptr: number;
+        len: number;
+    }>>;
+};
+export declare const init: (url?: any, 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<{
+            ptr: number;
+            len: number;
+        }>>;
+        dataSlice: <T extends TypedArray>(data: T) => Resource<Alloc<{
+            ptr: number;
+            len: number;
+        }>>;
+    };
+    vertexPositionGeometry: (mesh: IndexedMesh<{
+        position: Float32Array;
+    }, Uint32Array>) => 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;
+    }>;
+}>;
+export {};

package/index.js

@@ -0,0 +1,75 @@
+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 wasmURL from './gp.wasm?url';
+export const wasmInit = async (source, imports) => (await WebAssembly.instantiateStreaming(source, imports)).instance.exports;
+;
+const allocStruct = (mod, s) => {
+    const ptr = mod.malloc(s.size);
+    const value = view(s, mod.memory.buffer, ptr);
+    return resource({ ptr, value }, () => mod.free(ptr, s.size));
+};
+const allocArray = (mod, ctor, length) => {
+    const ptr = mod.malloc(ctor.BYTES_PER_ELEMENT * length);
+    const value = new ctor(mod.memory.buffer, ptr, length);
+    return resource({ ptr, value }, () => mod.free(ptr, value.byteLength));
+};
+const allocdata = (mod, data) => map(allocArray(mod, 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 alloc = allocators(mod);
+    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;
+            };
+            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));
+        })
+    };
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@cgtk/gp",
+  "version": "0.0.13",
+  "type": "module",
+  "main": "./index.js",
+  "exports": {
+    ".": "./index.js"
+  },
+  "files": [
+    "**/*.js",
+    "**/*.d.ts",
+    "**/*.wasm"
+  ],
+  "dependencies": {
+    "@cgtk/geometry": "~0.0.19",
+    "@cgtk/std": "~0.0.188"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.8",
+    "@types/node": "^25.2.1",
+    "typescript": "^5.9.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}