simulationjsv2 0.5.1 → 0.6.0

package/dist/graphics.js

@@ -1,22 +1,51 @@
 import { vec3, mat4, vec2, vec4 } from 'wgpu-matrix';
 import { Vertex, cloneBuf, color, colorFromVector4, vector2, vector3, vertex, Color, transitionValues, vector2FromVector3, matrix4, vector3FromVector2, distance2d } from './utils.js';
 import { BlankGeometry, CircleGeometry, CubeGeometry, Line2dGeometry, Line3dGeometry, PlaneGeometry, PolygonGeometry, Spline2dGeometry, SquareGeometry } from './geometry.js';
-import { VertexCache, bufferGenerator, logger, rotateMat4, vector2ToPixelRatio, vector3ToPixelRatio } from './internalUtils.js';
+import { VertexCache, bufferGenerator, logger, rotateMat4, vector3ToPixelRatio } from './internalUtils.js';
+import { modelProjMatOffset } from './constants.js';
 export class SimulationElement {
+    pos;
     color;
     wireframe;
     vertexCache;
     rotation;
+    modelMatrix;
+    uniformBuffer;
     isInstanced;
     /**
      * @param pos - Expected to be adjusted to devicePixelRatio before reaching constructor
      */
-    constructor(color = new Color(), rotation) {
+    constructor(pos, rotation, color = new Color()) {
+        this.pos = pos;
         this.color = color;
         this.vertexCache = new VertexCache();
         this.wireframe = false;
-        this.rotation = rotation;
         this.isInstanced = false;
+        this.rotation = rotation;
+        this.uniformBuffer = null;
+        this.modelMatrix = matrix4();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getModelMatrix(_) {
+        return this.modelMatrix;
+    }
+    getUniformBuffer(device, mat) {
+        if (!this.uniformBuffer) {
+            const uniformBufferSize = 4 * 16 + 4 * 16 + 4 * 2 + 8; // 4x4 matrix + 4x4 matrix + vec2<f32> + 8 bc 144 is cool
+            this.uniformBuffer = device.createBuffer({
+                size: uniformBufferSize,
+                usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+            });
+        }
+        device.queue.writeBuffer(this.uniformBuffer, modelProjMatOffset, mat);
+        return this.uniformBuffer;
+    }
+    updateModelMatrix3d() {
+        mat4.identity(this.modelMatrix);
+        mat4.translate(this.modelMatrix, this.pos, this.modelMatrix);
+        mat4.rotateZ(this.modelMatrix, this.rotation[2], this.modelMatrix);
+        mat4.rotateY(this.modelMatrix, this.rotation[1], this.modelMatrix);
+        mat4.rotateX(this.modelMatrix, this.rotation[0], this.modelMatrix);
     }
     getGeometryType() {
         return this.geometry.getType();
@@ -50,6 +79,62 @@ export class SimulationElement {
             this.vertexCache.updated();
         }, t, f);
     }
+    move(amount, t = 0, f) {
+        const tempAmount = cloneBuf(amount);
+        vector3ToPixelRatio(tempAmount);
+        const finalPos = cloneBuf(this.pos);
+        vec3.add(finalPos, tempAmount, finalPos);
+        return transitionValues((p) => {
+            this.pos[0] += tempAmount[0] * p;
+            this.pos[1] += tempAmount[1] * p;
+            this.pos[2] += tempAmount[2] * p;
+            this.updateModelMatrix3d();
+        }, () => {
+            this.pos = finalPos;
+            this.updateModelMatrix3d();
+        }, t, f);
+    }
+    moveTo(pos, t = 0, f) {
+        const tempPos = cloneBuf(pos);
+        vector3ToPixelRatio(tempPos);
+        const diff = vector3();
+        vec3.sub(tempPos, this.pos, diff);
+        return transitionValues((p) => {
+            this.pos[0] += diff[0] * p;
+            this.pos[1] += diff[1] * p;
+            this.pos[2] += diff[2] * p;
+            this.updateModelMatrix3d();
+        }, () => {
+            this.pos = tempPos;
+            this.updateModelMatrix3d();
+        }, t, f);
+    }
+    rotate(amount, t = 0, f) {
+        const tempAmount = cloneBuf(amount);
+        const finalRotation = cloneBuf(amount);
+        vec3.add(finalRotation, this.rotation, finalRotation);
+        return transitionValues((p) => {
+            this.rotation[0] += tempAmount[0] * p;
+            this.rotation[1] += tempAmount[1] * p;
+            this.rotation[2] += tempAmount[2] * p;
+            this.updateModelMatrix3d();
+        }, () => {
+            this.rotation = finalRotation;
+            this.updateModelMatrix3d();
+        }, t, f);
+    }
+    rotateTo(rot, t = 0, f) {
+        const diff = vec3.sub(rot, this.rotation);
+        return transitionValues((p) => {
+            this.rotation[0] += diff[0] * p;
+            this.rotation[1] += diff[1] * p;
+            this.rotation[2] += diff[2] * p;
+            this.updateModelMatrix3d();
+        }, () => {
+            this.rotation = cloneBuf(rot);
+            this.updateModelMatrix3d();
+        }, t, f);
+    }
     getVertexCount() {
         if (this.vertexCache.shouldUpdate()) {
             this.geometry.recompute();
@@ -59,25 +144,14 @@ export class SimulationElement {
         }
         return this.geometry.getTriangleVertexCount();
     }
-    defaultUpdateMatrix(camera) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    defaultUpdateMatrix(_) {
         const matrix = matrix4();
-        if (typeof this.rotation === 'number') {
-            const pos = vector3FromVector2(this.pos);
-            pos[1] = camera.getScreenSize()[1] + pos[1];
-            mat4.translate(matrix, pos, matrix);
-            mat4.rotateZ(matrix, this.rotation, matrix);
-        }
-        else {
-            mat4.translate(matrix, this.pos, matrix);
-            rotateMat4(matrix, this.rotation);
-        }
-        this.geometry.updateMatrix(matrix);
+        mat4.translate(matrix, this.pos, matrix);
+        rotateMat4(matrix, this.rotation);
     }
-    getBuffer(camera, vertexParamGenerator) {
-        const shouldEvalExtender = vertexParamGenerator?.shouldEvaluate?.();
-        const reEvalExtender = shouldEvalExtender === undefined ? true : shouldEvalExtender;
-        if (this.vertexCache.shouldUpdate() || camera.hasUpdated() || reEvalExtender) {
-            this.updateMatrix(camera);
+    getBuffer(vertexParamGenerator) {
+        if (this.vertexCache.shouldUpdate()) {
             this.geometry.recompute();
             if (this.isInstanced) {
                 bufferGenerator.setInstancing(true);
@@ -101,119 +175,33 @@ export class SimulationElement3d extends SimulationElement {
     rotation;
     is3d = true;
     constructor(pos, rotation = vector3(), color) {
-        super(color, rotation);
+        super(pos, rotation, color);
         this.pos = pos;
         vector3ToPixelRatio(this.pos);
         this.rotation = rotation;
     }
-    rotate(amount, t = 0, f) {
-        const finalRotation = cloneBuf(this.rotation);
-        vec3.add(finalRotation, amount, finalRotation);
-        return transitionValues((p) => {
-            this.rotation[0] += amount[0] * p;
-            this.rotation[1] += amount[1] * p;
-            this.rotation[2] += amount[2] * p;
-            this.vertexCache.updated();
-        }, () => {
-            this.rotation = finalRotation;
-            this.vertexCache.updated();
-        }, t, f);
-    }
-    rotateTo(rot, t = 0, f) {
-        const diff = vector3();
-        vec3.sub(rot, this.rotation, diff);
-        return transitionValues((p) => {
-            this.rotation[0] += diff[0] * p;
-            this.rotation[1] += diff[1] * p;
-            this.rotation[2] += diff[2] * p;
-            this.vertexCache.updated();
-        }, () => {
-            this.rotation = rot;
-            this.vertexCache.updated();
-        }, t, f);
-    }
-    move(amount, t = 0, f) {
-        const finalPos = cloneBuf(this.pos);
-        vec3.add(finalPos, amount, finalPos);
-        return transitionValues((p) => {
-            this.pos[0] += amount[0] * p;
-            this.pos[1] += amount[1] * p;
-            this.pos[2] += amount[2] * p;
-            this.vertexCache.updated();
-        }, () => {
-            this.pos = finalPos;
-            this.vertexCache.updated();
-        }, t, f);
-    }
-    moveTo(pos, t = 0, f) {
-        const diff = vector3();
-        vec3.sub(pos, this.pos, diff);
-        return transitionValues((p) => {
-            this.pos[0] += diff[0] * p;
-            this.pos[1] += diff[1] * p;
-            this.pos[2] += diff[2] * p;
-            this.vertexCache.updated();
-        }, () => {
-            this.pos = pos;
-            this.vertexCache.updated();
-        }, t, f);
-    }
 }
 export class SimulationElement2d extends SimulationElement {
-    pos;
-    rotation;
-    constructor(pos, rotation = 0, color) {
-        super(color, rotation);
-        this.pos = pos;
-        this.rotation = rotation;
+    constructor(pos, rotation = vector3(), color) {
+        super(vector3FromVector2(pos), rotation, color);
+        vector3ToPixelRatio(this.pos);
     }
-    rotate(rotation, t = 0, f) {
-        const finalRotation = this.rotation + rotation;
-        return transitionValues((p) => {
-            this.rotation += rotation * p;
-            this.vertexCache.updated();
-        }, () => {
-            this.rotation = finalRotation;
-            this.vertexCache.updated();
-        }, t, f);
+    rotate2d(amount, t = 0, f) {
+        return super.rotate(vector3(0, 0, amount), t, f);
     }
-    rotateTo(newRotation, t = 0, f) {
-        const diff = newRotation - this.rotation;
-        return transitionValues((p) => {
-            this.rotation += diff * p;
-            this.vertexCache.updated();
-        }, () => {
-            this.rotation = newRotation;
-            this.vertexCache.updated();
-        }, t, f);
+    rotateTo2d(rot, t = 0, f) {
+        return super.rotateTo(vector3(0, 0, rot), t, f);
     }
-    move(amount, t = 0, f) {
-        const tempAmount = cloneBuf(amount);
-        vector2ToPixelRatio(tempAmount);
-        const finalPos = vector2();
-        vec3.add(tempAmount, this.pos, finalPos);
-        return transitionValues((p) => {
-            this.pos[0] += tempAmount[0] * p;
-            this.pos[1] += tempAmount[1] * p;
-            this.vertexCache.updated();
-        }, () => {
-            this.pos = finalPos;
-            this.vertexCache.updated();
-        }, t, f);
+    updateModelMatrix2d(camera) {
+        mat4.identity(this.modelMatrix);
+        const pos = cloneBuf(this.pos);
+        pos[1] = camera.getScreenSize()[1] + pos[1];
+        mat4.translate(this.modelMatrix, pos, this.modelMatrix);
+        mat4.rotateZ(this.modelMatrix, this.rotation[2], this.modelMatrix);
     }
-    moveTo(newPos, t = 0, f) {
-        const pos = cloneBuf(newPos);
-        vector2ToPixelRatio(pos);
-        const diff = vector2();
-        vec2.sub(pos, this.pos, diff);
-        return transitionValues((p) => {
-            this.pos[0] += diff[0] * p;
-            this.pos[1] += diff[1] * p;
-            this.vertexCache.updated();
-        }, () => {
-            this.pos = pos;
-            this.vertexCache.updated();
-        }, t, f);
+    getModelMatrix(camera) {
+        this.updateModelMatrix2d(camera);
+        return this.modelMatrix;
     }
 }
 export class Plane extends SimulationElement3d {
@@ -229,9 +217,6 @@ export class Plane extends SimulationElement3d {
         this.points = newPoints;
         this.vertexCache.updated();
     }
-    updateMatrix(camera) {
-        this.defaultUpdateMatrix(camera);
-    }
 }
 export class Square extends SimulationElement2d {
     geometry;
@@ -243,14 +228,23 @@ export class Square extends SimulationElement2d {
      * @param vertexColors{Record<number, Color>} - 0 is top left vertex, numbers increase clockwise
      */
     constructor(pos, width, height, color, rotation, centerOffset, vertexColors) {
-        super(pos, rotation, color);
-        vector2ToPixelRatio(this.pos);
+        super(pos, vector3(0, 0, rotation), color);
         this.width = width * devicePixelRatio;
         this.height = height * devicePixelRatio;
         this.vertexColors = this.cloneColorMap(vertexColors || {});
         this.geometry = new SquareGeometry(this.width, this.height, centerOffset);
         this.geometry.setVertexColorMap(this.vertexColors);
     }
+    setOffset(offset) {
+        this.geometry.setOffset(offset);
+    }
+    setOffsetInplace(offset) {
+        const diff = vector3FromVector2(offset);
+        vec2.sub(diff, this.geometry.getOffset(), diff);
+        vec2.mul(diff, vector2(this.width / devicePixelRatio, -this.height / devicePixelRatio), diff);
+        this.setOffset(offset);
+        this.move(diff);
+    }
     cloneColorMap(colorMap) {
         const newColorMap = {};
         Object.entries(colorMap).forEach(([key, value]) => {
@@ -364,23 +358,14 @@ export class Square extends SimulationElement2d {
             this.vertexCache.updated();
         }, t, f);
     }
-    updateMatrix(camera) {
-        const pos = cloneBuf(this.pos);
-        pos[1] = camera.getScreenSize()[1] + pos[1];
-        const matrix = matrix4();
-        mat4.translate(matrix, vector3FromVector2(pos), matrix);
-        mat4.rotateZ(matrix, this.rotation, matrix);
-        this.geometry.updateMatrix(matrix);
-    }
 }
 export class Circle extends SimulationElement2d {
     geometry;
     radius;
     detail;
     constructor(pos, radius, color, detail = 50) {
-        super(pos, 0, color);
-        vector2ToPixelRatio(this.pos);
-        this.radius = radius;
+        super(pos, vector3(), color);
+        this.radius = radius * devicePixelRatio;
         this.detail = detail;
         this.geometry = new CircleGeometry(this.radius, this.detail);
     }
@@ -410,15 +395,12 @@ export class Circle extends SimulationElement2d {
             this.vertexCache.updated();
         }, t, f);
     }
-    updateMatrix(camera) {
-        this.defaultUpdateMatrix(camera);
-    }
 }
 export class Polygon extends SimulationElement2d {
     geometry;
     vertices;
     constructor(pos, points, color, rotation) {
-        super(pos, rotation, color);
+        super(pos, vector3(0, 0, rotation), color);
         this.vertices = points;
         this.geometry = new PolygonGeometry(this.vertices);
     }
@@ -492,9 +474,6 @@ export class Polygon extends SimulationElement2d {
             this.vertexCache.updated();
         }, t, f);
     }
-    updateMatrix(camera) {
-        this.defaultUpdateMatrix(camera);
-    }
 }
 export class Line3d extends SimulationElement3d {
     geometry;
@@ -506,7 +485,7 @@ export class Line3d extends SimulationElement3d {
         this.to = to.getPos();
         vec3.scale(this.to, devicePixelRatio, this.to);
         vec3.sub(this.to, this.pos, this.to);
-        this.geometry = new Line3dGeometry(this.pos, this.to, this.thickness);
+        this.geometry = new Line3dGeometry(this.pos, this.to, this.thickness, pos.getColor() || this.getColor(), to.getColor());
     }
     setStart(pos, t = 0, f) {
         return this.moveTo(pos, t, f);
@@ -526,41 +505,37 @@ export class Line3d extends SimulationElement3d {
             this.vertexCache.updated();
         }, t, f);
     }
-    updateMatrix(camera) {
-        return this.defaultUpdateMatrix(camera);
-    }
 }
 export class Line2d extends SimulationElement2d {
     geometry;
     to;
     thickness;
     constructor(from, to, thickness = 1) {
-        super(vector2FromVector3(from.getPos()), 0, from.getColor() || undefined);
+        super(vector2FromVector3(from.getPos()), vector3(), from.getColor() || undefined);
         this.thickness = thickness * devicePixelRatio;
-        this.to = vector2FromVector3(to.getPos());
-        vec2.scale(this.to, devicePixelRatio, this.to);
+        this.to = to.getPos();
         vec2.sub(this.to, this.pos, this.to);
-        this.geometry = new Line2dGeometry(this.pos, this.to, this.thickness);
+        this.geometry = new Line2dGeometry(this.pos, this.to, this.thickness, from.getColor() || this.getColor(), to.getColor());
     }
     setStart(pos, t = 0, f) {
         return this.moveTo(pos, t, f);
     }
     setEnd(pos, t = 0, f) {
+        const tempPos = cloneBuf(pos);
+        vector3ToPixelRatio(tempPos);
+        // vec2.sub(tempPos, this.getPos(), tempPos);
         const diff = vector3();
-        vec2.sub(pos, this.to, diff);
+        vec2.sub(tempPos, this.to, diff);
         return transitionValues((p) => {
             this.to[0] += diff[0] * p;
             this.to[1] += diff[1] * p;
             this.vertexCache.updated();
         }, () => {
-            this.to[0] = pos[0];
-            this.to[1] = pos[1];
+            this.to[0] = tempPos[0];
+            this.to[1] = tempPos[1];
             this.vertexCache.updated();
         }, t, f);
     }
-    updateMatrix(camera) {
-        return this.defaultUpdateMatrix(camera);
-    }
 }
 export class Cube extends SimulationElement3d {
     geometry;
@@ -639,9 +614,6 @@ export class Cube extends SimulationElement3d {
             this.vertexCache.updated();
         }, t, f);
     }
-    updateMatrix(camera) {
-        this.defaultUpdateMatrix(camera);
-    }
 }
 export class BezierCurve2d {
     points;
@@ -793,8 +765,7 @@ export class Spline2d extends SimulationElement2d {
     length;
     constructor(pos, points, thickness = devicePixelRatio, detail = 40) {
         const tempPos = vector2FromVector3(pos.getPos());
-        vector2ToPixelRatio(tempPos);
-        super(tempPos, 0, pos.getColor() || undefined);
+        super(tempPos, vector3(), pos.getColor() || undefined);
         this.thickness = thickness * devicePixelRatio;
         this.detail = detail;
         this.interpolateStart = 0;
@@ -846,7 +817,7 @@ export class Spline2d extends SimulationElement2d {
         const clonePoint = newPoint.clone();
         const start = clonePoint.getStart()?.getPos() || vector3();
         const end = clonePoint.getEnd().getPos();
-        const pos = vector3FromVector2(this.getPos());
+        const pos = this.getPos();
         vec3.sub(start, pos, start);
         vec3.sub(end, pos, end);
         this.geometry.updatePoint(pointIndex, clonePoint);
@@ -890,9 +861,6 @@ export class Spline2d extends SimulationElement2d {
         const [vec] = this.interpolateSlope(t);
         return vec;
     }
-    updateMatrix(camera) {
-        this.defaultUpdateMatrix(camera);
-    }
 }
 export class Instance extends SimulationElement3d {
     geometry;
@@ -901,7 +869,6 @@ export class Instance extends SimulationElement3d {
     matrixBuffer;
     device;
     baseMat;
-    needsRemap = false;
     constructor(obj, numInstances) {
         super(vector3());
         this.device = null;
@@ -942,16 +909,11 @@ export class Instance extends SimulationElement3d {
             const clone = cloneBuf(this.baseMat);
             this.instanceMatrix[i] = clone;
         }
-        if (this.device) {
-            this.setMatrixBuffer();
-            this.needsRemap = true;
-        }
     }
     setInstance(instance, transformation) {
         if (instance >= this.instanceMatrix.length || instance < 0)
             return;
         this.instanceMatrix[instance] = transformation;
-        this.needsRemap = true;
     }
     mapBuffer() {
         if (!this.device || this.matrixBuffer === null)
@@ -959,18 +921,6 @@ export class Instance extends SimulationElement3d {
         const buf = new Float32Array(this.instanceMatrix.map((mat) => [...mat]).flat());
         this.device.queue.writeBuffer(this.matrixBuffer, 0, buf.buffer, buf.byteOffset, buf.byteLength);
         this.matrixBuffer.unmap();
-        this.needsRemap = false;
-    }
-    setMatrixBuffer() {
-        if (!this.device || this.instanceMatrix.length === 0)
-            return;
-        const minSize = 640;
-        const size = Math.max(minSize, this.instanceMatrix[0].byteLength * this.instanceMatrix.length);
-        this.matrixBuffer = this.device.createBuffer({
-            size,
-            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
-        });
-        this.needsRemap = true;
     }
     getInstances() {
         return this.instanceMatrix;
@@ -978,13 +928,16 @@ export class Instance extends SimulationElement3d {
     getNumInstances() {
         return this.instanceMatrix.length;
     }
-    setDevice(device) {
-        this.device = device;
-        if (this.matrixBuffer === null) {
-            this.setMatrixBuffer();
+    getMatrixBuffer(device) {
+        if (!this.matrixBuffer) {
+            const minSize = 640;
+            const size = Math.max(minSize, this.instanceMatrix[0].byteLength * this.instanceMatrix.length);
+            this.matrixBuffer = device.createBuffer({
+                size,
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+            });
         }
-    }
-    getMatrixBuffer() {
+        this.mapBuffer();
         return this.matrixBuffer;
     }
     getVertexCount() {
@@ -993,11 +946,7 @@ export class Instance extends SimulationElement3d {
     getGeometryType() {
         return this.obj.getGeometryType();
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    updateMatrix(_) { }
-    getBuffer(camera) {
-        if (this.needsRemap)
-            this.mapBuffer();
-        return this.obj.getBuffer(camera);
+    getBuffer() {
+        return this.obj.getBuffer();
     }
 }

package/dist/internalUtils.d.ts

@@ -1,19 +1,20 @@
 /// <reference types="@webgpu/types" />
 import { AnySimulationElement, VertexParamGeneratorInfo, Mat4, Vector2, Vector3, VertexParamInfo } from './types.js';
 import { Color } from './utils.js';
+import { Camera } from './simulation.js';
 export declare class VertexCache {
     private vertices;
     private hasUpdated;
     constructor();
-    setCache(vertices: number[]): void;
-    getCache(): number[];
+    setCache(vertices: Float32Array | number[]): void;
+    getCache(): Float32Array;
     updated(): void;
     shouldUpdate(): boolean;
     getVertexCount(): number;
 }
-export declare const buildProjectionMatrix: (aspectRatio: number, zNear?: number, zFar?: number) => any;
-export declare const getTransformationMatrix: (pos: Vector3, rotation: Vector3, projectionMatrix: mat4) => Float32Array;
-export declare const getOrthoMatrix: (screenSize: [number, number]) => Float32Array;
+export declare const updateProjectionMatrix: (mat: Mat4, aspectRatio: number, zNear?: number, zFar?: number) => any;
+export declare const updateWorldProjectionMatrix: (worldProjMat: Mat4, projMat: Mat4, camera: Camera) => void;
+export declare const updateOrthoProjectionMatrix: (mat: Mat4, screenSize: [number, number]) => Float32Array;
 export declare const buildDepthTexture: (device: GPUDevice, width: number, height: number) => GPUTexture;
 export declare const buildMultisampleTexture: (device: GPUDevice, ctx: GPUCanvasContext, width: number, height: number) => GPUTexture;
 export declare const addObject: (scene: SimSceneObjInfo[], el: AnySimulationElement, device: GPUDevice | null, id?: string) => void;
@@ -48,6 +49,7 @@ declare class Logger {
 }
 export declare const logger: Logger;
 export declare function lossyTriangulate<T>(vertices: T[]): (readonly [T, T, T])[];
+export declare function lossyTriangulateStrip<T>(vertices: T[]): T[];
 declare class BufferGenerator {
     private instancing;
     constructor();
@@ -59,7 +61,8 @@ export declare function vector3ToPixelRatio(vec: Vector3): void;
 export declare function vector2ToPixelRatio(vec: Vector2): void;
 export declare function matrixFromRotation(rotation: Vector3): Mat4;
 export declare function rotateMat4(mat: Mat4, rotation: Vector3): void;
-export declare function createPipeline(device: GPUDevice, module: GPUShaderModule, bindGroupLayouts: GPUBindGroupLayout[], presentationFormat: GPUTextureFormat, entryPoint: string, topology: GPUPrimitiveTopology, vertexParams?: VertexParamInfo[]): GPURenderPipeline;
+export declare function createPipeline(device: GPUDevice, module: GPUShaderModule, bindGroupLayouts: GPUBindGroupLayout[], presentationFormat: GPUTextureFormat, topology: GPUPrimitiveTopology, vertexParams?: VertexParamInfo[]): GPURenderPipeline;
 export declare function triangulateWireFrameOrder(len: number): number[];
 export declare function getTotalVertices(scene: SimSceneObjInfo[]): number;
+export declare function wrapVoidPromise(promise: Promise<unknown>): Promise<void>;
 export {};