simulationjsv2 0.5.2 → 0.7.1

package/dist/internalUtils.d.ts

@@ -1,30 +1,29 @@
 /// <reference types="@webgpu/types" />
-import { AnySimulationElement, VertexParamGeneratorInfo, Mat4, Vector2, Vector3, VertexParamInfo } from './types.js';
+import { VertexParamGeneratorInfo, Mat4, Vector2, Vector3, VertexParamInfo } from './types.js';
 import { Color } from './utils.js';
+import { SimulationElement3d } from './graphics.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) => 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;
-export declare const removeObject: (scene: SimSceneObjInfo[], el: AnySimulationElement) => void;
 export declare const removeObjectId: (scene: SimSceneObjInfo[], id: string) => void;
 export declare class SimSceneObjInfo {
     private obj;
     private id;
     private lifetime;
     private currentLife;
-    constructor(obj: AnySimulationElement, id?: string);
+    constructor(obj: SimulationElement3d, id?: string);
     /**
      * @param lifetime - ms
      */
@@ -35,7 +34,7 @@ export declare class SimSceneObjInfo {
      * @param amount - ms
      */
     traverseLife(amount: number): void;
-    getObj(): AnySimulationElement;
+    getObj(): SimulationElement3d;
     getId(): string | null;
 }
 declare class Logger {
@@ -48,6 +47,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 +59,11 @@ 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 vectorCompAngle(a: number, b: number): number;
+export declare function angleBetween(pos1: Vector3, pos2: Vector3): Vector3;
+export declare function internalTransitionValues(onFrame: (deltaT: number, t: number, total: number) => void, adjustment: () => void, transitionLength: number, func?: (n: number) => number): Promise<void>;
+export declare function posTo2dScreen(pos: Vector3): Vector3;
 export {};

package/dist/internalUtils.js

@@ -1,14 +1,16 @@
 import { mat4, vec3 } from 'wgpu-matrix';
 import { BUF_LEN, colorOffset, drawingInstancesOffset, uvOffset, vertexSize } from './constants.js';
-import { vector2, vector3 } from './utils.js';
-import { Instance, SimulationElement } from './graphics.js';
-import { SceneCollection } from './simulation.js';
+import { cloneBuf, transitionValues, vector2, vector3 } from './utils.js';
+import { camera } from './simulation.js';
+import { settings } from './settings.js';
 export class VertexCache {
-    vertices = [];
+    vertices;
     hasUpdated = true;
-    constructor() { }
+    constructor() {
+        this.vertices = new Float32Array();
+    }
     setCache(vertices) {
-        this.vertices = vertices;
+        this.vertices = Array.isArray(vertices) ? new Float32Array(vertices) : vertices;
         this.hasUpdated = false;
     }
     getCache() {
@@ -24,25 +26,23 @@ export class VertexCache {
         return this.vertices.length / BUF_LEN;
     }
 }
-export const buildProjectionMatrix = (aspectRatio, zNear = 1, zFar = 500) => {
-    const fov = (2 * Math.PI) / 5;
-    return mat4.perspective(fov, aspectRatio, zNear, zFar);
+export const updateProjectionMatrix = (mat, aspectRatio, zNear = 1, zFar = 500) => {
+    const fov = Math.PI / 4;
+    return mat4.perspective(fov, aspectRatio, zNear, zFar, mat);
 };
-export const getTransformationMatrix = (pos, rotation, projectionMatrix) => {
-    const modelViewProjectionMatrix = mat4.create();
-    const viewMatrix = mat4.identity();
-    const camPos = vector3();
-    vec3.clone(pos, camPos);
+export const updateWorldProjectionMatrix = (worldProjMat, projMat) => {
+    mat4.identity(worldProjMat);
+    const camPos = cloneBuf(camera.getPos());
+    const rotation = camera.getRotation();
     vec3.scale(camPos, -1, camPos);
-    mat4.rotateZ(viewMatrix, rotation[2], viewMatrix);
-    mat4.rotateY(viewMatrix, rotation[1], viewMatrix);
-    mat4.rotateX(viewMatrix, rotation[0], viewMatrix);
-    mat4.translate(viewMatrix, camPos, viewMatrix);
-    mat4.multiply(projectionMatrix, viewMatrix, modelViewProjectionMatrix);
-    return modelViewProjectionMatrix;
+    mat4.rotateZ(worldProjMat, rotation[2], worldProjMat);
+    mat4.rotateY(worldProjMat, rotation[1], worldProjMat);
+    mat4.rotateX(worldProjMat, rotation[0], worldProjMat);
+    mat4.translate(worldProjMat, camPos, worldProjMat);
+    mat4.multiply(projMat, worldProjMat, worldProjMat);
 };
-export const getOrthoMatrix = (screenSize) => {
-    return mat4.ortho(0, screenSize[0], 0, screenSize[1], 0, 100);
+export const updateOrthoProjectionMatrix = (mat, screenSize) => {
+    return mat4.ortho(0, screenSize[0], 0, screenSize[1], 0, 100, mat);
 };
 export const buildDepthTexture = (device, width, height) => {
     return device.createTexture({
@@ -60,28 +60,6 @@ export const buildMultisampleTexture = (device, ctx, width, height) => {
         sampleCount: 4
     });
 };
-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);
-    }
-    else {
-        throw logger.error('Cannot add invalid SimulationElement');
-    }
-};
-export const removeObject = (scene, el) => {
-    if (!(el instanceof SimulationElement))
-        return;
-    for (let i = 0; i < scene.length; i++) {
-        if (scene[i].getObj() === el) {
-            scene.splice(i, 1);
-            break;
-        }
-    }
-};
 export const removeObjectId = (scene, id) => {
     for (let i = 0; i < scene.length; i++) {
         if (scene[i].getId() === id) {
@@ -176,6 +154,25 @@ export function lossyTriangulate(vertices) {
     }
     return res;
 }
+export function lossyTriangulateStrip(vertices) {
+    const res = [];
+    let upper = vertices.length - 1;
+    let lower = 0;
+    let onLower = true;
+    while (upper > lower) {
+        if (onLower) {
+            res.push(vertices[lower]);
+            lower++;
+        }
+        else {
+            res.push(vertices[upper]);
+            upper--;
+        }
+        onLower = !onLower;
+    }
+    res.push(vertices[upper]);
+    return res;
+}
 class BufferGenerator {
     instancing = false;
     constructor() { }
@@ -191,7 +188,7 @@ class BufferGenerator {
             }
             return buf;
         }
-        return [x, y, z, 1, ...color.toBuffer(), ...uv, this.instancing ? 1 : 0];
+        return [x, y, z, ...color.toBuffer(), ...uv, this.instancing ? 1 : 0];
     }
 }
 export const bufferGenerator = new BufferGenerator();
@@ -216,7 +213,7 @@ export function rotateMat4(mat, rotation) {
     mat4.rotateY(mat, rotation[1], mat);
     mat4.rotateX(mat, rotation[0], mat);
 }
-export function createPipeline(device, module, bindGroupLayouts, presentationFormat, entryPoint, topology, vertexParams) {
+export function createPipeline(device, module, bindGroupLayouts, presentationFormat, topology, vertexParams) {
     let params = [
         {
             // position
@@ -263,7 +260,7 @@ export function createPipeline(device, module, bindGroupLayouts, presentationFor
         }),
         vertex: {
             module,
-            entryPoint,
+            entryPoint: 'vertex_main',
             buffers: [
                 {
                     arrayStride: stride,
@@ -314,3 +311,32 @@ export function getTotalVertices(scene) {
     }
     return total;
 }
+export function vectorCompAngle(a, b) {
+    if (a === 0)
+        return 0;
+    else {
+        if (b === 0)
+            return 0;
+        else
+            return Math.atan2(a, b);
+    }
+}
+export function angleBetween(pos1, pos2) {
+    const diff = vec3.sub(pos1, pos2);
+    const angleZ = vectorCompAngle(diff[0], diff[1]);
+    const angleY = vectorCompAngle(diff[2], diff[0]);
+    const angleX = vectorCompAngle(diff[2], diff[1]);
+    return vector3(angleX, angleY, angleZ);
+}
+export function internalTransitionValues(onFrame, adjustment, transitionLength, func) {
+    const newAdjustment = () => {
+        if (settings.transformAdjustments)
+            adjustment();
+    };
+    return transitionValues(onFrame, newAdjustment, transitionLength, func);
+}
+export function posTo2dScreen(pos) {
+    const newPos = cloneBuf(pos);
+    newPos[1] = camera.getScreenSize()[1] + newPos[1];
+    return newPos;
+}

package/dist/settings.d.ts

@@ -0,0 +1,7 @@
+export declare const settings: {
+    transformAdjustments: boolean;
+};
+export declare class Settings {
+    constructor();
+    setTransformAdjustments(value: boolean): void;
+}

package/dist/settings.js

@@ -0,0 +1,9 @@
+export const settings = {
+    transformAdjustments: true
+};
+export class Settings {
+    constructor() { }
+    setTransformAdjustments(value) {
+        settings.transformAdjustments = value;
+    }
+}

package/dist/simulation.d.ts

@@ -1,10 +1,30 @@
 /// <reference types="@webgpu/types" />
-import { SimulationElement3d } from './graphics.js';
+import { EmptyElement, SimulationElement3d } from './graphics.js';
 import type { Vector2, Vector3, LerpFunc, AnySimulationElement, VertexParamGeneratorInfo, VertexParamInfo, BindGroupInfo } from './types.js';
 import { Color } from './utils.js';
-import { BlankGeometry } from './geometry.js';
 import { SimSceneObjInfo } from './internalUtils.js';
-export declare class Simulation {
+import { Settings } from './settings.js';
+export declare class Camera {
+    private pos;
+    private rotation;
+    private aspectRatio;
+    private updated;
+    private screenSize;
+    constructor(pos: Vector3, rotation?: Vector3);
+    setScreenSize(size: Vector2): void;
+    getScreenSize(): Vector2;
+    hasUpdated(): boolean;
+    updateConsumed(): void;
+    move(amount: Vector3, t?: number, f?: LerpFunc): Promise<void>;
+    moveTo(pos: Vector3, t?: number, f?: LerpFunc): Promise<void>;
+    rotateTo(value: Vector3, t?: number, f?: LerpFunc): Promise<void>;
+    rotate(amount: Vector3, t?: number, f?: LerpFunc): Promise<void>;
+    getRotation(): Vector3;
+    getPos(): Vector3;
+    getAspectRatio(): number;
+}
+export declare let camera: Camera;
+export declare class Simulation extends Settings {
     canvasRef: HTMLCanvasElement | null;
     private bgColor;
     private scene;
@@ -12,18 +32,17 @@ export declare class Simulation {
     private running;
     private initialized;
     private frameRateView;
-    private camera;
     private device;
     private pipelines;
     private renderInfo;
     private resizeEvents;
-    constructor(idOrCanvasRef: string | HTMLCanvasElement, camera?: Camera | null, showFrameRate?: boolean);
+    constructor(idOrCanvasRef: string | HTMLCanvasElement, sceneCamera?: Camera | null, showFrameRate?: boolean);
     private handleCanvasResize;
     onResize(cb: (width: number, height: number) => void): void;
     getWidth(): number;
     getHeight(): number;
     add(el: AnySimulationElement, id?: string): void;
-    remove(el: AnySimulationElement): void;
+    remove(el: SimulationElement3d): void;
     removeId(id: string): void;
     /**
      * @param lifetime - ms
@@ -36,60 +55,12 @@ export declare class Simulation {
     stop(): void;
     setBackground(color: Color): void;
     getScene(): SimSceneObjInfo[];
-    getSceneObjects(): AnySimulationElement[];
+    getSceneObjects(): SimulationElement3d[];
     private render;
     private renderScene;
     fitElement(): void;
 }
-export declare class SceneCollection extends SimulationElement3d {
-    protected geometry: BlankGeometry;
-    private name;
-    private scene;
-    protected device: GPUDevice | null;
-    constructor(name?: string);
-    setWireframe(_: boolean): void;
-    getName(): string | null;
-    getScene(): SimSceneObjInfo[];
-    setDevice(device: GPUDevice): void;
-    protected propagateDevice(device: GPUDevice): void;
-    getVertexCount(): number;
-    getSceneObjects(): AnySimulationElement[];
-    setSceneObjects(newScene: AnySimulationElement[]): void;
-    setScene(newScene: SimSceneObjInfo[]): void;
-    add(el: AnySimulationElement, id?: string): void;
-    remove(el: AnySimulationElement): void;
-    removeId(id: string): void;
-    /**
-     * @param lifetime - ms
-     */
-    setLifetime(el: AnySimulationElement, lifetime: number): void;
-    empty(): void;
-    getSceneBuffer(camera: Camera): number[];
-    getWireframe(camera: Camera): number[];
-    getTriangles(camera: Camera): number[];
-    protected updateMatrix(camera: Camera): void;
-}
-export declare class Camera {
-    private pos;
-    private rotation;
-    private aspectRatio;
-    private updated;
-    private screenSize;
-    constructor(pos: Vector3, rotation?: Vector3);
-    setScreenSize(size: Vector2): void;
-    getScreenSize(): Vector2;
-    hasUpdated(): boolean;
-    updateConsumed(): void;
-    move(amount: Vector3, t?: number, f?: LerpFunc): Promise<void>;
-    moveTo(pos: Vector3, t?: number, f?: LerpFunc): Promise<void>;
-    rotateTo(value: Vector3, t?: number, f?: LerpFunc): Promise<void>;
-    rotate(amount: Vector3, t?: number, f?: LerpFunc): Promise<void>;
-    getRotation(): Vector3;
-    getPos(): Vector3;
-    getAspectRatio(): number;
-}
-export declare class ShaderGroup extends SceneCollection {
-    protected geometry: BlankGeometry;
+export declare class ShaderGroup extends EmptyElement {
     private code;
     private module;
     private pipeline;
@@ -100,12 +71,11 @@ export declare class ShaderGroup extends SceneCollection {
     private bindGroup;
     private valueBuffers;
     constructor(shaderCode: string, topology: GPUPrimitiveTopology | undefined, vertexParams: VertexParamInfo[], paramGenerator: VertexParamGeneratorInfo, bindGroup?: BindGroupInfo);
-    protected propagateDevice(device: GPUDevice): void;
+    protected onDeviceChange(device: GPUDevice): void;
     getBindGroupLayout(): GPUBindGroupLayout | null;
     getPipeline(): GPURenderPipeline | null;
-    getBindGroupBuffers(): GPUBuffer[] | null;
+    getBindGroupBuffers(device: GPUDevice): GPUBuffer[] | null;
     private createBuffer;
-    protected updateMatrix(camera: Camera): void;
     getVertexParamGenerator(): VertexParamGeneratorInfo;
     hasBindGroup(): boolean;
 }