simulationjsv2 0.6.0 → 0.7.2

package/dist/internalUtils.d.ts

@@ -1,7 +1,7 @@
 /// <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 { Camera } from './simulation.js';
+import { SimulationElement3d } from './graphics.js';
 export declare class VertexCache {
     private vertices;
     private hasUpdated;
@@ -12,20 +12,26 @@ export declare class VertexCache {
     shouldUpdate(): boolean;
     getVertexCount(): number;
 }
+export declare class GlobalInfo {
+    private device;
+    constructor();
+    setDevice(device: GPUDevice): void;
+    errorGetDevice(): GPUDevice;
+    getDevice(): GPUDevice | null;
+}
+export declare const globalInfo: GlobalInfo;
 export declare const updateProjectionMatrix: (mat: Mat4, aspectRatio: number, zNear?: number, zFar?: number) => any;
-export declare const updateWorldProjectionMatrix: (worldProjMat: Mat4, projMat: Mat4, camera: Camera) => void;
+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
      */
@@ -36,7 +42,7 @@ export declare class SimSceneObjInfo {
      * @param amount - ms
      */
     traverseLife(amount: number): void;
-    getObj(): AnySimulationElement;
+    getObj(): SimulationElement3d;
     getId(): string | null;
 }
 declare class Logger {
@@ -59,10 +65,11 @@ declare class BufferGenerator {
 export declare const bufferGenerator: BufferGenerator;
 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, topology: GPUPrimitiveTopology, vertexParams?: VertexParamInfo[]): GPURenderPipeline;
 export declare function triangulateWireFrameOrder(len: number): number[];
 export declare function getTotalVertices(scene: SimSceneObjInfo[]): number;
-export declare function wrapVoidPromise(promise: Promise<unknown>): Promise<void>;
+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,8 +1,8 @@
 import { mat4, vec3 } from 'wgpu-matrix';
 import { BUF_LEN, colorOffset, drawingInstancesOffset, uvOffset, vertexSize } from './constants.js';
-import { cloneBuf, vector2 } from './utils.js';
-import { 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;
     hasUpdated = true;
@@ -26,11 +26,29 @@ export class VertexCache {
         return this.vertices.length / BUF_LEN;
     }
 }
+export class GlobalInfo {
+    device;
+    constructor() {
+        this.device = null;
+    }
+    setDevice(device) {
+        this.device = device;
+    }
+    errorGetDevice() {
+        if (!this.device)
+            throw logger.error('GPUDevice is null');
+        return this.device;
+    }
+    getDevice() {
+        return this.device;
+    }
+}
+export const globalInfo = new GlobalInfo();
 export const updateProjectionMatrix = (mat, aspectRatio, zNear = 1, zFar = 500) => {
-    const fov = (2 * Math.PI) / 5;
+    const fov = Math.PI / 4;
     return mat4.perspective(fov, aspectRatio, zNear, zFar, mat);
 };
-export const updateWorldProjectionMatrix = (worldProjMat, projMat, camera) => {
+export const updateWorldProjectionMatrix = (worldProjMat, projMat) => {
     mat4.identity(worldProjMat);
     const camPos = cloneBuf(camera.getPos());
     const rotation = camera.getRotation();
@@ -60,28 +78,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 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) {
@@ -223,18 +219,6 @@ export function vector2ToPixelRatio(vec) {
     vec[0] *= devicePixelRatio;
     vec[1] *= devicePixelRatio;
 }
-export function matrixFromRotation(rotation) {
-    const rotMatrix = mat4.identity();
-    mat4.rotateZ(rotMatrix, rotation[2], rotMatrix);
-    mat4.rotateY(rotMatrix, rotation[1], rotMatrix);
-    mat4.rotateX(rotMatrix, rotation[0], rotMatrix);
-    return rotMatrix;
-}
-export function rotateMat4(mat, rotation) {
-    mat4.rotateZ(mat, rotation[2], mat);
-    mat4.rotateY(mat, rotation[1], mat);
-    mat4.rotateX(mat, rotation[0], mat);
-}
 export function createPipeline(device, module, bindGroupLayouts, presentationFormat, topology, vertexParams) {
     let params = [
         {
@@ -333,21 +317,32 @@ export function getTotalVertices(scene) {
     }
     return total;
 }
-export function wrapVoidPromise(promise) {
-    return new Promise((resolve) => {
-        promise.then(() => resolve());
-    });
+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;
 }
-// export function vec3FromQuat(vec: Vector3, quat: Quat, matrix: Mat4) {
-//   const mat = matrix || matrix4();
-//   const threshold = 0.9999999;
-//   mat4.fromQuat(quat, mat);
-//   vec[1] = clamp(mat[8], -1, 1);
-//   if (Math.abs(mat[8]) < threshold) {
-//     vec[0] = Math.atan2(-mat[9], mat[10]);
-//     vec[2] = Math.atan2(-mat[4], mat[0]);
-//   } else {
-//     vec[0] = Math.atan2(-mat[6], mat[5]);
-//     vec[2] = 0;
-//   }
-// }

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,29 +1,47 @@
 /// <reference types="@webgpu/types" />
-import { SimulationElement3d } from './graphics.js';
-import type { Vector2, Vector3, LerpFunc, AnySimulationElement, VertexParamGeneratorInfo, VertexParamInfo, BindGroupInfo, ElementRotation } from './types.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;
     private fittingElement;
     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);
+    private frameRateView;
+    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
@@ -32,64 +50,15 @@ export declare class Simulation {
     private applyCanvasSize;
     setCanvasSize(width: number, height: number): void;
     start(): void;
-    private propagateDevice;
     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;
-    protected scene: SimSceneObjInfo[];
-    protected device: GPUDevice | null;
-    constructor(name?: string);
-    setWireframe(wireframe: 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(): (number | Float32Array)[];
-    getWireframe(): (number | Float32Array)[];
-    getTriangles(): (number | Float32Array)[];
-    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,21 +69,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;
+    private initPipeline;
     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;
 }
-export declare class Group extends SceneCollection {
-    constructor(name?: string);
-    move(amount: Vector2 | Vector3, t?: number, f?: LerpFunc): Promise<void>;
-    moveTo(pos: Vector2 | Vector3, t?: number, f?: LerpFunc): Promise<void>;
-    rotate(amount: ElementRotation<Vector2 | Vector3>, t?: number, f?: LerpFunc): Promise<void>;
-    rotateTo(rotation: ElementRotation<Vector2 | Vector3>, t?: number, f?: LerpFunc): Promise<void>;
-    fill(newColor: Color, t?: number, f?: LerpFunc | undefined): Promise<void>;
-    private loopElements;
-}