simulationjsv2 0.6.0 → 0.7.2

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

@@ -6,6 +6,8 @@ export declare const drawingInstancesOffset = 36;
 export declare const BUF_LEN: number;
 export declare const worldProjMatOffset = 0;
 export declare const modelProjMatOffset: number;
+export declare const mat4ByteLength = 64;
 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

@@ -7,6 +7,8 @@ export const drawingInstancesOffset = 36;
 export const BUF_LEN = vertexSize / 4;
 export const worldProjMatOffset = 0;
 export const modelProjMatOffset = 4 * 16;
+export const mat4ByteLength = 64;
 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,53 +1,77 @@
 /// <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;
-    getUniformBuffer(device: GPUDevice, mat: Mat4): GPUBuffer;
+    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;
+    getModelMatrix(): Mat4;
+    getUniformBuffer(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[];
 }
-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;
 }
-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;
@@ -174,16 +198,31 @@ export declare class Instance<T extends AnySimulationElement> extends Simulation
     private obj;
     private instanceMatrix;
     private matrixBuffer;
-    private device;
     private baseMat;
+    private maxInstances;
+    isInstance: boolean;
     constructor(obj: T, numInstances: number);
     setNumInstances(numInstances: number): void;
     setInstance(instance: number, transformation: Mat4): void;
+    private allocBuffer;
     private mapBuffer;
     getInstances(): Mat4[];
     getNumInstances(): number;
-    getMatrixBuffer(device: GPUDevice): GPUBuffer;
+    getMatrixBuffer(): GPUBuffer;
     getVertexCount(): number;
     getGeometryType(): "list" | "strip";
     getBuffer(): Float32Array | number[];
+    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;
+}
+export declare class TraceLines3d extends SimulationElement3d {
+    protected geometry: TraceLinesGeometry;
+    constructor(color?: Color, maxLen?: number);
+    addPoint(point: Vector2 | Vector3, color?: Color): void;
+    isWireframe(): boolean;
 }