simulationjsv2 0.10.5 → 0.11.0

package/dist/simulation.js

@@ -1,9 +1,10 @@
 import { vec3 } from 'wgpu-matrix';
-import { Color, matrix4, transitionValues, vector2, vector3 } from './utils.js';
-import { buildDepthTexture, buildMultisampleTexture, updateProjectionMatrix, getVertexAndIndexSize, updateOrthoProjectionMatrix, updateWorldProjectionMatrix, CachedArray, addToScene, removeSceneObj, removeSceneId } from './internalUtils.js';
+import { matrix4, transitionValues, vector2, vector3, webGLAvailable } from './utils.js';
+import { updateProjectionMatrix, updateOrthoProjectionMatrix, updateWorldProjectionMatrix, CachedArray, addToScene, removeSceneObj, removeSceneId } from './internalUtils.js';
 import { Settings } from './settings.js';
-import { MemoBuffer } from './buffers.js';
 import { globalInfo, logger } from './globals.js';
+import { WebGLBackend } from './backends/webgl.js';
+import { WebGPUBackend } from './backends/webgpu.js';
 const simjsFrameRateCss = `.simjs-frame-rate {
   position: absolute;
   top: 0;
@@ -142,9 +143,13 @@ export class Camera {
     }
 }
 export let camera = new Camera(vector3());
+const defaultSimulationOptions = {
+    sceneCamera: null,
+    showFrameRate: false,
+    backendMode: 'webgpu'
+};
 export class Simulation extends Settings {
     canvasRef = null;
-    bgColor = new Color(255, 255, 255);
     scene = [];
     fittingElement = false;
     running = true;
@@ -152,9 +157,9 @@ export class Simulation extends Settings {
     resizeEvents;
     frameRateView;
     transparentElements;
-    vertexBuffer;
-    indexBuffer;
-    constructor(idOrCanvasRef, sceneCamera = null, showFrameRate = false) {
+    backend;
+    constructor(idOrCanvasRef, options = {}) {
+        const { sceneCamera = defaultSimulationOptions.sceneCamera, showFrameRate = defaultSimulationOptions.showFrameRate, backendMode = defaultSimulationOptions.backendMode } = options;
         super();
         if (typeof idOrCanvasRef === 'string') {
             const ref = document.getElementById(idOrCanvasRef);
@@ -181,8 +186,15 @@ export class Simulation extends Settings {
         this.frameRateView = new FrameRateView(showFrameRate);
         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);
+        if (backendMode === 'webgpu' && 'gpu' in navigator) {
+            this.backend = new WebGPUBackend();
+        }
+        else if (webGLAvailable(this.canvasRef)) {
+            this.backend = new WebGLBackend();
+        }
+        else {
+            throw logger.error('WebGL and WebGPU not available');
+        }
     }
     handleCanvasResize(parent) {
         if (this.fittingElement) {
@@ -199,6 +211,9 @@ export class Simulation extends Settings {
     onResize(cb) {
         this.resizeEvents.push(cb);
     }
+    getBackend() {
+        return this.backend;
+    }
     getWidth() {
         return this.canvasRef?.width || 0;
     }
@@ -242,35 +257,23 @@ export class Simulation extends Settings {
         (async () => {
             if (this.canvasRef === null)
                 return;
-            this.initialized = true;
-            this.running = true;
-            const adapter = await navigator.gpu.requestAdapter();
-            if (!adapter)
-                throw logger.error('Adapter is null');
-            const ctx = this.canvasRef.getContext('webgpu');
-            if (!ctx)
-                throw logger.error('Context is null');
-            const device = await adapter.requestDevice();
-            globalInfo.setDevice(device);
             const screenSize = vector2(this.canvasRef.width, this.canvasRef.height);
             camera.setScreenSize(screenSize);
             const canvas = this.canvasRef;
             canvas.width = canvas.clientWidth * devicePixelRatio;
             canvas.height = canvas.clientHeight * devicePixelRatio;
-            const presentationFormat = navigator.gpu.getPreferredCanvasFormat();
-            ctx.configure({
-                device,
-                format: presentationFormat,
-                alphaMode: 'opaque'
-            });
-            this.render(device, ctx, canvas);
+            this.initialized = true;
+            this.running = true;
+            await this.backend.init(this.canvasRef);
+            this.backend.initShaders(globalInfo.getToInitShaders());
+            this.render(canvas, this.backend);
         })();
     }
     stop() {
         this.running = false;
     }
     setBackground(color) {
-        this.bgColor = color;
+        this.backend.setClearColor(color);
     }
     setDefaultColor(color) {
         globalInfo.setDefaultColor(color);
@@ -281,15 +284,7 @@ export class Simulation extends Settings {
     getScene() {
         return this.scene;
     }
-    render(device, ctx, canvas) {
-        const colorAttachment = {
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore
-            view: undefined, // Assigned later
-            clearValue: this.bgColor.toObject(),
-            loadOp: 'clear',
-            storeOp: 'store'
-        };
+    render(canvas, backend) {
         const newAspectRatio = canvas.width / canvas.height;
         if (newAspectRatio !== aspectRatio) {
             updateProjectionMatrix(projMat, newAspectRatio);
@@ -297,23 +292,11 @@ export class Simulation extends Settings {
         }
         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 = {
-            colorAttachments: [colorAttachment],
-            depthStencilAttachment: {
-                view: depthTexture.createView(),
-                depthClearValue: 1.0,
-                depthLoadOp: 'clear',
-                depthStoreOp: 'store'
-            }
-        };
+        backend.renderStart(canvas);
         // sub 10 to start with a reasonable gap between starting time and next frame time
         let prev = Date.now() - 10;
         let prevFps = 0;
         const frame = async () => {
-            if (!canvas)
-                return;
             requestAnimationFrame(frame);
             if (!this.running)
                 return;
@@ -333,36 +316,23 @@ export class Simulation extends Settings {
                 aspectRatio = camera.getAspectRatio();
                 updateProjectionMatrix(projMat, aspectRatio);
                 updateWorldProjectionMatrix(worldProjectionMatrix, projMat);
-                multisampleTexture = buildMultisampleTexture(device, ctx, screenSize[0], screenSize[1]);
-                depthTexture = buildDepthTexture(device, screenSize[0], screenSize[1]);
-                renderPassDescriptor.depthStencilAttachment.view = depthTexture.createView();
+                backend.updateTextures(screenSize);
             }
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore
-            renderPassDescriptor.colorAttachments[0].view = multisampleTexture.createView();
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore
-            renderPassDescriptor.colorAttachments[0].resolveTarget = ctx.getCurrentTexture().createView();
             if (camera.hasUpdated()) {
                 updateOrthoProjectionMatrix(orthogonalMatrix, camera.getScreenSize());
                 updateWorldProjectionMatrix(worldProjectionMatrix, projMat);
             }
-            const commandEncoder = device.createCommandEncoder();
-            const passEncoder = commandEncoder.beginRenderPass(renderPassDescriptor);
-            const [totalVerticesSize, totalIndexSize] = getVertexAndIndexSize(this.scene);
-            this.vertexBuffer.setSize(totalVerticesSize * 4);
-            this.indexBuffer.setSize(totalIndexSize * 4);
+            backend.preRender(this.scene);
             this.transparentElements.reset();
-            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);
+            const [opaqueVertexOffset, opaqueIndexOffset] = this.renderScene(backend, 0, 0, this.scene, this.scene.length, diff, false);
+            this.renderScene(backend, opaqueVertexOffset, opaqueIndexOffset, this.transparentElements.getArray(), this.transparentElements.length, diff, true);
             camera.updateConsumed();
-            passEncoder.end();
-            device.queue.submit([commandEncoder.finish()]);
+            backend.finishRender();
         };
         requestAnimationFrame(frame);
     }
-    renderScene(device, passEncoder, vertexBuffer, indexBuffer, startVertexOffset, startIndexOffset, scene, numElements, diff, transparent) {
-        let vertexOffset = startVertexOffset;
+    renderScene(backend, startVertexCallOffset, startIndexOffset, scene, numElements, diff, transparent) {
+        let vertexCallOffset = startVertexCallOffset;
         let indexOffset = startIndexOffset;
         for (let i = 0; i < numElements; i++) {
             const obj = scene[i];
@@ -372,30 +342,23 @@ export class Simulation extends Settings {
             }
             if (obj.hasChildren()) {
                 const childObjects = obj.getChildrenInfos();
-                const [vertexDiff, indexDiff] = this.renderScene(device, passEncoder, vertexBuffer, indexBuffer, vertexOffset, indexOffset, childObjects, childObjects.length, diff, transparent);
-                vertexOffset += vertexDiff;
+                const [vertexDiff, indexDiff] = this.renderScene(backend, vertexCallOffset, indexOffset, childObjects, childObjects.length, diff, transparent);
+                vertexCallOffset += vertexDiff;
                 indexOffset += indexDiff;
             }
             if (obj.isEmpty)
                 continue;
-            const vertices = obj.getVertexBuffer();
+            const vertexCallBuffer = obj.getVertexCallBuffer();
             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]);
-            }
-            passEncoder.drawIndexed(indices.length, instances);
-            vertexOffset += vertices.byteLength;
+            backend.draw(obj, 
+            // vertex
+            vertexCallOffset, vertexCallBuffer, 
+            // index
+            indexOffset, indices);
+            vertexCallOffset += vertexCallBuffer.byteLength;
             indexOffset += indices.byteLength;
         }
-        return [vertexOffset - startVertexOffset, indexOffset - startIndexOffset];
+        return [vertexCallOffset - startVertexCallOffset, indexOffset - startIndexOffset];
     }
     fitElement() {
         if (this.canvasRef === null)

package/dist/types.d.ts

@@ -1,6 +1,11 @@
-/// <reference types="@webgpu/types" />
-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;
@@ -33,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;
@@ -57,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,7 +1,6 @@
-/// <reference types="@webgpu/types" />
 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;
@@ -83,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.5",
-  "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/pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+onlyBuiltDependencies:
+  - esbuild

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,37 +0,0 @@
-/// <reference types="@webgpu/types" />
-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;