simulationjsv2 0.3.1 → 0.3.3

package/dist/geometry.d.ts

@@ -74,6 +74,7 @@ export declare class Spline2dGeometry extends Geometry {
     constructor(points: SplinePoint2d[], color: Color, thickness: number, detail: number);
     updateInterpolationStart(start: number): void;
     updateInterpolationLimit(limit: number): void;
+    updatePoint(pointIndex: number, newPoint: SplinePoint2d): void;
     updateThickness(thickness: number): void;
     private getVertexCount;
     getWireframeVertexCount(): number;

package/dist/geometry.js

@@ -239,6 +239,20 @@ export class Spline2dGeometry extends Geometry {
     updateInterpolationLimit(limit) {
         this.params.interpolateLimit = Math.min(1, Math.max(0, limit));
     }
+    updatePoint(pointIndex, newPoint) {
+        if (pointIndex < 0 && pointIndex >= this.params.points.length)
+            return;
+        const start = newPoint.getStart();
+        const end = newPoint.getEnd();
+        const [startControl, endControl] = newPoint.getControls();
+        const rawControls = newPoint.getRawControls();
+        vec3.add(end.getPos(), rawControls[1], endControl);
+        if (start && startControl) {
+            vec3.add(start.getPos(), rawControls[0], startControl);
+        }
+        this.params.points[pointIndex] = newPoint;
+        this.computeCurves();
+    }
     updateThickness(thickness) {
         this.params.thickness = thickness;
     }
@@ -255,6 +269,8 @@ export class Spline2dGeometry extends Geometry {
         return this.params.curves;
     }
     computeCurves() {
+        this.params.curves = [];
+        this.params.distance = 0;
         for (let i = 0; i < this.params.points.length; i++) {
             let prevControl = null;
             let prevColor = null;

package/dist/graphics.d.ts

@@ -156,6 +156,7 @@ export declare class SplinePoint2d {
     getDetail(): number | undefined;
     getColors(prevColor?: Color | null): (Color | null)[];
     getVectorArray(prevEnd: Vector2 | null, prevControl: Vector2 | null): readonly [Vector2, Vector2, Vector2, Vector2];
+    clone(): SplinePoint2d;
 }
 export declare class Spline2d extends SimulationElement2d {
     protected geometry: Spline2dGeometry;
@@ -169,8 +170,10 @@ export declare class Spline2d extends SimulationElement2d {
     getLength(): number;
     setInterpolateStart(start: number, t?: number, f?: LerpFunc): Promise<void>;
     setInterpolateLimit(limit: number, t?: number, f?: LerpFunc): Promise<void>;
+    updatePoint(pointIndex: number, newPoint: SplinePoint2d): void;
+    updatePointAbsolute(pointIndex: number, newPoint: SplinePoint2d): void;
     setThickness(thickness: number, t?: number, f?: LerpFunc): Promise<void>;
-    interpolateSlope(t: number): readonly [Vector2, Vector2];
+    interpolateSlope(t: number): Vector2[] | readonly [Vector2, Vector2];
     interpolate(t: number): Vector2;
     protected updateMatrix(camera: Camera): void;
 }

package/dist/graphics.js

@@ -773,6 +773,9 @@ export class SplinePoint2d {
             vector2FromVector3(this.end.getPos())
         ];
     }
+    clone() {
+        return new SplinePoint2d(this.start, this.end, this.control1, this.control2, this.rawControls, this.detail);
+    }
 }
 export class Spline2d extends SimulationElement2d {
     geometry;
@@ -794,6 +797,7 @@ export class Spline2d extends SimulationElement2d {
         this.estimateLength();
     }
     estimateLength() {
+        this.length = 0;
         const curves = this.geometry.getCurves();
         for (let i = 0; i < curves.length; i++) {
             this.length += curves[i].getLength();
@@ -826,6 +830,22 @@ export class Spline2d extends SimulationElement2d {
             this.vertexCache.updated();
         }, t, f);
     }
+    updatePoint(pointIndex, newPoint) {
+        this.geometry.updatePoint(pointIndex, newPoint);
+        this.estimateLength();
+        this.vertexCache.updated();
+    }
+    updatePointAbsolute(pointIndex, newPoint) {
+        const clonePoint = newPoint.clone();
+        const start = clonePoint.getStart()?.getPos() || vector3();
+        const end = clonePoint.getEnd().getPos();
+        const pos = vector3FromVector2(this.getPos());
+        vec3.sub(start, pos, start);
+        vec3.sub(end, pos, end);
+        this.geometry.updatePoint(pointIndex, clonePoint);
+        this.estimateLength();
+        this.vertexCache.updated();
+    }
     setThickness(thickness, t = 0, f) {
         thickness *= devicePixelRatio;
         const diff = thickness - this.thickness;
@@ -855,6 +875,8 @@ export class Spline2d extends SimulationElement2d {
             }
             currentLength += curves[i].getLength();
         }
+        if (curves.length === 0)
+            return [vector2(), vector2()];
         return curves[index].interpolateSlope(diff);
     }
     interpolate(t) {
@@ -896,8 +918,10 @@ export class Instance extends SimulationElement3d {
     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: this.instanceMatrix[0].length * 4 * this.instanceMatrix.length,
+            size,
             usage: GPUBufferUsage.STORAGE,
             mappedAtCreation: true
         });

package/dist/simulation.d.ts

@@ -34,6 +34,7 @@ export declare class SceneCollection extends SimulationElement3d {
     setWireframe(_: boolean): void;
     getName(): string;
     getScene(): SimulationElement<Vector3>[];
+    setScene(newScene: SimulationElement<any>[]): void;
     add(el: SimulationElement<any>): void;
     empty(): void;
     getSceneBuffer(camera: Camera): number[];

package/dist/simulation.js

@@ -214,7 +214,7 @@ export class Simulation {
             usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
         });
         const instanceBuffer = device.createBuffer({
-            size: 16 * 10 * 4,
+            size: 10 * 4 * 16,
             usage: GPUBufferUsage.STORAGE
         });
         const bindGroupLayout = device.createBindGroupLayout({
@@ -457,6 +457,9 @@ export class SceneCollection extends SimulationElement3d {
     getScene() {
         return this.scene;
     }
+    setScene(newScene) {
+        this.scene = newScene;
+    }
     add(el) {
         applyElementToScene(this.scene, el);
     }

package/package.json

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