simulationjsv2 0.4.5 → 0.4.6

package/dist/graphics.d.ts

@@ -183,7 +183,6 @@ export declare class Instance<T extends SimulationElement2d | SimulationElement3
     private instanceMatrix;
     private matrixBuffer;
     private device;
-    readonly isInstance = true;
     private baseMat;
     constructor(obj: T, numInstances: number);
     setNumInstances(numInstances: number): void;

package/dist/graphics.js

@@ -894,7 +894,6 @@ export class Instance extends SimulationElement3d {
     instanceMatrix;
     matrixBuffer;
     device;
-    isInstance = true;
     baseMat;
     constructor(obj, numInstances) {
         super(vector3());
@@ -942,7 +941,7 @@ export class Instance extends SimulationElement3d {
         }
     }
     setInstance(instance, transformation) {
-        if (instance >= this.instanceMatrix.length)
+        if (instance >= this.instanceMatrix.length || instance < 0)
             return;
         this.instanceMatrix[instance] = transformation;
         this.mapBuffer();

package/dist/internalUtils.d.ts

@@ -17,7 +17,7 @@ export declare const getTransformationMatrix: (pos: Vector3, rotation: Vector3,
 export declare const getOrthoMatrix: (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: SimulationElement<any>, id?: string) => void;
+export declare const addObject: (scene: SimSceneObjInfo[], el: SimulationElement<any>, device: GPUDevice | null, id?: string) => void;
 export declare const removeObject: (scene: SimSceneObjInfo[], el: SimulationElement<any>) => void;
 export declare const removeObjectId: (scene: SimSceneObjInfo[], id: string) => void;
 export declare class SimSceneObjInfo {

package/dist/internalUtils.js

@@ -1,7 +1,8 @@
 import { mat4, vec3 } from 'wgpu-matrix';
 import { BUF_LEN, colorOffset, drawingInstancesOffset, uvOffset, vertexSize } from './constants.js';
 import { vector2, vector3 } from './utils.js';
-import { SimulationElement } from './graphics.js';
+import { Instance, SimulationElement } from './graphics.js';
+import { SceneCollection } from './simulation.js';
 export class VertexCache {
     vertices = [];
     hasUpdated = true;
@@ -59,8 +60,11 @@ export const buildMultisampleTexture = (device, ctx, width, height) => {
         sampleCount: 4
     });
 };
-export const addObject = (scene, el, id) => {
+export const addObject = (scene, el, device, id) => {
     if (el instanceof SimulationElement) {
+        if (device !== null && (el instanceof Instance || el instanceof SceneCollection)) {
+            el.setDevice(device);
+        }
         const obj = new SimSceneObjInfo(el, id);
         scene.unshift(obj);
     }

package/dist/simulation.d.ts

@@ -13,6 +13,7 @@ export declare class Simulation {
     private initialized;
     private frameRateView;
     private camera;
+    private device;
     private pipelines;
     private renderInfo;
     constructor(idOrCanvasRef: string | HTMLCanvasElement, camera?: Camera | null, showFrameRate?: boolean);
@@ -25,31 +26,33 @@ export declare class Simulation {
     setLifetime(el: SimulationElement<any>, lifetime: number): void;
     setCanvasSize(width: number, height: number): void;
     start(): void;
+    private propagateDevice;
     stop(): void;
     setBackground(color: Color): void;
     getScene(): SimSceneObjInfo[];
     getSceneObjects(): SimulationElement<Vector3 | Vector2>[];
-    private propagateDevice;
-    render(device: GPUDevice, ctx: GPUCanvasContext): void;
+    private render;
     private renderScene;
     fitElement(): void;
-    private assertHasCanvas;
 }
 export declare class SceneCollection extends SimulationElement3d {
     protected geometry: BlankGeometry;
     private name;
     private scene;
-    readonly isCollection = true;
+    private device;
     constructor(name: string);
     setWireframe(_: boolean): void;
     getName(): string;
     getScene(): SimSceneObjInfo[];
+    setDevice(device: GPUDevice): void;
+    private propagateDevice;
     getVertexCount(): number;
     getSceneObjects(): SimulationElement<Vector3 | Vector2>[];
     setSceneObjects(newScene: SimulationElement<any>[]): void;
     setScene(newScene: SimSceneObjInfo[]): void;
-    add(el: SimulationElement<any>): void;
+    add(el: SimulationElement<any>, id?: string): void;
     remove(el: SimulationElement<any>): void;
+    removeId(id: string): void;
     /**
      * @param lifetime - ms
      */

package/dist/simulation.js

@@ -1,5 +1,5 @@
 import { vec3 } from 'wgpu-matrix';
-import { SimulationElement3d } from './graphics.js';
+import { Instance, SimulationElement3d } from './graphics.js';
 import { BUF_LEN } from './constants.js';
 import { Color, toSceneObjInfoMany, transitionValues, vector2, vector3 } from './utils.js';
 import { BlankGeometry } from './geometry.js';
@@ -118,8 +118,9 @@ export class Simulation {
     initialized = false;
     frameRateView;
     camera;
-    pipelines;
-    renderInfo;
+    device = null;
+    pipelines = null;
+    renderInfo = null;
     constructor(idOrCanvasRef, camera = null, showFrameRate = false) {
         if (typeof idOrCanvasRef === 'string') {
             const ref = document.getElementById(idOrCanvasRef);
@@ -148,13 +149,11 @@ export class Simulation {
                 this.setCanvasSize(width, height);
             }
         });
-        this.renderInfo = null;
-        this.pipelines = null;
         this.frameRateView = new FrameRateView(showFrameRate);
         this.frameRateView.updateFrameRate(1);
     }
     add(el, id) {
-        addObject(this.scene, el, id);
+        addObject(this.scene, el, this.device, id);
     }
     remove(el) {
         removeObject(this.scene, el);
@@ -172,7 +171,8 @@ export class Simulation {
         }
     }
     setCanvasSize(width, height) {
-        this.assertHasCanvas();
+        if (this.canvasRef === null)
+            return;
         this.canvasRef.width = width * devicePixelRatio;
         this.canvasRef.height = height * devicePixelRatio;
         this.canvasRef.style.width = width + 'px';
@@ -184,7 +184,8 @@ export class Simulation {
             return;
         }
         (async () => {
-            this.assertHasCanvas();
+            if (this.canvasRef === null)
+                return;
             this.initialized = true;
             this.running = true;
             const adapter = await navigator.gpu.requestAdapter();
@@ -194,6 +195,7 @@ export class Simulation {
             if (!ctx)
                 throw logger.error('Context is null');
             const device = await adapter.requestDevice();
+            this.device = device;
             this.propagateDevice(device);
             ctx.configure({
                 device,
@@ -201,9 +203,17 @@ export class Simulation {
             });
             const screenSize = vector2(this.canvasRef.width, this.canvasRef.height);
             this.camera.setScreenSize(screenSize);
-            this.render(device, ctx);
+            this.render(ctx);
         })();
     }
+    propagateDevice(device) {
+        for (let i = 0; i < this.scene.length; i++) {
+            const el = this.scene[i].getObj();
+            if (el instanceof Instance || el instanceof SceneCollection) {
+                el.setDevice(device);
+            }
+        }
+    }
     stop() {
         this.running = false;
     }
@@ -216,17 +226,11 @@ export class Simulation {
     getSceneObjects() {
         return this.scene.map((item) => item.getObj());
     }
-    propagateDevice(device) {
-        for (let i = 0; i < this.scene.length; i++) {
-            const obj = this.scene[i].getObj();
-            if (obj.isInstance) {
-                obj.setDevice(device);
-            }
-        }
-    }
-    render(device, ctx) {
-        this.assertHasCanvas();
+    render(ctx) {
+        if (this.canvasRef === null || this.device === null)
+            return;
         const canvas = this.canvasRef;
+        const device = this.device;
         canvas.width = canvas.clientWidth * devicePixelRatio;
         canvas.height = canvas.clientHeight * devicePixelRatio;
         const presentationFormat = navigator.gpu.getPreferredCanvasFormat();
@@ -403,7 +407,7 @@ export class Simulation {
                 scene[i].traverseLife(diff);
             }
             const obj = scene[i].getObj();
-            if (obj.isCollection) {
+            if (obj instanceof SceneCollection) {
                 currentOffset += this.renderScene(device, passEncoder, vertexBuffer, obj.getScene(), currentOffset, diff);
                 continue;
             }
@@ -440,7 +444,7 @@ export class Simulation {
                 }
             }
             let instances = 1;
-            if (obj.isInstance) {
+            if (obj instanceof Instance) {
                 instances = obj.getNumInstances();
                 const buf = obj.getMatrixBuffer();
                 if (buf && this.renderInfo) {
@@ -474,7 +478,8 @@ export class Simulation {
         return currentOffset - startOffset;
     }
     fitElement() {
-        this.assertHasCanvas();
+        if (this.canvasRef === null)
+            return;
         this.fittingElement = true;
         const parent = this.canvasRef.parentElement;
         if (parent !== null) {
@@ -483,17 +488,12 @@ export class Simulation {
             this.setCanvasSize(width, height);
         }
     }
-    assertHasCanvas() {
-        if (this.canvasRef === null) {
-            throw logger.error(`cannot complete action, canvas is null`);
-        }
-    }
 }
 export class SceneCollection extends SimulationElement3d {
     geometry;
     name;
     scene;
-    isCollection = true;
+    device = null;
     constructor(name) {
         super(vector3());
         this.wireframe = false;
@@ -508,6 +508,18 @@ export class SceneCollection extends SimulationElement3d {
     getScene() {
         return this.scene;
     }
+    setDevice(device) {
+        this.device = device;
+        this.propagateDevice(device);
+    }
+    propagateDevice(device) {
+        for (let i = 0; i < this.scene.length; i++) {
+            const el = this.scene[i].getObj();
+            if (el instanceof Instance || el instanceof SceneCollection) {
+                el.setDevice(device);
+            }
+        }
+    }
     getVertexCount() {
         let total = 0;
         for (let i = 0; i < this.scene.length; i++) {
@@ -524,12 +536,15 @@ export class SceneCollection extends SimulationElement3d {
     setScene(newScene) {
         this.scene = newScene;
     }
-    add(el) {
-        addObject(this.scene, el);
+    add(el, id) {
+        addObject(this.scene, el, this.device, id);
     }
     remove(el) {
         removeObject(this.scene, el);
     }
+    removeId(id) {
+        removeObjectId(this.scene, id);
+    }
     /**
      * @param lifetime - ms
      */

package/package.json

@@ -5,7 +5,7 @@
   "types": "./dist/index.d.ts",
   "author": "Jackson Otto",
   "description": "A simple graphics library using WebGPU",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "exports": {
     ".": {
       "import": "./dist/index.js",