simulationjsv2 0.6.0 → 0.7.1

package/TODO.md

@@ -1,13 +1,17 @@
 # TODO
 
-- [ ] Add animation status handle to transition values
+- [ ] Fix transparency
+- [x] Update `updateModelMatrix2d`
+- [x] Trace line element (wireframe strip for tracing paths)
+- [x] Test new transform things on 3d stuff
+- [x] Fix rotating nested children elements
+- [x] Fix instancing
+- [x] Remove SceneCollection and replace by elements with children
+  - Test this
 - [x] Change position/rotation to be matrix transform on gpu
 - [x] Add update square center offset position in-place + not
 - [x] Make getBuffer return cached Float32Array
 - [x] Make input buffer position vec3 not vec4
 - [x] Use line strip vertices for polygon buffers
 - [x] Scene collection wireframe
-
-## Not Yet
-
-- [ ] Add rotateAround and rotateToAround methods to simulation element for absolute positioned vectors
+- [ ] Add animation status handle to transition values

package/dist/constants.d.ts

@@ -9,3 +9,4 @@ export declare const modelProjMatOffset: number;
 export declare const xAxis: import("./types.js").Vector3;
 export declare const yAxis: import("./types.js").Vector3;
 export declare const zAxis: import("./types.js").Vector3;
+export declare const origin0: import("./types.js").Vector3;

package/dist/constants.js

@@ -10,3 +10,4 @@ export const modelProjMatOffset = 4 * 16;
 export const xAxis = vector3(1);
 export const yAxis = vector3(0, 1);
 export const zAxis = vector3(0, 0, 1);
+export const origin0 = vector3();

package/dist/geometry.d.ts

@@ -1,4 +1,4 @@
-import { VertexParamGeneratorInfo, CircleGeometryParams, CubeGeometryParams, EmptyParams, PolygonGeometryParams, Spline2dGeometryParams, SquareGeometryParams, Vector2, Vector3, VertexColorMap, LineGeometryParams } from './types.js';
+import { VertexParamGeneratorInfo, CircleGeometryParams, CubeGeometryParams, EmptyParams, PolygonGeometryParams, Spline2dGeometryParams, SquareGeometryParams, Vector2, Vector3, VertexColorMap, LineGeometryParams, TraceLinesParams } from './types.js';
 import { Color, Vertex } from './utils.js';
 import { CubicBezierCurve2d, SplinePoint2d } from './graphics.js';
 export declare abstract class Geometry<T extends EmptyParams> {
@@ -114,3 +114,13 @@ export declare class PolygonGeometry extends Geometry<PolygonGeometryParams> {
     recompute(): void;
     getTriangleBuffer(color: Color): number[];
 }
+export declare class TraceLines2dGeometry extends Geometry<EmptyParams> {
+    protected wireframeOrder: never[];
+    protected triangleOrder: never[];
+    protected params: TraceLinesParams;
+    constructor(maxLen?: number);
+    recompute(): void;
+    getWireframeBuffer(color: Color, vertexParamGenerator?: VertexParamGeneratorInfo | undefined): number[];
+    getWireframeVertexCount(): number;
+    addVertex(vert: Vertex): void;
+}

package/dist/geometry.js

@@ -475,3 +475,34 @@ export class PolygonGeometry extends Geometry {
             .flat();
     }
 }
+export class TraceLines2dGeometry extends Geometry {
+    wireframeOrder = [];
+    triangleOrder = [];
+    params;
+    constructor(maxLen) {
+        super([], 'strip');
+        this.params = {
+            vertices: [],
+            maxLength: maxLen || null
+        };
+        this.wireframeOrder = [];
+    }
+    recompute() { }
+    getWireframeBuffer(color, vertexParamGenerator) {
+        return this.params.vertices
+            .map((item) => {
+            const pos = item.getPos();
+            return bufferGenerator.generate(pos[0], pos[1], pos[2], item.getColor() || color, vector2(), vertexParamGenerator);
+        })
+            .flat();
+    }
+    getWireframeVertexCount() {
+        return this.params.vertices.length;
+    }
+    addVertex(vert) {
+        this.params.vertices.push(vert);
+        if (this.params.maxLength && this.params.vertices.length > this.params.maxLength) {
+            this.params.vertices.shift();
+        }
+    }
+}

package/dist/graphics.d.ts

@@ -1,59 +1,87 @@
 /// <reference types="@webgpu/types" />
-import { Camera } from './simulation.js';
 import type { Vector2, Vector3, LerpFunc, VertexColorMap, Mat4, AnySimulationElement, VertexParamGeneratorInfo } from './types.js';
 import { Vertex, Color } from './utils.js';
