@multiplekex/shallot 0.1.9 → 0.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@multiplekex/shallot",
-    "version": "0.1.9",
+    "version": "0.1.11",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/rust/transforms/pkg/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "shallot-transforms",
+  "type": "module",
+  "version": "0.1.0",
+  "files": [
+    "shallot_transforms_bg.wasm",
+    "shallot_transforms.js",
+    "shallot_transforms.d.ts"
+  ],
+  "main": "shallot_transforms.js",
+  "types": "shallot_transforms.d.ts",
+  "sideEffects": [
+    "./snippets/*"
+  ]
+}

package/rust/transforms/pkg/shallot_transforms.d.ts

@@ -0,0 +1,81 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export function compute_transforms(count: number): void;
+
+export function get_indices_ptr(): number;
+
+export function get_matrices_ptr(): number;
+
+export function get_max_entities(): number;
+
+export function get_no_parent(): number;
+
+export function get_parents_ptr(): number;
+
+export function get_pos_x_ptr(): number;
+
+export function get_pos_y_ptr(): number;
+
+export function get_pos_z_ptr(): number;
+
+export function get_quat_w_ptr(): number;
+
+export function get_quat_x_ptr(): number;
+
+export function get_quat_y_ptr(): number;
+
+export function get_quat_z_ptr(): number;
+
+export function get_scale_x_ptr(): number;
+
+export function get_scale_y_ptr(): number;
+
+export function get_scale_z_ptr(): number;
+
+export function init_data(): void;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly compute_transforms: (a: number) => void;
+  readonly get_indices_ptr: () => number;
+  readonly get_matrices_ptr: () => number;
+  readonly get_max_entities: () => number;
+  readonly get_no_parent: () => number;
+  readonly get_parents_ptr: () => number;
+  readonly get_pos_x_ptr: () => number;
+  readonly get_pos_y_ptr: () => number;
+  readonly get_pos_z_ptr: () => number;
+  readonly get_quat_w_ptr: () => number;
+  readonly get_quat_x_ptr: () => number;
+  readonly get_quat_y_ptr: () => number;
+  readonly get_quat_z_ptr: () => number;
+  readonly get_scale_x_ptr: () => number;
+  readonly get_scale_y_ptr: () => number;
+  readonly get_scale_z_ptr: () => number;
+  readonly init_data: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+*
+* @returns {Promise<InitOutput>}
+*/
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/rust/transforms/pkg/shallot_transforms.js

@@ -0,0 +1,229 @@
+let wasm;
+
+/**
+ * @param {number} count
+ */
+export function compute_transforms(count) {
+    wasm.compute_transforms(count);
+}
+
+/**
+ * @returns {number}
+ */
+export function get_indices_ptr() {
+    const ret = wasm.get_indices_ptr();
+    return ret >>> 0;
+}
+
+/**
+ * @returns {number}
+ */
+export function get_matrices_ptr() {
+    const ret = wasm.get_matrices_ptr();
+    return ret >>> 0;
+}
+
+/**
+ * @returns {number}
+ */
+export function get_max_entities() {
+    const ret = wasm.get_max_entities();
+    return ret >>> 0;
+}
+
+/**
+ * @returns {number}
+ */
+export function get_no_parent() {
+    const ret = wasm.get_no_parent();
+    return ret >>> 0;
+}
+
+/**
+ * @returns {number}
+ */
+export function get_parents_ptr() {
+    const ret = wasm.get_parents_ptr();
+    return ret >>> 0;
+}
+
+/**
+ * @returns {number}
+ */
+export function get_pos_x_ptr() {
+    const ret = wasm.get_pos_x_ptr();
+    return ret >>> 0;
+}
+
+/**
+ * @returns {number}
+ */
+export function get_pos_y_ptr() {
+    const ret = wasm.get_pos_y_ptr();
+    return ret >>> 0;
+}
+
+/**
+ * @returns {number}
+ */
+export function get_pos_z_ptr() {
+    const ret = wasm.get_pos_z_ptr();
+    return ret >>> 0;
+}
+
+/**
+ * @returns {number}
+ */
+export function get_quat_w_ptr() {
+    const ret = wasm.get_quat_w_ptr();
+    return ret >>> 0;
+}
+
+/**
+ * @returns {number}
+ */
+export function get_quat_x_ptr() {
+    const ret = wasm.get_quat_x_ptr();
+    return ret >>> 0;
+}
+
+/**
+ * @returns {number}
+ */
+export function get_quat_y_ptr() {
+    const ret = wasm.get_quat_y_ptr();
+    return ret >>> 0;
+}
+
+/**
+ * @returns {number}
+ */
+export function get_quat_z_ptr() {
+    const ret = wasm.get_quat_z_ptr();
+    return ret >>> 0;
+}
+
+/**
+ * @returns {number}
+ */
+export function get_scale_x_ptr() {
+    const ret = wasm.get_scale_x_ptr();
+    return ret >>> 0;
+}
+
+/**
+ * @returns {number}
+ */
+export function get_scale_y_ptr() {
+    const ret = wasm.get_scale_y_ptr();
+    return ret >>> 0;
+}
+
+/**
+ * @returns {number}
+ */
+export function get_scale_z_ptr() {
+    const ret = wasm.get_scale_z_ptr();
+    return ret >>> 0;
+}
+
+export function init_data() {
+    wasm.init_data();
+}
+
+const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = module.ok && EXPECTED_RESPONSE_TYPES.has(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else {
+                    throw e;
+                }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+}
+
+function __wbg_get_imports() {
+    const imports = {};
+    imports.wbg = {};
+
+    return imports;
+}
+
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    __wbg_init.__wbindgen_wasm_module = module;
+
+
+
+    return wasm;
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof module !== 'undefined') {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof module_or_path !== 'undefined') {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (typeof module_or_path === 'undefined') {
+        module_or_path = new URL('shallot_transforms_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync };
+export default __wbg_init;

package/rust/transforms/pkg/shallot_transforms_bg.wasm.d.ts

@@ -0,0 +1,20 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const compute_transforms: (a: number) => void;
+export const get_indices_ptr: () => number;
+export const get_matrices_ptr: () => number;
+export const get_max_entities: () => number;
+export const get_no_parent: () => number;
+export const get_parents_ptr: () => number;
+export const get_pos_x_ptr: () => number;
+export const get_pos_y_ptr: () => number;
+export const get_pos_z_ptr: () => number;
+export const get_quat_w_ptr: () => number;
+export const get_quat_x_ptr: () => number;
+export const get_quat_y_ptr: () => number;
+export const get_quat_z_ptr: () => number;
+export const get_scale_x_ptr: () => number;
+export const get_scale_y_ptr: () => number;
+export const get_scale_z_ptr: () => number;
+export const init_data: () => void;

package/src/core/runtime.ts

@@ -111,6 +111,7 @@ function createStandaloneRuntime(): Runtime {
                 }
                 return response.text();
             }
+            // @ts-ignore - Tauri plugin only available in Tauri context
             const { readTextFile } = await import(/* @vite-ignore */ "@tauri-apps/plugin-fs");
             return readTextFile(path);
         },
@@ -123,6 +124,7 @@ function createStandaloneRuntime(): Runtime {
                 }
                 return response.arrayBuffer();
             }
