simulationjsv2 0.10.6 → 0.11.0

package/dist/types.d.ts

@@ -1,5 +1,11 @@
-import { MemoBuffer } from './buffers.js';
+import { WebGLBackend } from './backends/webgl.js';
+import { WebGPUBackend } from './backends/webgpu.js';
+import { MemoBuffer } from './buffers/buffer.js';
+import { WebGLMemoBuffer } from './buffers/webgl.js';
+import { WebGPUMemoBuffer } from './buffers/webgpu.js';
 import { CubicBezierCurve2d, SimulationElement3d, SplinePoint2d } from './graphics.js';
+import { SimJSWebGLShader } from './shaders/webgl.js';
+import { SimJSWebGPUShader } from './shaders/webgpu.js';
 import { Color } from './utils.js';
 export type FloatArray = Float32Array | Float64Array;
 export type UintArray = Uint8Array | Uint16Array | Uint32Array;
@@ -32,21 +38,20 @@ export type Quat = Float32Array & [number, number, number, number];
 export type LerpFunc = (n: number) => number;
 export type VertexColorMap = Record<number, Color>;
 export type ElementRotation<T extends Vector2 | Vector3> = T extends Vector2 ? number : T;
-export type EmptyParams = object;
-export interface CubeGeometryParams {
+export type CubeGeometryParams = {
     width: number;
     height: number;
     depth: number;
-}
-export interface SquareGeometryParams {
+};
+export type SquareGeometryParams = {
     width: number;
     height: number;
-}
-export interface CircleGeometryParams {
+};
+export type CircleGeometryParams = {
     radius: number;
     detail: number;
-}
-export interface Spline2dGeometryParams {
+};
+export type Spline2dGeometryParams = {
     points: SplinePoint2d[];
     detail: number;
     interpolateStart: number;
@@ -56,63 +61,77 @@ export interface Spline2dGeometryParams {
     distance: number;
     vertexInterpolations: number[];
     curveVertexIndices: number[];
-}
-export interface LineGeometryParams {
+};
+export type LineGeometryParams = {
     pos: Vector3;
     to: Vector3;
     thickness: number;
-}
-export interface TraceLinesParams {
+};
+export type TraceLinesParams = {
     maxLength: number | null;
-}
-export interface PipelineGroup {
+};
+export type PipelineGroup = {
     triangleList: GPURenderPipeline;
     triangleStrip: GPURenderPipeline;
     lineStrip: GPURenderPipeline;
     triangleListTransparent: GPURenderPipeline;
     triangleStripTransparent: GPURenderPipeline;
     lineStripTransparent: GPURenderPipeline;
-}
-export interface VertexParamGeneratorInfo {
+};
+export type VertexParamGeneratorInfo = {
     bufferSize: number;
     createBuffer: (x: number, y: number, z: number, color: Color) => number[];
-}
-export interface ShaderInfo {
+};
+export type ShaderInfo = {
     pipeline: GPURenderPipeline;
     paramGenerator: VertexParamGeneratorInfo;
     bufferInfo: {
         buffers: GPUBuffer[];
         layout: GPUBindGroupLayout;
     } | null;
-}
-export interface VertexParamInfo {
+};
+export type VertexParamInfo = {
     format: GPUVertexFormat;
     size: number;
-}
-export interface BindGroupEntry {
+};
+export type BindGroupEntry = {
     visibility: GPUBindGroupLayoutEntry['visibility'];
     buffer: GPUBindGroupLayoutEntry['buffer'];
-}
+};
 export type ArrayConstructors = Float32ArrayConstructor | Float64ArrayConstructor | Int8ArrayConstructor | Int16ArrayConstructor | Int32ArrayConstructor;
-export interface BindGroupValue {
+export type BindGroupValue = {
     value: number[];
     usage: GPUBufferDescriptor['usage'];
     array: ArrayConstructors;
-}
-export interface BindGroupInfo {
+};
+export type BindGroupInfo = {
     bindings: BindGroupEntry[];
     values: () => BindGroupValue[];
-}
-export interface SimulationElementInfo {
+};
+export type SimulationElementInfo = {
     topology: GPUPrimitiveTopology;
     transparent: boolean;
     cullMode: GPUCullMode;
-}
-export interface BufferInfo {
+};
+export type WebGPUBufferDecleration = {
     usage: GPUBufferDescriptor['usage'];
     defaultSize?: number;
-    owned?: boolean;
-}
+};
+export type WebGLBufferDecleration = {
+    target: GLenum;
+    usage: GLenum;
+    defaultCapacity?: number;
+};
 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[];
+export type BackendType = 'webgpu' | 'webgl';
+export type BackendSpecificType<T extends BackendType, WebGPUOption, WebGLOption> = T extends 'webgpu' ? WebGPUOption : WebGLOption;
+export type SpecificBackendType<T extends BackendType> = BackendSpecificType<T, WebGPUBackend, WebGLBackend>;
+export type SpecificShaderType<T extends BackendType> = BackendSpecificType<T, SimJSWebGPUShader, SimJSWebGLShader<any>>;
+export type SpecificMemoBufferType<T extends BackendType> = BackendSpecificType<T, WebGPUMemoBuffer, WebGLMemoBuffer>;
+export type GPUBuffers<T extends BackendType | unknown> = {
+    gpuVertexCallBuffer: MemoBufferFromBackendType<T>;
+    gpuIndexBuffer: MemoBufferFromBackendType<T>;
+};
+export type AnyGPUBuffer = GPUBuffer | WebGLBuffer;
+export type MemoBufferFromBackendType<T extends BackendType | unknown> = T extends BackendType ? SpecificMemoBufferType<T> : MemoBuffer;
+export type BufferFromBackendType<T extends BackendType | unknown> = T extends BackendType ? BackendSpecificType<T, GPUBuffer, WebGLBuffer> : unknown;

package/dist/utils.d.ts

@@ -1,6 +1,6 @@
 import { SimulationElement3d, SplinePoint2d } from './graphics.js';
 import { FloatArray, LerpFunc, Mat4, Vector2, Vector2m, Vector3, Vector3m, Vector4 } from './types.js';
-import { Shader } from './shaders.js';
+import { SimJSWebGPUShader } from './shaders/webgpu.js';
 export declare class Color {
     r: number;
     g: number;
@@ -82,8 +82,8 @@ export declare function distance3d(vector1: Vector3m, vector2: Vector3m): number
 export declare function interpolateColors(colors: Color[], t: number): Color;
 export declare function vectorsToVertex(vectors: Vector3[]): Vertex[];
 export declare function cloneVectors(vectors: Vector3[]): Vector3[];
-export declare function createBindGroup(shader: Shader, bindGroupIndex: number, buffers: GPUBuffer[]): GPUBindGroup;
-export declare function writeUniformWorldMatrix(el: SimulationElement3d): void;
+export declare function createBindGroup(shader: SimJSWebGPUShader, bindGroupIndex: number, buffers: GPUBuffer[]): GPUBindGroup;
 export declare function transform(from: SimulationElement3d, to: SimulationElement3d, t: number, f?: LerpFunc): Promise<void>;
 export declare function defaultColor(): Color;
+export declare function webGLAvailable(canvas: HTMLCanvasElement): boolean;
 export {};

package/dist/utils.js

@@ -1,8 +1,6 @@
 import { mat4, vec2, vec3, vec4 } from 'wgpu-matrix';
 import { SplinePoint2d } from './graphics.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
@@ -288,7 +286,9 @@ export function cloneVectors(vectors) {
     return vectors.map((vec) => cloneBuf(vec));
 }
 export function createBindGroup(shader, bindGroupIndex, buffers) {
-    const device = globalInfo.errorGetDevice();
+    // TODO - probably change
+    const backend = globalInfo.errorGetCanvas().getBackend();
+    const device = backend.getDeviceOrError();
     const layout = shader.getBindGroupLayouts()[bindGroupIndex];
     return device.createBindGroup({
         layout: layout,
@@ -300,12 +300,6 @@ export function createBindGroup(shader, bindGroupIndex, buffers) {
         }))
     });
 }