-import { BlankGeometry, CircleGeometry, CubeGeometry, Geometry, Line2dGeometry, Line3dGeometry, PlaneGeometry, PolygonGeometry, Spline2dGeometry, SquareGeometry } from './geometry.js';
-import { VertexCache } from './internalUtils.js';
-export declare abstract class SimulationElement {
+import { BlankGeometry, CircleGeometry, CubeGeometry, Geometry, Line2dGeometry, Line3dGeometry, PlaneGeometry, PolygonGeometry, Spline2dGeometry, SquareGeometry, TraceLines2dGeometry as TraceLinesGeometry } from './geometry.js';
+import { SimSceneObjInfo, VertexCache } from './internalUtils.js';
+export declare abstract class SimulationElement3d {
+    private children;
+    private uniformBuffer;
+    protected parent: SimulationElement3d | null;
+    protected centerOffset: Vector3;
+    protected rotationOffset: Vector3;
     protected pos: Vector3;
-    protected abstract geometry: Geometry<any>;
+    protected abstract geometry: Geometry<object>;
     protected color: Color;
     protected wireframe: boolean;
     protected vertexCache: VertexCache;
     protected rotation: Vector3;
     protected modelMatrix: Mat4;
-    private uniformBuffer;
+    isInstance: boolean;
     isInstanced: boolean;
+    is3d: boolean;
+    isEmpty: boolean;
     /**
      * @param pos - Expected to be adjusted to devicePixelRatio before reaching constructor
      */
     constructor(pos: Vector3, rotation: Vector3, color?: Color);
-    getModelMatrix(_: Camera): Mat4;
+    add(el: SimulationElement3d, id?: string): void;
+    remove(el: SimulationElement3d): void;
+    getChildren(): SimulationElement3d[];
+    getChildrenInfos(): SimSceneObjInfo[];
+    hasChildren(): boolean;
+    setParent(parent: SimulationElement3d): void;
+    getParent(): SimulationElement3d | null;
+    setCenterOffset(offset: Vector3): void;
+    setRotationOffset(offset: Vector3): void;
+    resetCenterOffset(): void;
+    propagateDevice(device: GPUDevice): void;
+    getModelMatrix(): Mat4;
     getUniformBuffer(device: GPUDevice, mat: Mat4): GPUBuffer;
+    protected mirrorParentTransforms3d(mat: Mat4): void;
     protected updateModelMatrix3d(): void;
+    protected mirrorParentTransforms2d(mat: Mat4): void;
+    protected updateModelMatrix2d(): void;
     getGeometryType(): "list" | "strip";
     setWireframe(wireframe: boolean): void;
     isWireframe(): boolean;
     getColor(): Color;
     getPos(): Vector3;
+    getAbsolutePos(): Vector3;
     getRotation(): Vector3;
+    getCenterOffset(): Vector3;
     fill(newColor: Color, t?: number, f?: LerpFunc): Promise<void>;
-    move(amount: Vector3, t?: number, f?: LerpFunc): Promise<void>;
-    moveTo(pos: Vector3, t?: number, f?: LerpFunc): Promise<void>;
+    private moveChildren;
+    move(amount: Vector3, t?: number, f?: LerpFunc, fromDevicePixelRatio?: boolean): Promise<void>;
+    moveTo(pos: Vector3, t?: number, f?: LerpFunc, fromDevicePixelRatio?: boolean): Promise<void>;
+    rotateChildrenTo(angle: Vector3): void;
+    rotateChildren(angle: Vector3): void;
     rotate(amount: Vector3, t?: number, f?: LerpFunc): Promise<void>;
     rotateTo(rot: Vector3, t?: number, f?: LerpFunc): Promise<void>;
     getVertexCount(): number;
-    protected defaultUpdateMatrix(_: Camera): void;
     getBuffer(vertexParamGenerator?: VertexParamGeneratorInfo): Float32Array | number[];
+    protected abstract onDeviceChange(device: GPUDevice): void;
 }
-export declare abstract class SimulationElement3d extends SimulationElement {
-    protected pos: Vector3;
-    protected rotation: Vector3;
-    is3d: boolean;
-    constructor(pos: Vector3, rotation?: Vector3, color?: Color);
+export declare class EmptyElement extends SimulationElement3d {
+    protected geometry: BlankGeometry;
+    private label;
+    isEmpty: boolean;
+    constructor(label?: string);
+    getLabel(): string | null;
+    protected onDeviceChange(_device: GPUDevice): void;
 }
-export declare abstract class SimulationElement2d extends SimulationElement {
+export declare abstract class SimulationElement2d extends SimulationElement3d {
+    is3d: boolean;
     constructor(pos: Vector2, rotation?: Vector3, color?: Color);
     rotate2d(amount: number, t?: number, f?: LerpFunc): Promise<void>;
     rotateTo2d(rot: number, t?: number, f?: LerpFunc): Promise<void>;
-    private updateModelMatrix2d;
-    getModelMatrix(camera: Camera): Mat4;
+    getModelMatrix(): Mat4;
 }
 export declare class Plane extends SimulationElement3d {
     protected geometry: PlaneGeometry;
     points: Vertex[];
     constructor(pos: Vector3, points: Vertex[], color?: Color, rotation?: Vector3);
     setPoints(newPoints: Vertex[]): void;
+    protected onDeviceChange(_device: GPUDevice): void;
 }
 export declare class Square extends SimulationElement2d {
     protected geometry: SquareGeometry;
@@ -74,6 +102,7 @@ export declare class Square extends SimulationElement2d {
     scale(amount: number, t?: number, f?: LerpFunc): Promise<void>;
     setWidth(num: number, t?: number, f?: LerpFunc): Promise<void>;
     setHeight(num: number, t?: number, f?: LerpFunc): Promise<void>;
+    protected onDeviceChange(_device: GPUDevice): void;
 }
 export declare class Circle extends SimulationElement2d {
     protected geometry: CircleGeometry;
@@ -82,6 +111,7 @@ export declare class Circle extends SimulationElement2d {
     constructor(pos: Vector2, radius: number, color?: Color, detail?: number);
     setRadius(num: number, t?: number, f?: LerpFunc): Promise<void>;
     scale(amount: number, t?: number, f?: LerpFunc): Promise<void>;
+    protected onDeviceChange(_device: GPUDevice): void;
 }
 export declare class Polygon extends SimulationElement2d {
     protected geometry: PolygonGeometry;
@@ -89,6 +119,7 @@ export declare class Polygon extends SimulationElement2d {
     constructor(pos: Vector2, points: Vertex[], color?: Color, rotation?: number);
     getVertices(): Vertex[];
     setVertices(newVertices: Vertex[], t?: number, f?: LerpFunc): Promise<void>;
+    protected onDeviceChange(_device: GPUDevice): void;
 }
 export declare class Line3d extends SimulationElement3d {
     protected geometry: Line3dGeometry;
@@ -97,6 +128,7 @@ export declare class Line3d extends SimulationElement3d {
     constructor(pos: Vertex, to: Vertex, thickness: number);
     setStart(pos: Vector3, t?: number, f?: LerpFunc): Promise<void>;
     setEnd(pos: Vector3, t?: number, f?: LerpFunc): Promise<void>;
+    protected onDeviceChange(_device: GPUDevice): void;
 }
 export declare class Line2d extends SimulationElement2d {
     protected geometry: Line2dGeometry;
@@ -105,6 +137,7 @@ export declare class Line2d extends SimulationElement2d {
     constructor(from: Vertex, to: Vertex, thickness?: number);
     setStart(pos: Vector3, t?: number, f?: LerpFunc): Promise<void>;
     setEnd(pos: Vector3, t?: number, f?: LerpFunc): Promise<void>;
+    protected onDeviceChange(_device: GPUDevice): void;
 }
 export declare class Cube extends SimulationElement3d {
     protected geometry: CubeGeometry;
@@ -116,6 +149,7 @@ export declare class Cube extends SimulationElement3d {
     setHeight(height: number, t?: number, f?: LerpFunc): Promise<void>;
     setDepth(depth: number, t?: number, f?: LerpFunc): Promise<void>;
     scale(amount: number, t?: number, f?: LerpFunc): Promise<void>;
+    protected onDeviceChange(_device: GPUDevice): void;
 }
 export declare class BezierCurve2d {
     private points;
@@ -168,14 +202,15 @@ export declare class Spline2d extends SimulationElement2d {
     setThickness(thickness: number, t?: number, f?: LerpFunc): Promise<void>;
     interpolateSlope(t: number): Vector2[] | readonly [Vector2, Vector2];
     interpolate(t: number): Vector2;
+    protected onDeviceChange(_device: GPUDevice): void;
 }
 export declare class Instance<T extends AnySimulationElement> extends SimulationElement3d {
     protected geometry: BlankGeometry;
     private obj;
     private instanceMatrix;
     private matrixBuffer;
-    private device;
     private baseMat;
+    isInstance: boolean;
     constructor(obj: T, numInstances: number);
     setNumInstances(numInstances: number): void;
     setInstance(instance: number, transformation: Mat4): void;
@@ -186,4 +221,20 @@ export declare class Instance<T extends AnySimulationElement> extends Simulation
     getVertexCount(): number;
     getGeometryType(): "list" | "strip";
     getBuffer(): Float32Array | number[];
+    protected onDeviceChange(device: GPUDevice): void;
+    getModelMatrix(): Mat4;
+}
+export declare class TraceLines2d extends SimulationElement2d {
+    protected geometry: TraceLinesGeometry;
+    constructor(color?: Color, maxLen?: number);
+    addPoint(point: Vector2 | Vector3, color?: Color): void;
+    isWireframe(): boolean;
+    protected onDeviceChange(_: GPUDevice): void;
+}
+export declare class TraceLines3d extends SimulationElement3d {
+    protected geometry: TraceLinesGeometry;
+    constructor(color?: Color, maxLen?: number);
+    addPoint(point: Vector2 | Vector3, color?: Color): void;
+    isWireframe(): boolean;
+    protected onDeviceChange(_: GPUDevice): void;
 }