simulationjsv2 0.7.4 → 0.8.0

package/dist/simulation.js

@@ -1,12 +1,10 @@
 import { vec3 } from 'wgpu-matrix';
-import { EmptyElement, SimulationElement3d } from './graphics.js';
-import { BUF_LEN, worldProjMatOffset } from './constants.js';
+import { SimulationElement3d } from './graphics.js';
 import { Color, matrix4, transitionValues, vector2, vector3 } from './utils.js';
-import { BlankGeometry } from './geometry.js';
-import createUniformBindGroup, { SimSceneObjInfo, buildDepthTexture, buildMultisampleTexture, updateProjectionMatrix, createPipeline, getTotalVertices, logger, removeObjectId, updateOrthoProjectionMatrix, updateWorldProjectionMatrix, globalInfo, CachedArray, createDefaultPipelines } from './internalUtils.js';
+import { SimSceneObjInfo, buildDepthTexture, buildMultisampleTexture, updateProjectionMatrix, getVertexAndIndexSize, removeObjectId, updateOrthoProjectionMatrix, updateWorldProjectionMatrix, CachedArray } from './internalUtils.js';
 import { Settings } from './settings.js';
-import { defaultShader } from './shaders.js';
 import { MemoBuffer } from './buffers.js';
+import { globalInfo, logger } from './globals.js';
 const simjsFrameRateCss = `.simjs-frame-rate {
   position: absolute;
   top: 0;
@@ -55,8 +53,8 @@ class FrameRateView {
 }
 let aspectRatio = 0;
 const projMat = matrix4();
-const worldProjMat = matrix4();
-const orthoMatrix = matrix4();
+export const worldProjectionMatrix = matrix4();
+export const orthogonalMatrix = matrix4();
 export class Camera {
     pos;
     rotation;
@@ -152,12 +150,11 @@ export class Simulation extends Settings {
     fittingElement = false;
     running = true;
     initialized = false;
-    pipelines = null;
-    renderInfo = null;
     resizeEvents;
     frameRateView;
     transparentElements;
     vertexBuffer;
+    indexBuffer;
     constructor(idOrCanvasRef, sceneCamera = null, showFrameRate = false) {
         super();
         if (typeof idOrCanvasRef === 'string') {
@@ -185,6 +182,7 @@ export class Simulation extends Settings {
         this.frameRateView.updateFrameRate(1);
         this.transparentElements = new CachedArray();
         this.vertexBuffer = new MemoBuffer(GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST, 0);
+        this.indexBuffer = new MemoBuffer(GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST, 0);
     }
     handleCanvasResize(parent) {
         if (this.fittingElement) {
@@ -274,14 +272,6 @@ export class Simulation extends Settings {
                 format: presentationFormat,
                 alphaMode: 'opaque'
             });
-            this.pipelines = createDefaultPipelines(defaultShader);
-            const instanceBuffer = device.createBuffer({
-                size: 10 * 4 * 16,
-                usage: GPUBufferUsage.STORAGE
-            });
-            this.renderInfo = {
-                instanceBuffer
-            };
             this.render(device, ctx, canvas);
         })();
     }
@@ -311,8 +301,8 @@ export class Simulation extends Settings {
             updateProjectionMatrix(projMat, newAspectRatio);
             aspectRatio = newAspectRatio;
         }
-        updateWorldProjectionMatrix(worldProjMat, projMat);
-        updateOrthoProjectionMatrix(orthoMatrix, camera.getScreenSize());
+        updateWorldProjectionMatrix(worldProjectionMatrix, projMat);
+        updateOrthoProjectionMatrix(orthogonalMatrix, camera.getScreenSize());
         let multisampleTexture = buildMultisampleTexture(device, ctx, canvas.width, canvas.height);
         let depthTexture = buildDepthTexture(device, canvas.width, canvas.height);
         const renderPassDescriptor = {
@@ -328,7 +318,7 @@ export class Simulation extends Settings {
         let prev = Date.now() - 10;
         let prevFps = 0;
         const frame = async () => {
-            if (!canvas || !this.renderInfo)
+            if (!canvas)
                 return;
             requestAnimationFrame(frame);
             if (!this.running)
@@ -348,7 +338,7 @@ export class Simulation extends Settings {
                 screenSize[1] = canvas.height;
                 aspectRatio = camera.getAspectRatio();
                 updateProjectionMatrix(projMat, aspectRatio);
-                updateWorldProjectionMatrix(worldProjMat, projMat);
+                updateWorldProjectionMatrix(worldProjectionMatrix, projMat);
                 multisampleTexture = buildMultisampleTexture(device, ctx, screenSize[0], screenSize[1]);
                 depthTexture = buildDepthTexture(device, screenSize[0], screenSize[1]);
                 renderPassDescriptor.depthStencilAttachment.view = depthTexture.createView();
@@ -360,133 +350,72 @@ export class Simulation extends Settings {
             // @ts-ignore
             renderPassDescriptor.colorAttachments[0].resolveTarget = ctx.getCurrentTexture().createView();
             if (camera.hasUpdated()) {
-                updateOrthoProjectionMatrix(orthoMatrix, camera.getScreenSize());
-                updateWorldProjectionMatrix(worldProjMat, projMat);
+                updateOrthoProjectionMatrix(orthogonalMatrix, camera.getScreenSize());
+                updateWorldProjectionMatrix(worldProjectionMatrix, projMat);
             }
             const commandEncoder = device.createCommandEncoder();
             const passEncoder = commandEncoder.beginRenderPass(renderPassDescriptor);
-            const totalVertices = getTotalVertices(this.scene);
-            this.vertexBuffer.setSize(totalVertices * 4 * BUF_LEN);
+            const [totalVerticesSize, totalIndexSize] = getVertexAndIndexSize(this.scene);
+            this.vertexBuffer.setSize(totalVerticesSize * 4);
+            this.indexBuffer.setSize(totalIndexSize * 4);
             this.transparentElements.reset();
-            const opaqueOffset = this.renderScene(device, passEncoder, this.vertexBuffer.getBuffer(), this.scene, 0, diff, false);
-            this.renderScene(device, passEncoder, this.vertexBuffer.getBuffer(), this.transparentElements.toArray(), opaqueOffset, diff, true);
+            const [opaqueVertexOffset, opaqueIndexOffset] = this.renderScene(device, passEncoder, this.vertexBuffer.getBuffer(), this.indexBuffer.getBuffer(), 0, 0, this.scene, this.scene.length, diff, false);
+            this.renderScene(device, passEncoder, this.vertexBuffer.getBuffer(), this.indexBuffer.getBuffer(), opaqueVertexOffset, opaqueIndexOffset, this.transparentElements.getArray(), this.transparentElements.length, diff, true);
             camera.updateConsumed();
             passEncoder.end();
             device.queue.submit([commandEncoder.finish()]);
         };
         requestAnimationFrame(frame);
     }
-    renderScene(device, passEncoder, vertexBuffer, scene, startOffset, diff, transparent, shaderInfo) {
-        if (this.pipelines === null)
-            return 0;
-        let currentOffset = startOffset;
+    renderScene(device, passEncoder, vertexBuffer, indexBuffer, startVertexOffset, startIndexOffset, scene, numElements, diff, transparent) {
+        let vertexOffset = startVertexOffset;
+        let indexOffset = startIndexOffset;
         const toRemove = [];
-        for (let i = 0; i < scene.length; i++) {
-            const lifetime = scene[i].getLifetime();
+        for (let i = 0; i < numElements; i++) {
+            const sceneObj = scene[i];
+            const lifetime = sceneObj.getLifetime();
             if (lifetime !== null) {
-                const complete = scene[i].lifetimeComplete();
+                const complete = sceneObj.lifetimeComplete();
                 if (complete) {
                     toRemove.push(i);
                     continue;
                 }
-                scene[i].traverseLife(diff);
+                sceneObj.traverseLife(diff);
             }
-            const obj = scene[i].getObj();
+            const obj = sceneObj.getObj();
             if (!transparent && obj.isTransparent()) {
-                this.transparentElements.add(scene[i]);
+                this.transparentElements.add(sceneObj);
                 continue;
             }
             if (obj.hasChildren()) {
-                let shaderInfo = undefined;
-                if (obj instanceof ShaderGroup) {
-                    const pipeline = obj.getPipeline();
-                    if (pipeline !== null) {
-                        shaderInfo = {
-                            pipeline,
-                            paramGenerator: obj.getVertexParamGenerator(),
-                            bufferInfo: obj.hasBindGroup()
-                                ? {
-                                    buffers: obj.getBindGroupBuffers(device),
-                                    layout: obj.getBindGroupLayout()
-                                }
-                                : null
-                        };
-                    }
-                }
-                currentOffset += this.renderScene(device, passEncoder, vertexBuffer, obj.getChildrenInfos(), currentOffset, diff, transparent, shaderInfo);
+                const childObjects = obj.getChildrenInfos();
+                const [vertexDiff, indexDiff] = this.renderScene(device, passEncoder, vertexBuffer, indexBuffer, vertexOffset, indexOffset, childObjects, childObjects.length, diff, transparent);
+                vertexOffset += vertexDiff;
+                indexOffset += indexDiff;
             }
             if (obj.isEmpty)
                 continue;
-            const buffer = new Float32Array(obj.getBuffer(shaderInfo?.paramGenerator));
-            const bufLen = shaderInfo?.paramGenerator?.bufferSize || BUF_LEN;
-            const vertexCount = buffer.length / bufLen;
-            device.queue.writeBuffer(vertexBuffer, currentOffset, buffer.buffer, buffer.byteOffset, buffer.byteLength);
-            vertexBuffer.unmap();
-            passEncoder.setVertexBuffer(0, vertexBuffer, currentOffset, buffer.byteLength);
-            const modelMatrix = obj.getModelMatrix();
-            const uniformBuffer = obj.getUniformBuffer(modelMatrix);
-            const projBuf = obj.is3d ? worldProjMat : orthoMatrix;
-            device.queue.writeBuffer(uniformBuffer, worldProjMatOffset, projBuf.buffer, projBuf.byteOffset, projBuf.byteLength);
-            if (shaderInfo) {
-                passEncoder.setPipeline(shaderInfo.pipeline);
+            const vertices = obj.getVertexBuffer();
+            const indices = obj.getIndexBuffer();
+            device.queue.writeBuffer(vertexBuffer, vertexOffset, vertices.buffer, vertices.byteOffset, vertices.byteLength);
+            device.queue.writeBuffer(indexBuffer, indexOffset, indices.buffer, indices.byteOffset, indices.byteLength);
+            passEncoder.setVertexBuffer(0, vertexBuffer, vertexOffset, vertices.byteLength);
+            passEncoder.setIndexBuffer(indexBuffer, 'uint32', indexOffset, indices.byteLength);
+            passEncoder.setPipeline(obj.getPipeline());
+            obj.writeBuffers();
+            const instances = obj.isInstance ? obj.getNumInstances() : 1;
+            const bindGroups = obj.getShader().getBindGroups(obj);
+            for (let i = 0; i < bindGroups.length; i++) {
+                passEncoder.setBindGroup(i, bindGroups[i]);
             }
-            else if (obj.isWireframe()) {
-                if (obj.isTransparent())
-                    passEncoder.setPipeline(this.pipelines.lineStripTransparent);
-                else
-                    passEncoder.setPipeline(this.pipelines.lineStrip);
-            }
-            else {
-                const type = obj.getGeometryType();
-                // must be exhaustive
-                if (type === 'strip') {
-                    if (obj.isTransparent())
-                        passEncoder.setPipeline(this.pipelines.triangleStripTransparent);
-                    else
-                        passEncoder.setPipeline(this.pipelines.triangleStrip);
-                }
-                else if (type === 'list') {
-                    if (obj.isTransparent())
-                        passEncoder.setPipeline(this.pipelines.triangleListTransparent);
-                    else
-                        passEncoder.setPipeline(this.pipelines.triangleList);
-                }
-            }
-            let instances = 1;
-            if (this.renderInfo) {
-                let instanceBuffer;
-                if (obj.isInstance) {
-                    instances = obj.getNumInstances();
-                    instanceBuffer =
-                        obj.getMatrixBuffer() ?? this.renderInfo.instanceBuffer;
-                }
-                else {
-                    instanceBuffer = this.renderInfo.instanceBuffer;
-                }
-                const uniformBindGroup = createUniformBindGroup(defaultShader, [uniformBuffer, instanceBuffer]);
-                passEncoder.setBindGroup(0, uniformBindGroup);
-            }
-            if (shaderInfo && shaderInfo.bufferInfo) {
-                const bindGroupEntries = shaderInfo.bufferInfo.buffers.map((buffer, index) => ({
-                    binding: index,
-                    resource: {
-                        buffer
-                    }
-                }));
-                const bindGroup = device.createBindGroup({
-                    layout: shaderInfo.bufferInfo.layout,
-                    entries: bindGroupEntries
-                });
-                passEncoder.setBindGroup(1, bindGroup);
-            }
-            // TODO maybe switch to drawIndexed
-            passEncoder.draw(vertexCount, instances, 0, 0);
-            currentOffset += buffer.byteLength;
+            passEncoder.drawIndexed(indices.length, instances);
+            vertexOffset += vertices.byteLength;
+            indexOffset += indices.byteLength;
         }
         for (let i = toRemove.length - 1; i >= 0; i--) {
-            this.remove(scene[i].getObj());
+            this.remove(scene.at(i).getObj());
         }
-        return currentOffset - startOffset;
+        return [vertexOffset - startVertexOffset, indexOffset - startIndexOffset];
     }
     fitElement() {
         if (this.canvasRef === null)
@@ -500,114 +429,3 @@ export class Simulation extends Settings {
         }
     }
 }
-const defaultShaderCode = `
-struct Uniforms {
-  worldProjectionMatrix: mat4x4<f32>,
-  modelProjectionMatrix: mat4x4<f32>,
-}
- 
-@group(0) @binding(0) var<uniform> uniforms: Uniforms;
-
-@group(0) @binding(1) var<storage> instanceMatrices: array<mat4x4f>;
-`;
-export class ShaderGroup extends EmptyElement {
-    code;
-    module;
-    pipeline;
-    bindGroupLayout;
-    topology;
-    paramGenerator;
-    vertexParams;
-    bindGroup;
-    valueBuffers;
-    constructor(shaderCode, topology = 'triangle-list', vertexParams, paramGenerator, bindGroup) {
-        super();
-        this.geometry = new BlankGeometry();
-        this.code = defaultShaderCode + shaderCode;
-        this.module = null;
-        this.pipeline = null;
-        this.bindGroupLayout = null;
-        this.bindGroup = bindGroup || null;
-        this.topology = topology;
-        this.paramGenerator = paramGenerator;
-        this.vertexParams = vertexParams;
-        this.valueBuffers = null;
-    }
-    initPipeline() {
-        const device = globalInfo.errorGetDevice();
-        this.module = device.createShaderModule({ code: this.code });
-        const presentationFormat = navigator.gpu.getPreferredCanvasFormat();
-        const bindGroupLayout = defaultShader.getBindGroupLayout();
-        const bindGroups = [bindGroupLayout];
-        if (this.bindGroup !== null) {
-            const entryValues = this.bindGroup.bindings.map((binding, index) => ({
-                binding: index,
-                visibility: binding.visibility,
-                buffer: binding.buffer
-            }));
-            this.bindGroupLayout = device.createBindGroupLayout({
-                entries: entryValues
-            });
-            bindGroups.push(this.bindGroupLayout);
-        }
-        this.pipeline = createPipeline(device, this.module, bindGroups, presentationFormat, this.topology, 
-        // TODO possibly make transparent materials
-        false, this.vertexParams);
-    }
-    getBindGroupLayout() {
-        return this.bindGroupLayout;
-    }
-    getPipeline() {
-        if (!this.pipeline)
-            this.initPipeline();
-        return this.pipeline;
-    }
-    getBindGroupBuffers(device) {
-        if (this.bindGroup === null)
-            return null;
-        if (device === null)
-            return null;
-        const values = this.bindGroup.values();
-        if (this.valueBuffers === null) {
-            this.valueBuffers = [];
-            for (let i = 0; i < values.length; i++) {
-                const buffer = this.createBuffer(device, values[i]);
-                this.valueBuffers.push(buffer);
-            }
-        }
-        else {
-            for (let i = 0; i < values.length; i++) {
-                const arrayConstructor = values[i].array;
-                const array = new arrayConstructor(values[i].value);
-                if (array.byteLength > this.valueBuffers[i].size) {
-                    const newBuffer = this.createBuffer(device, values[i]);
-                    this.valueBuffers[i].destroy();
-                    this.valueBuffers[i] = newBuffer;
-                }
-                else {
-                    device.queue.writeBuffer(this.valueBuffers[i], 0, array.buffer, array.byteOffset, array.byteLength);
-                }
-            }
-        }
-        return this.valueBuffers;
-    }
-    createBuffer(device, value) {
-        const arrayConstructor = value.array;
-        const array = new arrayConstructor(value.value);
-        const buffer = device.createBuffer({
-            mappedAtCreation: true,
-            size: array.byteLength,
-            usage: value.usage
-        });
-        const bufferArr = new arrayConstructor(buffer.getMappedRange());
-        bufferArr.set(array);
-        buffer.unmap();
-        return buffer;
-    }
-    getVertexParamGenerator() {
-        return this.paramGenerator;
-    }
-    hasBindGroup() {
-        return !!this.bindGroup;
-    }
-}

package/dist/types.d.ts

@@ -1,7 +1,11 @@
 /// <reference types="@webgpu/types" />
+import { MemoBuffer } from './buffers.js';
 import { CubicBezierCurve2d, SimulationElement2d, SimulationElement3d, SplinePoint2d } from './graphics.js';
-import { Color, Vertex } from './utils.js';
+import { Color } from './utils.js';
 export type FloatArray = Float32Array | Float64Array;
+export type UintArray = Uint8Array | Uint16Array | Uint32Array;
+export type IntArray = Int8Array | Int16Array | Int32Array;
+export type ArrayTypes = FloatArray | UintArray | IntArray;
 export type Vector4 = FloatArray & [number, number, number, number];
 export type Vector3 = FloatArray & [number, number, number];
 export type Vector2 = FloatArray & [number, number];
@@ -29,85 +33,86 @@ export type VertexColorMap = Record<number, Color>;
 export type ElementRotation<T extends Vector2 | Vector3> = T extends Vector2 ? number : T;
 export type AnySimulationElement = SimulationElement2d | SimulationElement3d;
 export type EmptyParams = object;
-export type CubeGeometryParams = {
+export interface CubeGeometryParams {
     width: number;
     height: number;
     depth: number;
-};
-export type SquareGeometryParams = {
+}
+export interface SquareGeometryParams {
     width: number;
     height: number;
-    colorMap: VertexColorMap;
-    centerOffset: Vector2;
-};
-export type CircleGeometryParams = {
+}
+export interface CircleGeometryParams {
     radius: number;
     detail: number;
-};
-export type Spline2dGeometryParams = {
+}
+export interface Spline2dGeometryParams {
     points: SplinePoint2d[];
-    curves: CubicBezierCurve2d[];
-    distance: number;
     detail: number;
     interpolateStart: number;
     interpolateLimit: number;
     thickness: number;
-    color: Color;
-    vertexColors: Color[];
-};
-export type LineGeometryParams = {
+    curves: CubicBezierCurve2d[];
+    distance: number;
+    vertexInterpolations: number[];
+    curveVertexIndices: number[];
+}
+export interface LineGeometryParams {
     pos: Vector3;
     to: Vector3;
-    fromColor: Color | null;
-    toColor: Color | null;
     thickness: number;
-};
-export type PolygonGeometryParams = {
-    points: Vertex[];
-};
-export type TraceLinesParams = {
-    vertices: Vertex[];
+}
+export interface TraceLinesParams {
     maxLength: number | null;
-};
-export type PipelineGroup = {
+}
+export interface PipelineGroup {
     triangleList: GPURenderPipeline;
     triangleStrip: GPURenderPipeline;
     lineStrip: GPURenderPipeline;
     triangleListTransparent: GPURenderPipeline;
     triangleStripTransparent: GPURenderPipeline;
     lineStripTransparent: GPURenderPipeline;
-};
-export type RenderInfo = {
-    instanceBuffer: GPUBuffer;
-};
-export type VertexParamGeneratorInfo = {
+}
+export interface VertexParamGeneratorInfo {
     bufferSize: number;
     createBuffer: (x: number, y: number, z: number, color: Color) => number[];
-};
-export type ShaderInfo = {
+}
+export interface ShaderInfo {
     pipeline: GPURenderPipeline;
     paramGenerator: VertexParamGeneratorInfo;
     bufferInfo: {
         buffers: GPUBuffer[];
         layout: GPUBindGroupLayout;
     } | null;
-};
-export type VertexParamInfo = {
+}
+export interface VertexParamInfo {
     format: GPUVertexFormat;
     size: number;
-};
-export type BindGroupEntry = {
+}
+export interface BindGroupEntry {
     visibility: GPUBindGroupLayoutEntry['visibility'];
     buffer: GPUBindGroupLayoutEntry['buffer'];
-};
+}
 export type ArrayConstructors = Float32ArrayConstructor | Float64ArrayConstructor | Int8ArrayConstructor | Int16ArrayConstructor | Int32ArrayConstructor;
-export type ArrayTypes = Float32Array | Float64Array | Int8Array | Int16Array | Int32Array;
-export type BindGroupValue = {
+export interface BindGroupValue {
     value: number[];
     usage: GPUBufferDescriptor['usage'];
     array: ArrayConstructors;
-};
-export type BindGroupInfo = {
+}
+export interface BindGroupInfo {
     bindings: BindGroupEntry[];
     values: () => BindGroupValue[];
-};
+}
+export interface SimulationElementInfo {
+    topology: GPUPrimitiveTopology;
+    transparent: boolean;
+    cullMode: GPUCullMode;
+}
+export interface BufferInfo {
+    usage: GPUBufferDescriptor['usage'];
+    defaultSize?: number;
+    owned?: boolean;
+}
+export type VertexBufferWriter = (element: SimulationElement3d, buffer: Float32Array, vertex: Vector3, vertexIndex: number, offset: number) => void;
+export type BufferWriter = (element: SimulationElement3d, buffers: MemoBuffer[], device: GPUDevice) => void;
+export type BindGroupGenerator = (element: SimulationElement3d, buffers: MemoBuffer[]) => GPUBindGroup[];

package/dist/utils.d.ts

@@ -1,12 +1,15 @@
-import { SplinePoint2d } from './graphics.js';
+/// <reference types="@webgpu/types" />
+import { SimulationElement3d, SplinePoint2d } from './graphics.js';
 import { AnySimulationElement, FloatArray, Mat4, Vector2, Vector3, Vector4 } from './types.js';
 import { SimSceneObjInfo } from './internalUtils.js';
+import { Shader } from './shaders.js';
 export declare class Color {
     r: number;
     g: number;
     b: number;
     a: number;
     constructor(r?: number, g?: number, b?: number, a?: number);
+    static fromVec4(vec: Vector4): Color;
     clone(): Color;
     toBuffer(): readonly [number, number, number, number];
     toVec4(): Vector4;
@@ -17,6 +20,8 @@ export declare class Color {
         a: number;
     };
     diff(color: Color): Color;
+    isTransparent(): boolean;
+    setValues(color: Color): void;
 }
 export declare class Vertex {
     private pos;
@@ -33,7 +38,6 @@ export declare class Vertex {
     setY(y: number): void;
     setZ(z: number): void;
     clone(): Vertex;
-    toBuffer(defaultColor: Color): number[];
 }
 /**
  * @param onFrame - called every frame until the animation is finished
@@ -64,7 +68,6 @@ export declare function vector2(x?: number, y?: number): Vector2;
 export declare function matrix4(): Mat4;
 export declare function vector3FromVector2(vec: Vector2): Vector3;
 export declare function vector2FromVector3(vec: Vector3): Vector2;
-export declare function colorFromVector4(vec: Vector4): Color;
 export declare function randomInt(range: number, min?: number): number;
 export declare function randomColor(a?: number): Color;
 export declare function vertex(x?: number, y?: number, z?: number, color?: Color, uv?: Vector2): Vertex;
@@ -81,4 +84,6 @@ export declare function distance3d(vector1: Vector3, vector2: Vector3): number;
 export declare function toSceneObjInfo(el: AnySimulationElement, id?: string): SimSceneObjInfo;
 export declare function toSceneObjInfoMany(el: AnySimulationElement[], id?: (string | undefined)[]): SimSceneObjInfo[];
 export declare function interpolateColors(colors: Color[], t: number): Color;
+export declare function createBindGroup(shader: Shader, bindGroupIndex: number, buffers: GPUBuffer[]): GPUBindGroup;
+export declare function writeUniformWorldMatrix(el: SimulationElement3d): void;
 export {};

package/dist/utils.js

@@ -1,6 +1,9 @@
 import { mat4, vec2, vec3, vec4 } from 'wgpu-matrix';
 import { SplinePoint2d } from './graphics.js';
-import { SimSceneObjInfo, bufferGenerator } from './internalUtils.js';
+import { SimSceneObjInfo } from './internalUtils.js';
+import { globalInfo } from './globals.js';
+import { orthogonalMatrix, worldProjectionMatrix } from './simulation.js';
+import { worldProjMatOffset } from './constants.js';
 export class Color {
     r; // 0 - 255
     g; // 0 - 255
@@ -12,6 +15,9 @@ export class Color {
         this.b = b;
         this.a = a;
     }
+    static fromVec4(vec) {
+        return new Color(vec[0], vec[1], vec[2], vec[3]);
+    }
     clone() {
         return new Color(this.r, this.g, this.b, this.a);
     }
@@ -32,6 +38,15 @@ export class Color {
     diff(color) {
         return new Color(this.r - color.r, this.g - color.g, this.b - color.b, this.a - color.a);
     }
+    isTransparent() {
+        return this.a < 1;
+    }
+    setValues(color) {
+        this.r = color.r;
+        this.g = color.g;
+        this.b = color.b;
+        this.a = color.a;
+    }
 }
 export class Vertex {
     pos;
@@ -39,7 +54,7 @@ export class Vertex {
     uv;
     constructor(x = 0, y = 0, z = 0, color, uv = vector2()) {
         this.pos = vector3(x, y, z);
-        this.color = color || null;
+        this.color = color ?? null;
         this.uv = uv;
     }
     getPos() {
@@ -72,9 +87,6 @@ export class Vertex {
     clone() {
         return new Vertex(this.pos[0], this.pos[1], this.pos[2], this.color?.clone(), cloneBuf(this.uv));
     }
-    toBuffer(defaultColor) {
-        return bufferGenerator.generate(this.pos[0], this.pos[1], this.pos[2], this.color || defaultColor, this.uv);
-    }
 }
 /**
  * @param onFrame - called every frame until the animation is finished
@@ -206,9 +218,6 @@ export function vector3FromVector2(vec) {
 export function vector2FromVector3(vec) {
     return vector2(vec[0], vec[1]);
 }
-export function colorFromVector4(vec) {
-    return new Color(vec[0], vec[1], vec[2], vec[3]);
-}
 export function randomInt(range, min = 0) {
     return Math.floor(Math.random() * (range - min)) + min;
 }
@@ -284,3 +293,22 @@ export function interpolateColors(colors, t) {
     res.a += diff.a;
     return res;
 }
+export function createBindGroup(shader, bindGroupIndex, buffers) {
+    const device = globalInfo.errorGetDevice();
+    const layout = shader.getBindGroupLayouts()[bindGroupIndex];
+    return device.createBindGroup({
+        layout: layout,
+        entries: buffers.map((buffer, index) => ({
+            binding: index,
+            resource: {
+                buffer
+            }
+        }))
+    });
+}
+export function writeUniformWorldMatrix(el) {
+    const device = globalInfo.errorGetDevice();
+    const uniformBuffer = el.getUniformBuffer();
+    const projBuf = el.is3d ? worldProjectionMatrix : orthogonalMatrix;
+    device.queue.writeBuffer(uniformBuffer, worldProjMatOffset, projBuf.buffer, projBuf.byteOffset, projBuf.byteLength);
+}

package/package.json

@@ -5,7 +5,7 @@
   "types": "./dist/index.d.ts",
   "author": "Jackson Otto",
   "description": "A simple graphics library using WebGPU",
-  "version": "0.7.4",
+  "version": "0.8.0",
   "exports": {
     ".": {
       "import": "./dist/index.js",

package/dist/pipelines.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/pipelines.js

@@ -1 +0,0 @@
-export {};