+            // @ts-ignore - Tauri plugin only available in Tauri context
             const { readFile } = await import(/* @vite-ignore */ "@tauri-apps/plugin-fs");
             const bytes = await readFile(path);
             return bytes.buffer;

package/src/core/state.ts

@@ -37,6 +37,7 @@ export class State {
     readonly world: World;
     readonly scheduler = new Scheduler();
     readonly canvas: HTMLCanvasElement | null;
+    maxEid = 0;
 
     private _resources = new Map<symbol, unknown>();
     private _disposed = false;
@@ -140,6 +141,7 @@ export class State {
         if (eid >= MAX_ENTITIES) {
             throw new Error(`Entity limit exceeded: ${eid} >= ${MAX_ENTITIES}`);
         }
+        if (eid > this.maxEid) this.maxEid = eid;
         return eid;
     }
 

package/src/extras/arrows/index.ts

@@ -5,9 +5,10 @@ import {
     Render,
     RenderPlugin,
     DEPTH_FORMAT,
-    registerDrawContributor,
-    type DrawContributor,
-    type DrawContext,
+    Pass,
+    registerDraw,
+    type Draw,
+    type SharedPassContext,
 } from "../../standard/render";
 import { Transform } from "../../standard/transforms";
 import { Line, Lines, LinesPlugin } from "../lines";
@@ -245,15 +246,18 @@ export function createArrowsPipeline(
     });
 }
 
-function createArrowsContributor(config: ArrowsConfig): DrawContributor {
+function createArrowsDraw(config: ArrowsConfig): Draw {
     let pipeline: GPURenderPipeline | null = null;
     let bindGroup: GPUBindGroup | null = null;
 
     return {
         id: "arrows",
+        pass: Pass.Transparent,
         order: 1,
 
-        draw(pass: GPURenderPassEncoder, ctx: DrawContext) {
+        execute() {},
+
+        draw(pass: GPURenderPassEncoder, ctx: SharedPassContext) {
             const count = config.getCount();
             if (count === 0) return;
 
@@ -314,7 +318,8 @@ const ArrowsSystem: System = {
             }
         }
 
-        device.queue.writeBuffer(arrows.buffer, 0, ArrowData.data);
+        const uploadCount = state.maxEid + 1;
+        device.queue.writeBuffer(arrows.buffer, 0, ArrowData.data, 0, uploadCount * 4);
         device.queue.writeBuffer(arrows.entityIds, 0, arrowEntityIdArray, 0, count);
         arrows.count = count;
     },
@@ -345,9 +350,9 @@ export const ArrowsPlugin: Plugin = {
 
         state.setResource(Arrows, arrowsState);
 
-        registerDrawContributor(
+        registerDraw(
             state,
-            createArrowsContributor({
+            createArrowsDraw({
                 scene: render.scene,
                 arrows: arrowsState.buffer,
                 lines: lines.buffer,