simulationjsv2 0.7.3 → 0.8.0

package/README.md

@@ -2,8 +2,6 @@
 
 SimulationJS is a graphics library with simple easy to use APIs. Version 2 hopes to improve 3d graphics and boost performance by using webgpu under the hood.
 
-The APIs for v2 will differ however semantically, using them should be nearly identical.
-
-**Documentation eventually**
+**Documentation at 1.0.0**
 
 By _Jackson Otto_

package/TODO.md

@@ -1,19 +1,20 @@
 # TODO
 
-- [ ] Make materials
-  - [ ] Move shader group to material
-- [ ] Fix transparency
+- [ ] Change render vertices to use index buffer
+- [ ] Add cull modes
+- [x] Fix shaders
+- [x] Clean up polygons
+- [x] Fix transparency
+- [x] Change absolute pos function to pos function, and pos function to relative pos
 - [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
-- [ ] Add animation status handle to transition values

package/dist/buffers.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="@webgpu/types" />
+import { ArrayTypes } from './types.js';
+export declare class MemoBuffer {
+    private buffer;
+    private bufferSize;
+    private usage;
+    constructor(usage: GPUBufferDescriptor['usage'], size: number);
+    private allocBuffer;
+    getBuffer(): GPUBuffer;
+    setSize(size: number): void;
+    write(buf: ArrayTypes, offset?: number): void;
+    destroy(): void;
+}

package/dist/buffers.js

@@ -0,0 +1,44 @@
+import { globalInfo } from './globals.js';
+export class MemoBuffer {
+    buffer;
+    bufferSize;
+    usage;
+    constructor(usage, size) {
+        this.usage = usage;
+        this.bufferSize = size;
+        this.buffer = null;
+    }
+    allocBuffer() {
+        const device = globalInfo.getDevice();
+        if (!device)
+            return;
+        this.buffer = device.createBuffer({
+            size: this.bufferSize,
+            usage: this.usage
+        });
+    }
+    getBuffer() {
+        if (!this.buffer)
+            this.allocBuffer();
+        return this.buffer;
+    }
+    setSize(size) {
+        if (!this.buffer)
+            this.allocBuffer();
+        if (size > this.bufferSize) {
+            this.bufferSize = size;
+            this.allocBuffer();
+        }
+    }
+    write(buf, offset = 0) {
+        const device = globalInfo.errorGetDevice();
+        if (!this.buffer || buf.byteLength > this.bufferSize) {
+            this.bufferSize = buf.byteLength;
+            this.allocBuffer();
+        }
+        device.queue.writeBuffer(this.buffer, offset, buf.buffer, buf.byteOffset, buf.byteLength);
+    }
+    destroy() {
+        this.buffer?.destroy();
+    }
+}

package/dist/constants.d.ts

@@ -1,9 +1,3 @@
-export declare const vertexSize = 40;
-export declare const positionOffset = 0;
-export declare const colorOffset = 12;
-export declare const uvOffset = 28;
-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;

package/dist/constants.js

@@ -1,10 +1,5 @@
 import { vector3 } from './utils.js';
-export const vertexSize = 40; // 4 * 10
-export const positionOffset = 0;
-export const colorOffset = 12; // 4 * 3
-export const uvOffset = 28; // 4 * 8
-export const drawingInstancesOffset = 36;
-export const BUF_LEN = vertexSize / 4;
+// TODO find a place to put this
 export const worldProjMatOffset = 0;
 export const modelProjMatOffset = 4 * 16;
 export const mat4ByteLength = 64;

package/dist/geometry.d.ts

@@ -1,20 +1,17 @@
-import { VertexParamGeneratorInfo, CircleGeometryParams, CubeGeometryParams, EmptyParams, PolygonGeometryParams, Spline2dGeometryParams, SquareGeometryParams, Vector2, Vector3, VertexColorMap, LineGeometryParams, TraceLinesParams } from './types.js';
-import { Color, Vertex } from './utils.js';
+import { CircleGeometryParams, CubeGeometryParams, EmptyParams, Spline2dGeometryParams, SquareGeometryParams, Vector3, LineGeometryParams, TraceLinesParams } from './types.js';
+import { Vertex } from './utils.js';
 import { CubicBezierCurve2d, SplinePoint2d } from './graphics.js';
 export declare abstract class Geometry<T extends EmptyParams> {
     protected abstract wireframeOrder: number[];
     protected abstract triangleOrder: number[];
     protected abstract params: T;
     protected vertices: Vector3[];
-    protected geometryType: 'list' | 'strip';
+    protected topology: 'list' | 'strip';
     constructor(vertices?: Vector3[], geometryType?: 'list' | 'strip');
-    getType(): "list" | "strip";
+    getTopology(): "list" | "strip";
     abstract recompute(): void;
-    getTriangleVertexCount(): number;
-    getWireframeVertexCount(): number;
-    protected bufferFromOrder(order: number[], color: Color, vertexParamGenerator?: VertexParamGeneratorInfo): number[];
-    getWireframeBuffer(color: Color, vertexParamGenerator?: VertexParamGeneratorInfo): number[];
-    getTriangleBuffer(color: Color, vertexParamGenerator?: VertexParamGeneratorInfo): number[];
+    getIndexes(wireframe: boolean): number[];
+    getVertices(): Vector3[];
 }
 export declare class PlaneGeometry extends Geometry<EmptyParams> {
     protected params: {};
@@ -24,7 +21,6 @@ export declare class PlaneGeometry extends Geometry<EmptyParams> {
     constructor(vertices: Vertex[]);
     recompute(): void;
     updateVertices(vertices: Vertex[]): void;
-    getTriangleBuffer(color: Color, vertexParamGenerator?: VertexParamGeneratorInfo): number[];
 }
 export declare class CubeGeometry extends Geometry<CubeGeometryParams> {
     protected params: CubeGeometryParams;
@@ -41,14 +37,10 @@ export declare class SquareGeometry extends Geometry<SquareGeometryParams> {
     protected wireframeOrder: number[];
     protected triangleOrder: number[];
     protected params: SquareGeometryParams;
-    constructor(width: number, height: number, centerOffset?: Vector2);
-    setOffset(offset: Vector2): void;
-    getOffset(): Vector2;
-    setVertexColorMap(colorMap: VertexColorMap): void;
+    constructor(width: number, height: number);
     setWidth(width: number): void;
     setHeight(height: number): void;
     recompute(): void;
-    getTriangleBuffer(color: Color, vertexParamGenerator?: VertexParamGeneratorInfo): number[];
 }
 export declare class BlankGeometry extends Geometry<EmptyParams> {
     protected wireframeOrder: never[];
@@ -63,64 +55,54 @@ export declare class CircleGeometry extends Geometry<CircleGeometryParams> {
     protected params: CircleGeometryParams;
     constructor(radius: number, detail: number);
     setRadius(radius: number): void;
-    private updateWireframeOrder;
-    private updateTriangleOrder;
     recompute(): void;
 }
 export declare class Spline2dGeometry extends Geometry<Spline2dGeometryParams> {
     protected wireframeOrder: number[];
     protected triangleOrder: number[];
     protected params: Spline2dGeometryParams;
-    constructor(points: SplinePoint2d[], color: Color, thickness: number, detail: number);
+    constructor(points: SplinePoint2d[], thickness: number, detail: number);
     updateInterpolationStart(start: number): void;
     updateInterpolationLimit(limit: number): void;
+    getInterpolationStart(): number;
+    getInterpolationLimit(): number;
+    getDistance(): number;
     updatePoint(pointIndex: number, newPoint: SplinePoint2d): void;
     updateThickness(thickness: number): void;
-    private getVertexCount;
-    getWireframeVertexCount(): number;
-    getTriangleVertexCount(): number;
     getCurves(): CubicBezierCurve2d[];
+    getVertexInterpolations(): number[];
+    getCurveVertexIndices(): number[];
     private computeCurves;
-    private updateWireframeOrder;
     recompute(): void;
-    getWireframeBuffer(color: Color, vertexParamGenerator?: VertexParamGeneratorInfo): number[];
-    getTriangleBuffer(_: Color, vertexParamGenerator?: VertexParamGeneratorInfo): number[];
 }
 export declare class Line2dGeometry extends Geometry<LineGeometryParams> {
     protected wireframeOrder: number[];
     protected triangleOrder: number[];
     protected params: LineGeometryParams;
-    constructor(pos: Vector3, to: Vector3, thickness: number, fromColor?: Color | null, toColor?: Color | null);
-    private generateBuffer;
-    getTriangleBuffer(color: Color, vertexParamGenerator?: VertexParamGeneratorInfo): number[];
-    getWireframeBuffer(color: Color, vertexParamGenerator?: VertexParamGeneratorInfo): number[];
+    constructor(pos: Vector3, to: Vector3, thickness: number);
     recompute(): void;
 }
 export declare class Line3dGeometry extends Geometry<LineGeometryParams> {
     protected wireframeOrder: number[];
     protected triangleOrder: number[];
     protected params: LineGeometryParams;
-    constructor(pos: Vector3, to: Vector3, thickness: number, fromColor?: Color | null, toColor?: Color | null);
-    private generateBuffer;
-    getTriangleBuffer(color: Color, vertexParamGenerator?: VertexParamGeneratorInfo): number[];
-    getWireframeBuffer(color: Color, vertexParamGenerator?: VertexParamGeneratorInfo): number[];
+    constructor(pos: Vector3, to: Vector3, thickness: number);
     recompute(): void;
 }
-export declare class PolygonGeometry extends Geometry<PolygonGeometryParams> {
+export declare class PolygonGeometry extends Geometry<EmptyParams> {
     protected wireframeOrder: number[];
     protected triangleOrder: number[];
-    protected params: PolygonGeometryParams;
-    constructor(points: Vertex[]);
+    protected params: {};
+    constructor(vertices: Vector3[]);
     recompute(): void;
-    getTriangleBuffer(color: Color): number[];
 }
-export declare class TraceLines2dGeometry extends Geometry<EmptyParams> {
-    protected wireframeOrder: never[];
+export declare class TraceLines2dGeometry extends Geometry<TraceLinesParams> {
+    protected wireframeOrder: number[];
     protected triangleOrder: never[];
     protected params: TraceLinesParams;
     constructor(maxLen?: number);
     recompute(): void;
-    getWireframeBuffer(color: Color, vertexParamGenerator?: VertexParamGeneratorInfo | undefined): number[];
-    getWireframeVertexCount(): number;
-    addVertex(vert: Vertex): void;
+    getVertexCount(): number;
+    getOrder(_: boolean): readonly [Vector3[], number[]];
+    addVertex(vert: Vector3): void;
 }