-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);
-}
 /// may have unexpected position behavior for nested elements, or elements with a geometry with a set triangle order
 export function transform(from, to, t, f) {
     const canvas = globalInfo.errorGetCanvas();
@@ -332,3 +326,6 @@ export function transform(from, to, t, f) {
 export function defaultColor() {
     return globalInfo.getDefaultColor();
 }
+export function webGLAvailable(canvas) {
+    return canvas.getContext('webgl2') !== null;
+}

package/package.json

@@ -1,29 +1,29 @@
 {
-  "name": "simulationjsv2",
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "author": "Jackson Otto",
-  "description": "A simple graphics library using WebGPU",
-  "version": "0.10.6",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+    "name": "simulationjsv2",
+    "type": "module",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "author": "Jackson Otto",
+    "description": "A simple graphics library using WebGPU",
+    "version": "0.11.0",
+    "exports": {
+        ".": {
+            "import": "./dist/index.js",
+            "types": "./dist/index.d.ts"
+        }
+    },
+    "scripts": {
+        "dev": "npx nodemon --watch src -e ts --exec 'npx tsc || exit 1'",
+        "test": "vite --port 3000",
+        "build": "npx tsc"
+    },
+    "devDependencies": {
+        "nodemon": "^3.1.11",
+        "typescript": "^5.9.3",
+        "vite": "^4.5.14"
+    },
+    "dependencies": {
+        "@webgpu/types": "^0.1.68",
+        "wgpu-matrix": "^2.9.1"
     }
-  },
-  "scripts": {
-    "dev": "npx nodemon --watch src -e ts --exec 'npx tsc || exit 1'",
-    "test": "vite --port 3000",
-    "build": "npx tsc"
-  },
-  "devDependencies": {
-    "nodemon": "^3.0.1",
-    "typescript": "^5.1.6",
-    "vite": "^4.4.4"
-  },
-  "dependencies": {
-    "@webgpu/types": "^0.1.34",
-    "wgpu-matrix": "^2.8.0"
-  }
 }

package/dist/pipelineUtil.d.ts

@@ -1,5 +0,0 @@
-/// <reference types="@webgpu/types" />
-import { SimulationElement3d } from './graphics.js';
-import { Shader } from './shaders.js';
-export declare function createBindGroup(shader: Shader, bindGroupIndex: number, buffers: GPUBuffer[]): GPUBindGroup;
-export declare function writeUniformWorldMatrix(el: SimulationElement3d): void;

package/dist/pipelineUtil.js

@@ -1,22 +0,0 @@
-import { worldProjMatOffset } from './constants.js';
-import { globalInfo } from './globals.js';
-import { orthogonalMatrix, worldProjectionMatrix } from './simulation.js';
-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/dist/shaders.d.ts

@@ -1,36 +0,0 @@
-import { SimulationElement3d } from './graphics.js';
-import { BindGroupGenerator, BufferInfo, BufferWriter, Vector3, VertexBufferWriter, VertexParamInfo } from './types.js';
-export declare const uniformBufferSize: number;
-export declare class Shader {
-    private bindGroupLayoutDescriptors;
-    private bindGroupLayouts;
-    private module;
-    private code;
-    private fragmentMain;
-    private vertexMain;
-    private vertexBuffers;
-    private bufferLength;
-    private bufferWriter;
-    private vertexBufferWriter;
-    private bindGroupGenerator;
-    private buffers;
-    private bufferInfos;
-    constructor(code: string, descriptors: GPUBindGroupLayoutDescriptor[], vertexParams: VertexParamInfo[], bufferInfos: BufferInfo[], bufferWriter: BufferWriter, bindGroupGenerator: BindGroupGenerator, vertexBufferWriter: VertexBufferWriter, vertexMain?: string, fragmentMain?: string);
-    getCode(): string;
-    getBufferLength(): number;
-    getVertexBuffers(): GPUVertexBufferLayout;
-    getBindGroupLayouts(): GPUBindGroupLayout[];
-    getBindGroupLayoutDescriptors(): GPUBindGroupLayoutDescriptor[];
-    getBufferInfo(): BufferInfo[];
-    getBufferWriter(): BufferWriter;
-    getVertexBufferWriter(): VertexBufferWriter;
-    getBindGroupGenerator(): BindGroupGenerator;
-    getModule(): GPUShaderModule;
-    getVertexMain(): string;
-    getFragmentMain(): string;
-    setVertexInfo(element: SimulationElement3d, buffer: Float32Array, vertex: Vector3, vertexIndex: number, offset: number): void;
-    writeBuffers(el: SimulationElement3d): void;
-    getBindGroups(el: SimulationElement3d): GPUBindGroup[];
-}
-export declare const defaultShader: Shader;
-export declare const vertexColorShader: Shader;