simulationjsv2 0.7.3 → 0.8.0

package/dist/geometry.js

@@ -1,37 +1,22 @@
 import { mat4, vec2, vec3 } from 'wgpu-matrix';
-import { cloneBuf, interpolateColors, matrix4, vector2, vector2FromVector3, vector3, vector3FromVector2, vertex } from './utils.js';
+import { cloneBuf, matrix4, vector2, vector2FromVector3, vector3, vector3FromVector2 } from './utils.js';
 import { CubicBezierCurve2d } from './graphics.js';
-import { BUF_LEN } from './constants.js';
-import { bufferGenerator, lossyTriangulate, lossyTriangulateStrip, triangulateWireFrameOrder } from './internalUtils.js';
+import { createIndexArray, lossyTriangulate, lossyTriangulateStrip, triangulateWireFrameOrder } from './internalUtils.js';
 export class Geometry {
     vertices;
-    geometryType;
+    topology;
     constructor(vertices = [], geometryType = 'list') {
         this.vertices = vertices;
-        this.geometryType = geometryType;
+        this.topology = geometryType;
     }
-    getType() {
-        return this.geometryType;
+    getTopology() {
+        return this.topology;
     }
-    getTriangleVertexCount() {
-        return this.triangleOrder.length;
+    getIndexes(wireframe) {
+        return wireframe ? this.wireframeOrder : this.triangleOrder;
     }
-    getWireframeVertexCount() {
-        return this.wireframeOrder.length;
-    }
-    bufferFromOrder(order, color, vertexParamGenerator) {
-        return order
-            .map((vertexIndex) => {
-            const pos = this.vertices[vertexIndex];
-            return bufferGenerator.generate(pos[0], pos[1], pos[2], color, vector2(), vertexParamGenerator);
-        })
-            .flat();
-    }
-    getWireframeBuffer(color, vertexParamGenerator) {
-        return this.bufferFromOrder(this.wireframeOrder, color, vertexParamGenerator);
-    }
-    getTriangleBuffer(color, vertexParamGenerator) {
-        return this.bufferFromOrder(this.triangleOrder, color, vertexParamGenerator);
+    getVertices() {
+        return this.vertices;
     }
 }
 export class PlaneGeometry extends Geometry {
@@ -40,7 +25,7 @@ export class PlaneGeometry extends Geometry {
     triangleOrder;
     rawVertices;
     constructor(vertices) {
-        super();
+        super([], 'strip');
         this.wireframeOrder = [];
         this.triangleOrder = [];
         this.rawVertices = vertices;
@@ -51,18 +36,7 @@ export class PlaneGeometry extends Geometry {
         this.rawVertices = vertices;
         this.vertices = vertices.map((vertex) => vertex.getPos());
         this.wireframeOrder = triangulateWireFrameOrder(this.vertices.length);
-        this.triangleOrder = lossyTriangulate(Array(this.rawVertices.length)
-            .fill(0)
-            .map((_, index) => index)).flat();
-    }
-    getTriangleBuffer(color, vertexParamGenerator) {
-        return this.triangleOrder
-            .map((index) => {
-            const vertex = this.rawVertices[index];
-            const pos = vertex.getPos();
-            return bufferGenerator.generate(pos[0], pos[1], pos[2], vertex.getColor() || color, vector2(), vertexParamGenerator);
-        })
-            .flat();
+        this.triangleOrder = lossyTriangulateStrip(createIndexArray(this.rawVertices.length));
     }
 }
 export class CubeGeometry extends Geometry {
@@ -70,15 +44,15 @@ export class CubeGeometry extends Geometry {
     wireframeOrder = [0, 1, 2, 3, 0, 2, 6, 5, 1, 6, 7, 4, 5, 7, 3, 4, 0, 5, 6, 3];
     // prettier-ignore
     triangleOrder = [
-        0, 1, 2, 0, 2, 3,
-        4, 5, 6, 4, 6, 7,
-        0, 3, 7, 0, 7, 4,
-        0, 4, 5, 0, 5, 1,
-        1, 2, 6, 1, 5, 6,
-        2, 3, 7, 2, 6, 7
+        0, 1, 3, 2,
+        4, 7, 5, 6,
+        0, 3, 4, 7,
+        0, 4, 1, 5,
+        1, 5, 2, 6,
+        2, 6, 3, 7
     ];
     constructor(width, height, depth) {
-        super();
+        super([], 'strip');
         this.params = {
             width,
             height,
@@ -118,27 +92,16 @@ export class CubeGeometry extends Geometry {
 }
 export class SquareGeometry extends Geometry {
     wireframeOrder = [0, 1, 2, 3, 0, 2];
-    triangleOrder = [0, 1, 3, 2];
+    triangleOrder = [0, 3, 1, 2];
     params;
-    constructor(width, height, centerOffset) {
+    constructor(width, height) {
         super([], 'strip');
         this.params = {
             width,
-            height,
-            colorMap: {},
-            centerOffset: centerOffset || vector2(0, 0)
+            height
         };
         this.recompute();
     }
-    setOffset(offset) {
-        this.params.centerOffset = offset;
-    }
-    getOffset() {
-        return this.params.centerOffset;
-    }
-    setVertexColorMap(colorMap) {
-        this.params.colorMap = colorMap;
-    }
     setWidth(width) {
         this.params.width = width;
     }
@@ -146,22 +109,13 @@ export class SquareGeometry extends Geometry {
         this.params.height = height;
     }
     recompute() {
-        const centerOffset = this.params.centerOffset;
         this.vertices = [
-            vector3(-this.params.width * centerOffset[0], this.params.height * centerOffset[1]),
-            vector3(this.params.width * (1 - centerOffset[0]), this.params.height * centerOffset[1]),
-            vector3(this.params.width * (1 - centerOffset[0]), -this.params.height * (1 - centerOffset[1])),
-            vector3(-this.params.width * centerOffset[0], -this.params.height * (1 - centerOffset[1]))
+            vector3(-this.params.width, this.params.height),
+            vector3(this.params.width, this.params.height),
+            vector3(this.params.width, -this.params.height),
+            vector3(-this.params.width, -this.params.height)
         ];
     }
-    getTriangleBuffer(color, vertexParamGenerator) {
-        return this.triangleOrder
-            .map((vertexIndex) => {
-            const pos = this.vertices[vertexIndex];
-            return bufferGenerator.generate(pos[0], pos[1], pos[2], this.params.colorMap[vertexIndex] || color, vector2(), vertexParamGenerator);
-        })
-            .flat();
-    }
 }
 export class BlankGeometry extends Geometry {
     wireframeOrder = [];
@@ -186,14 +140,6 @@ export class CircleGeometry extends Geometry {
     setRadius(radius) {
         this.params.radius = radius;
     }
-    updateWireframeOrder() {
-        this.wireframeOrder = triangulateWireFrameOrder(this.vertices.length);
-    }
-    updateTriangleOrder() {
-        this.triangleOrder = lossyTriangulate(Array(this.vertices.length)
-            .fill(0)
-            .map((_, index) => index)).flat();
-    }
     recompute() {
         const vertices = [];
         const rotationInc = (Math.PI * 2) / this.params.detail;
@@ -205,16 +151,16 @@ export class CircleGeometry extends Geometry {
             vertices.push(vector3(vec[0], vec[1], vec[2]));
         }
         this.vertices = vertices;
-        this.updateTriangleOrder();
-        this.updateWireframeOrder();
+        this.triangleOrder = lossyTriangulate(createIndexArray(this.vertices.length)).flat();
+        this.wireframeOrder = triangulateWireFrameOrder(this.vertices.length);
     }
 }
 export class Spline2dGeometry extends Geometry {
     wireframeOrder;
     triangleOrder;
     params;
-    constructor(points, color, thickness, detail) {
-        super();
+    constructor(points, thickness, detail) {
+        super([], 'strip');
         this.wireframeOrder = [];
         this.triangleOrder = [];
         this.params = {
@@ -225,8 +171,8 @@ export class Spline2dGeometry extends Geometry {
             interpolateStart: 0,
             interpolateLimit: 1,
             thickness: thickness,
-            color: color,
-            vertexColors: []
+            vertexInterpolations: [],
+            curveVertexIndices: []
         };
         this.computeCurves();
         this.recompute();
@@ -237,6 +183,15 @@ export class Spline2dGeometry extends Geometry {
     updateInterpolationLimit(limit) {
         this.params.interpolateLimit = Math.min(1, Math.max(0, limit));
     }
+    getInterpolationStart() {
+        return this.params.interpolateStart;
+    }
+    getInterpolationLimit() {
+        return this.params.interpolateLimit;
+    }
+    getDistance() {
+        return this.params.distance;
+    }
     updatePoint(pointIndex, newPoint) {
         if (pointIndex < 0 && pointIndex >= this.params.points.length)
             return;
@@ -254,18 +209,15 @@ export class Spline2dGeometry extends Geometry {
     updateThickness(thickness) {
         this.params.thickness = thickness;
     }
-    getVertexCount() {
-        return this.triangleOrder.length * BUF_LEN;
-    }
-    getWireframeVertexCount() {
-        return this.getVertexCount();
-    }
-    getTriangleVertexCount() {
-        return this.getVertexCount();
-    }
     getCurves() {
         return this.params.curves;
     }
+    getVertexInterpolations() {
+        return this.params.vertexInterpolations;
+    }
+    getCurveVertexIndices() {
+        return this.params.curveVertexIndices;
+    }
     computeCurves() {
         this.params.curves = [];
         this.params.distance = 0;
@@ -277,7 +229,7 @@ export class Spline2dGeometry extends Geometry {
                 vec2.negate(prevControl, prevControl);
                 const prevColors = this.params.points[i - 1].getColors();
                 if (prevColors.at(-1)) {
-                    prevColor = prevColors.at(-1) || null;
+                    prevColor = prevColors.at(-1) ?? null;
                 }
             }
             const bezierPoints = this.params.points[i].getVectorArray(i > 0 ? vector2FromVector3(this.params.points[i - 1].getEnd().getPos()) : null, prevControl);
@@ -286,18 +238,16 @@ export class Spline2dGeometry extends Geometry {
             this.params.curves.push(curve);
         }
     }
-    updateWireframeOrder() {
-        this.wireframeOrder = triangulateWireFrameOrder(this.vertices.length);
-    }
     recompute() {
-        this.params.vertexColors = [];
         this.vertices = [];
-        let verticesTop = [];
+        this.params.vertexInterpolations = [];
+        this.params.curveVertexIndices = [];
+        const verticesTop = [];
         const verticesBottom = [];
         let currentDistance = 0;
         let interpolationStarted = false;
         outer: for (let i = 0; i < this.params.curves.length; i++) {
-            const detail = this.params.curves[i].getDetail() || this.params.detail;
+            const detail = this.params.curves[i].getDetail() ?? this.params.detail;
             const step = 1 / detail;
             const distanceRatio = currentDistance / this.params.distance;
             if (distanceRatio > this.params.interpolateLimit)
@@ -305,6 +255,7 @@ export class Spline2dGeometry extends Geometry {
             const curveLength = this.params.curves[i].getLength();
             currentDistance += curveLength;
             const sectionRatio = curveLength / this.params.distance;
+            let curveVertexIndexSet = i === 0;
             for (let j = 0; j < detail + 1; j++) {
                 let currentInterpolation = step * j;
                 let atLimit = false;
@@ -320,79 +271,42 @@ export class Spline2dGeometry extends Geometry {
                     currentInterpolation = (this.params.interpolateStart - distanceRatio) / sectionRatio;
                     j--;
                 }
+                if (!curveVertexIndexSet) {
+                    this.params.curveVertexIndices.push(verticesTop.length);
+                    curveVertexIndexSet = true;
+                }
                 const [point2d, slope] = this.params.curves[i].interpolateSlope(currentInterpolation);
                 const point = vector3FromVector2(point2d);
                 const normal = vector2(-slope[1], slope[0]);
                 vec2.normalize(normal, normal);
                 vec2.scale(normal, this.params.thickness / 2, normal);
-                const colors = this.params.curves[i].getColors().map((c) => (c ? c : this.params.color));
-                const vertexColor = interpolateColors(colors, currentInterpolation);
-                this.params.vertexColors.push(vertexColor);
-                const vertTop = vertex(point[0] + normal[0], point[1] + normal[1], 0, vertexColor);
+                this.params.vertexInterpolations.push(currentInterpolation);
+                const vertTop = vector3(point[0] + normal[0], point[1] + normal[1]);
                 verticesTop.push(vertTop);
-                const vertBottom = vertex(point[0] - normal[0], point[1] - normal[1], 0, vertexColor);
+                const vertBottom = vector3(point[0] - normal[0], point[1] - normal[1]);
                 verticesBottom.unshift(vertBottom);
                 if (atLimit) {
                     break outer;
                 }
             }
         }
-        verticesTop = verticesTop.concat(verticesBottom);
-        const tempColors = [...this.params.vertexColors];
-        tempColors.reverse();
-        this.params.vertexColors = this.params.vertexColors.concat(tempColors);
-        this.vertices = verticesTop.map((vertex) => vertex.getPos());
-        this.triangleOrder = lossyTriangulate(Array(verticesTop.length)
-            .fill(0)
-            .map((_, index) => index)).flat();
-        this.updateWireframeOrder();
-    }
-    getWireframeBuffer(color, vertexParamGenerator) {
-        return this.wireframeOrder
-            .map((vertexIndex) => {
-            const vertex = this.vertices[vertexIndex];
-            return bufferGenerator.generate(vertex[0], vertex[1], vertex[2], color, vector2(), vertexParamGenerator);
-        })
-            .flat();
-    }
-    getTriangleBuffer(_, vertexParamGenerator) {
-        return this.triangleOrder
-            .map((vertexIndex) => {
-            const vertex = this.vertices[vertexIndex];
-            return bufferGenerator.generate(vertex[0], vertex[1], vertex[2], this.params.vertexColors[vertexIndex], vector2(), vertexParamGenerator);
-        })
-            .flat();
+        this.vertices = verticesTop.concat(verticesBottom);
+        this.triangleOrder = lossyTriangulateStrip(createIndexArray(this.vertices.length));
+        this.wireframeOrder = triangulateWireFrameOrder(this.vertices.length);
     }
 }
 export class Line2dGeometry extends Geometry {
     wireframeOrder = [0, 1, 2, 3, 0, 2];
-    triangleOrder = [0, 1, 3, 2];
+    triangleOrder = [0, 3, 1, 2];
     params;
-    constructor(pos, to, thickness, fromColor, toColor) {
+    constructor(pos, to, thickness) {
         super([], 'strip');
         this.params = {
             pos,
             to,
-            thickness,
-            fromColor: fromColor || null,
-            toColor: toColor || null
+            thickness
         };
     }
-    generateBuffer(order, color, vertexParamGenerator) {
-        return order
-            .map((vertexIndex) => {
-            const pos = this.vertices[vertexIndex];
-            const vertexColor = (vertexIndex > 1 ? this.params.toColor : this.params.fromColor) || color;
-            return bufferGenerator.generate(pos[0], pos[1], pos[2], vertexColor, vector2(), vertexParamGenerator);
-        })
-            .flat();
-    }
-    getTriangleBuffer(color, vertexParamGenerator) {
-        return this.generateBuffer(this.triangleOrder, color, vertexParamGenerator);
-    }
-    getWireframeBuffer(color, vertexParamGenerator) {
-        return this.generateBuffer(this.wireframeOrder, color, vertexParamGenerator);
-    }
     recompute() {
         const normal = vector2(-this.params.to[1], this.params.to[0]);
         vec2.normalize(normal, normal);
@@ -407,33 +321,16 @@ export class Line2dGeometry extends Geometry {
 }
 export class Line3dGeometry extends Geometry {
     wireframeOrder = [0, 1, 2, 3, 0, 2];
-    triangleOrder = [0, 1, 2, 3, 0];
+    triangleOrder = [0, 3, 1, 2];
     params;
-    constructor(pos, to, thickness, fromColor, toColor) {
+    constructor(pos, to, thickness) {
         super([], 'strip');
         this.params = {
             pos,
             to,
-            thickness,
-            fromColor: fromColor || null,
-            toColor: toColor || null
+            thickness
         };
     }
-    generateBuffer(order, color, vertexParamGenerator) {
-        return order
-            .map((vertexIndex) => {
-            const pos = this.vertices[vertexIndex];
-            const vertexColor = (vertexIndex > 1 ? this.params.toColor : this.params.fromColor) || color;
-            return bufferGenerator.generate(pos[0], pos[1], pos[2], vertexColor, vector2(), vertexParamGenerator);
-        })
-            .flat();
-    }
-    getTriangleBuffer(color, vertexParamGenerator) {
-        return this.generateBuffer(this.triangleOrder, color, vertexParamGenerator);
-    }
-    getWireframeBuffer(color, vertexParamGenerator) {
-        return this.generateBuffer(this.wireframeOrder, color, vertexParamGenerator);
-    }
     recompute() {
         const normal = vector2(-this.params.to[1], this.params.to[0]);
         vec2.normalize(normal, normal);
@@ -449,31 +346,18 @@ export class Line3dGeometry extends Geometry {
 export class PolygonGeometry extends Geometry {
     wireframeOrder;
     triangleOrder;
-    params;
-    constructor(points) {
+    params = {};
+    constructor(vertices) {
         super([], 'strip');
         this.wireframeOrder = [];
         this.triangleOrder = [];
-        this.params = {
-            points
-        };
+        this.vertices = vertices;
         this.recompute();
     }
     recompute() {
-        this.vertices = this.params.points.map((point) => point.getPos());
-        this.triangleOrder = lossyTriangulateStrip(Array(this.vertices.length)
-            .fill(0)
-            .map((_, index) => index));
+        this.triangleOrder = lossyTriangulateStrip(createIndexArray(this.vertices.length));
         this.wireframeOrder = triangulateWireFrameOrder(this.vertices.length);
     }
-    getTriangleBuffer(color) {
-        return this.triangleOrder
-            .map((vertexIndex) => {
-            const vertex = this.vertices[vertexIndex];
-            return bufferGenerator.generate(vertex[0], vertex[1], 0, this.params.points[vertexIndex].getColor() || color);
-        })
-            .flat();
-    }
 }
 export class TraceLines2dGeometry extends Geometry {
     wireframeOrder = [];
@@ -482,27 +366,24 @@ export class TraceLines2dGeometry extends Geometry {
     constructor(maxLen) {
         super([], 'strip');
         this.params = {
-            vertices: [],
-            maxLength: maxLen || null
+            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();
+    getVertexCount() {
+        return this.vertices.length;
     }
-    getWireframeVertexCount() {
-        return this.params.vertices.length;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getOrder(_) {
+        return [this.vertices, this.wireframeOrder];
     }
     addVertex(vert) {
-        this.params.vertices.push(vert);
-        if (this.params.maxLength && this.params.vertices.length > this.params.maxLength) {
-            this.params.vertices.shift();
+        this.vertices.push(vert);
+        if (this.params.maxLength && this.vertices.length > this.params.maxLength) {
+            this.vertices.shift();
+        }
+        else {
+            this.wireframeOrder.push(this.wireframeOrder.length);
         }
     }
 }

package/dist/globals.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="@webgpu/types" />
+import { Shader } from './shaders.js';
+declare class Logger {
+    constructor();
+    private fmt;
+    log(msg: string): void;
+    error(msg: string): Error;
+    warn(msg: string): void;
+    log_error(msg: string): void;
+}
+export declare const logger: Logger;
+export declare class GlobalInfo {
+    private device;
+    constructor();
+    setDevice(device: GPUDevice): void;
+    errorGetDevice(): GPUDevice;
+    getDevice(): GPUDevice | null;
+}
+export declare const globalInfo: GlobalInfo;
+export declare class PipelineCache {
+    private pipelines;
+    constructor();
+    getPipeline(device: GPUDevice, info: string, shader: Shader): GPURenderPipeline;
+}
+export declare const pipelineCache: PipelineCache;
+export {};

package/dist/globals.js

@@ -0,0 +1,51 @@
+import { createPipeline } from './internalUtils.js';
+class Logger {
+    constructor() { }
+    fmt(msg) {
+        return `SimJS: ${msg}`;
+    }
+    log(msg) {
+        console.log(this.fmt(msg));
+    }
+    error(msg) {
+        return new Error(this.fmt(msg));
+    }
+    warn(msg) {
+        console.warn(this.fmt(msg));
+    }
+    log_error(msg) {
+        console.error(this.fmt(msg));
+    }
+}
+export const logger = new Logger();
+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 class PipelineCache {
+    pipelines;
+    constructor() {
+        this.pipelines = new Map();
+    }
+    getPipeline(device, info, shader) {
+        const res = this.pipelines.get(info);
+        if (!res)
+            return createPipeline(device, info, shader);
+        return res;
+    }
+}
+export const pipelineCache = new PipelineCache();