simulationjsv2 0.10.6 → 0.11.0

package/dist/index.d.ts

@@ -2,7 +2,9 @@ export * from './simulation.js';
 export * from './graphics.js';
 export * from './utils.js';
 export * from './types.js';
-export * from './shaders.js';
+export * as webGPUShaderUtils from './shaders/webgpu.js';
 export * from './materials.js';
 export * from './constants.js';
+export * from './backends/backend.js';
+export * from './shaders/shader.js';
 export { vec2, vec3, vec4, mat3, mat4, quat } from 'wgpu-matrix';

package/dist/index.js

@@ -2,7 +2,9 @@ export * from './simulation.js';
 export * from './graphics.js';
 export * from './utils.js';
 export * from './types.js';
-export * from './shaders.js';
+export * as webGPUShaderUtils from './shaders/webgpu.js';
 export * from './materials.js';
 export * from './constants.js';
+export * from './backends/backend.js';
+export * from './shaders/shader.js';
 export { vec2, vec3, vec4, mat3, mat4, quat } from 'wgpu-matrix';

package/dist/internalUtils.d.ts

@@ -1,5 +1,5 @@
 import { Mat4, Vector3 } from './types.js';
-import { Shader } from './shaders.js';
+import { SimJSWebGPUShader } from './shaders/webgpu.js';
 import { SimulationElement3d } from './graphics.js';
 export declare class Float32ArrayCache {
     private vertices;
@@ -32,7 +32,7 @@ export declare function triangulateWireFrameOrder(len: number): number[];
 export declare function getVertexAndIndexSize(scene: SimulationElement3d[]): readonly [number, number];
 export declare function internalTransitionValues(onFrame: (deltaT: number, t: number, total: number) => void, adjustment: () => void, transitionLength: number, func?: (n: number) => number): Promise<void>;
 export declare function posTo2dScreen(pos: Vector3): Vector3;
-export declare function createPipeline(device: GPUDevice, info: string, shader: Shader): GPURenderPipeline;
+export declare function createPipeline(device: GPUDevice, info: string, shader: SimJSWebGPUShader): GPURenderPipeline;
 export declare function addToScene(scene: SimulationElement3d[], el: SimulationElement3d, id?: string): void;
 export declare function removeSceneObj(scene: SimulationElement3d[], el: SimulationElement3d): void;
 export declare function removeSceneId(scene: SimulationElement3d[], id: string): void;

package/dist/internalUtils.js

@@ -88,7 +88,7 @@ export const buildMultisampleTexture = (device, ctx, width, height) => {
         sampleCount: 4
     });
 };
-// optomized for speed, depending on orientation of vertices as input, shape may not be preserved
+// optimized for speed, depending on orientation of vertices as input, shape may not be preserved
 export function lossyTriangulate(vertices) {
     const res = [];
     let facingRight = true;
@@ -236,6 +236,7 @@ export function addToScene(scene, el, id) {
 export function removeSceneObj(scene, el) {
     for (let i = 0; i < scene.length; i++) {
         if (scene[i] === el) {
+            scene[i].delete();
             scene.splice(i, 1);
             break;
         }
@@ -244,6 +245,7 @@ export function removeSceneObj(scene, el) {
 export function removeSceneId(scene, id) {
     for (let i = 0; i < scene.length; i++) {
         if (scene[i].getId() === id) {
+            scene[i].delete();
             scene.splice(i, 1);
             break;
         }

package/dist/shaders/shader.d.ts

@@ -0,0 +1,18 @@
+import { MemoBuffer } from '../buffers/buffer.js';
+import { SimulationElement3d } from '../graphics.js';
+import { BackendType, SpecificShaderType, Vector3, VertexBufferWriter } from '../types.js';
+export declare abstract class SimJSShader {
+    protected abstract buffers: MemoBuffer[];
+    protected vertexBufferWriter: VertexBufferWriter;
+    protected compatableBackend: BackendType;
+    protected bufferLength: number;
+    constructor(conpatableBackend: BackendType, vertexBufferWriter: VertexBufferWriter);
+    abstract writeUniformBuffers(obj: SimulationElement3d): void;
+    setVertexInfo(element: SimulationElement3d, buffer: Float32Array, vertex: Vector3, vertexIndex: number, offset: number): void;
+    getCompatableBackend(): BackendType;
+    compatableWith(backendType: BackendType): boolean;
+    getBufferLength(): number;
+    as<T extends BackendType>(type: T): SpecificShaderType<T>;
+}
+export declare const defaultVertexBufferWriter: VertexBufferWriter;
+export declare const defaultVertexColorBufferWriter: VertexBufferWriter;

package/dist/shaders/shader.js

@@ -0,0 +1,63 @@
+import { logger } from '../globals.js';
+export class SimJSShader {
+    vertexBufferWriter;
+    compatableBackend;
+    bufferLength;
+    constructor(conpatableBackend, vertexBufferWriter) {
+        this.bufferLength = 0;
+        this.vertexBufferWriter = vertexBufferWriter;
+        this.compatableBackend = conpatableBackend;
+    }
+    setVertexInfo(element, buffer, vertex, vertexIndex, offset) {
+        this.vertexBufferWriter(element, buffer, vertex, vertexIndex, offset);
+    }
+    getCompatableBackend() {
+        return this.compatableBackend;
+    }
+    compatableWith(backendType) {
+        return this.compatableBackend === backendType;
+    }
+    // returns number of floats (4 bytes)
+    getBufferLength() {
+        return this.bufferLength;
+    }
+    as(type) {
+        if (this.compatableBackend !== type)
+            throw logger.error('Incompatible shader cast');
+        return this;
+    }
+}
+export const defaultVertexBufferWriter = (el, buffer, vertex, vertexIndex, offset) => {
+    const material = el.getMaterial();
+    const colors = material.getVertexColors();
+    const vertexColor = colors[vertexIndex] ?? el.getColor();
+    // const vertexColor = color(0, 255, 255);
+    buffer[offset] = vertex[0];
+    buffer[offset + 1] = vertex[1];
+    buffer[offset + 2] = vertex[2];
+    buffer[offset + 3] = vertexColor.r / 255;
+    buffer[offset + 4] = vertexColor.g / 255;
+    buffer[offset + 5] = vertexColor.b / 255;
+    buffer[offset + 6] = vertexColor.a;
+    // TODO possibly change uv for textures
+    buffer[offset + 7] = 0;
+    buffer[offset + 8] = 0;
+    buffer[offset + 9] = el.isInstanced ? 1 : 0;
+};
+export const defaultVertexColorBufferWriter = (el, buffer, vertex, vertexIndex, offset) => {
+    const material = el.getMaterial();
+    const colors = material.getVertexColors();
+    const vertexColor = colors[vertexIndex] ?? el.getColor();
+    // const vertexColor = color(0, 255, 255);
+    buffer[offset] = vertex[0];
+    buffer[offset + 1] = vertex[1];
+    buffer[offset + 2] = vertex[2];
+    buffer[offset + 3] = vertexColor.r / 255;
+    buffer[offset + 4] = vertexColor.g / 255;
+    buffer[offset + 5] = vertexColor.b / 255;
+    buffer[offset + 6] = vertexColor.a;
+    // TODO possibly change uv for textures
+    buffer[offset + 7] = 0;
+    buffer[offset + 8] = 0;
+    buffer[offset + 9] = el.isInstanced ? 1 : 0;
+};

package/dist/shaders/utils.d.ts

@@ -0,0 +1,33 @@
+import { BackendType } from '../types.js';
+export declare function getDefaultShaderForBackend(backendType: BackendType): import("./webgpu.js").SimJSWebGPUShader | import("./webgl.js").SimJSWebGLShader<{
+    attributeLocations: [{
+        readonly position: 3;
+    }, {
+        readonly color: 4;
+    }, {
+        readonly uv: 2;
+    }, {
+        readonly drawingInstance: 1;
+    }];
+    uniformLocations: [{
+        readonly worldProjectionMatrix: 64;
+    }, {
+        readonly modelProjectionMatrix: 64;
+    }];
+}>;
+export declare function getDefaultVertexColorShaderForBackend(backendType: BackendType): import("./webgpu.js").SimJSWebGPUShader | import("./webgl.js").SimJSWebGLShader<{
+    attributeLocations: [{
+        readonly position: 3;
+    }, {
+        readonly color: 4;
+    }, {
+        readonly uv: 2;
+    }, {
+        readonly drawingInstance: 1;
+    }];
+    uniformLocations: [{
+        readonly worldProjectionMatrix: 64;
+    }, {
+        readonly modelProjectionMatrix: 64;
+    }];
+}>;

package/dist/shaders/utils.js

@@ -0,0 +1,25 @@
+import { logger } from '../globals.js';
+import { defaultWebGLShader } from './webgl.js';
+import { defaultWebGPUShader, defaultWebGPUVertexColorShader } from './webgpu.js';
+export function getDefaultShaderForBackend(backendType) {
+    if (backendType === 'webgpu') {
+        return defaultWebGPUShader;
+    }
+    else if (backendType === 'webgl') {
+        return defaultWebGLShader;
+    }
+    else {
+        throw logger.error('Unknown backend');
+    }
+}
+export function getDefaultVertexColorShaderForBackend(backendType) {
+    if (backendType === 'webgpu') {
+        return defaultWebGPUVertexColorShader;
+    }
+    else if (backendType === 'webgl') {
+        return defaultWebGLShader;
+    }
+    else {
+        throw logger.error('Unknown backend');
+    }
+}

package/dist/shaders/webgl.d.ts

@@ -0,0 +1,74 @@
+import { WebGLMemoBuffer } from '../buffers/webgl.js';
+import { SimulationElement3d } from '../graphics.js';
+import { VertexBufferWriter, WebGLBufferDecleration } from '../types.js';
+import { SimJSShader } from './shader.js';
+type WebGLUniformBufferWriter<T> = (programInfo: T, gl: WebGL2RenderingContext, element: SimulationElement3d, buffers: WebGLMemoBuffer[]) => void;
+type ProgramInfoLayout = {
+    attributeLocations: {
+        [key: string]: number;
+    }[];
+    uniformLocations: {
+        [key: string]: number;
+    }[];
+};
+type ToTuple<T> = [keyof T, T[keyof T]];
+type ToTupleList<T> = T extends [infer First, ...infer Rest] ? [ToTuple<First>, ...ToTupleList<Rest>] : [];
+type ProgramInfoLayoutToInfo<T extends ProgramInfoLayout> = {
+    program: WebGLProgram;
+    attributeLocations: ToTupleList<T['attributeLocations']>;
+    uniformLocations: ToTupleList<T['uniformLocations']>;
+};
+export declare class SimJSWebGLShader<T extends ProgramInfoLayout> extends SimJSShader {
+    protected buffers: WebGLMemoBuffer[];
+    private shaderProgram;
+    private shaderProgramInfoLayout;
+    private shaderProgramInfo;
+    private gl;
+    private uniformBufferWriter;
+    private getShaderProgramInfoFn;
+    private vertexSource;
+    private fragmentSource;
+    private bufferDeclerations;
+    constructor(vertexSource: string, fragmentSource: string, bufferDeclerations: WebGLBufferDecleration[], uniformBufferWriter: WebGLUniformBufferWriter<ProgramInfoLayoutToInfo<T>>, vertexBufferWriter: VertexBufferWriter, getShaderProgramInfoFn: () => T);
+    init(gl: WebGL2RenderingContext): void;
+    programInfoLayoutToProgramInfo(program: WebGLProgram, gl: WebGL2RenderingContext, layout: T): ProgramInfoLayoutToInfo<T>;
+    private initShaderProgram;
+    private loadShader;
+    getShaderProgram(): WebGLProgram;
+    getShaderProgramInfo(): ProgramInfoLayoutToInfo<T>;
+    writeUniformBuffers(obj: SimulationElement3d): void;
+    writeShaderProgramAttributes(buffer: WebGLMemoBuffer, vertexCallOffset: number, vertexCallBuffer: Float32Array): void;
+}
+export declare const defaultWebGLShader: SimJSWebGLShader<{
+    attributeLocations: [{
+        readonly position: 3;
+    }, {
+        readonly color: 4;
+    }, {
+        readonly uv: 2;
+    }, {
+        readonly drawingInstance: 1;
+    }];
+    uniformLocations: [{
+        readonly worldProjectionMatrix: 64;
+    }, {
+        readonly modelProjectionMatrix: 64;
+    }];
+}>;
+export declare const defaultWebGLVertexColorShader: SimJSWebGLShader<{
+    attributeLocations: [{
+        readonly position: 3;
+    }, {
+        readonly color: 4;
+    }, {
+        readonly uv: 2;
+    }, {
+        readonly drawingInstance: 1;
+    }];
+    uniformLocations: [{
+        readonly worldProjectionMatrix: 64;
+    }, {
+        readonly modelProjectionMatrix: 64;
+    }];
+}>;
+export {};

package/dist/shaders/webgl.js

@@ -0,0 +1,242 @@
+import { WebGLMemoBuffer } from '../buffers/webgl.js';
+import { FLOAT_SIZE, mat4ByteLength } from '../constants.js';
+import { globalInfo, logger } from '../globals.js';
+import { orthogonalMatrix, worldProjectionMatrix } from '../simulation.js';
+import { defaultVertexBufferWriter, defaultVertexColorBufferWriter, SimJSShader } from './shader.js';
+export class SimJSWebGLShader extends SimJSShader {
+    buffers;
+    shaderProgram = null;
+    shaderProgramInfoLayout = null;
+    shaderProgramInfo = null;
+    gl = null;
+    uniformBufferWriter;
+    getShaderProgramInfoFn;
+    vertexSource;
+    fragmentSource;
+    bufferDeclerations;
+    constructor(vertexSource, fragmentSource, bufferDeclerations, uniformBufferWriter, vertexBufferWriter, getShaderProgramInfoFn) {
+        super('webgl', vertexBufferWriter);
+        this.buffers = [];
+        this.vertexSource = vertexSource;
+        this.fragmentSource = fragmentSource;
+        this.uniformBufferWriter = uniformBufferWriter;
+        this.getShaderProgramInfoFn = getShaderProgramInfoFn;
+        this.bufferDeclerations = bufferDeclerations;
+        const canvas = globalInfo.getCanvas();
+        if (!canvas) {
+            globalInfo.addToInitShader(this);
+            return;
+        }
+        const backend = canvas.getBackend().as('webgl');
+        this.init(backend.getContextOrError());
+    }
+    init(gl) {
+        this.gl = gl;
+        this.shaderProgram = this.initShaderProgram(gl, this.vertexSource, this.fragmentSource);
+        this.shaderProgramInfoLayout = this.getShaderProgramInfoFn();
+        this.shaderProgramInfo = this.programInfoLayoutToProgramInfo(this.shaderProgram, gl, this.shaderProgramInfoLayout);
+        for (const dec of this.bufferDeclerations) {
+            const buf = new WebGLMemoBuffer(this.gl, dec.target, dec.usage, dec.defaultCapacity ?? 0);
+            this.buffers.push(buf);
+        }
+    }
+    programInfoLayoutToProgramInfo(program, gl, layout) {
+        const res = {
+            program: program,
+            // @ts-ignore
+            attributeLocations: [],
+            // @ts-ignore
+            uniformLocations: []
+        };
+        let bufferLength = 0;
+        for (const obj of layout.attributeLocations) {
+            const key = Object.keys(obj)[0];
+            const size = obj[key];
+            const loc = gl.getAttribLocation(program, key);
+            const tuple = [key, loc];
+            // @ts-ignore
+            res.attributeLocations.push(tuple);
+            bufferLength += size;
+        }
+        this.bufferLength = bufferLength;
+        for (const obj of layout.uniformLocations) {
+            const key = Object.keys(obj)[0];
+            const loc = gl.getUniformLocation(program, key);
+            const tuple = [key, loc];
+            // @ts-ignore
+            res.uniformLocations.push(tuple);
+        }
+        return res;
+    }
+    initShaderProgram(gl, vertexShaderSource, fragmentShaderSource) {
+        const vertexShader = this.loadShader(gl, gl.VERTEX_SHADER, vertexShaderSource);
+        const fragmentShader = this.loadShader(gl, gl.FRAGMENT_SHADER, fragmentShaderSource);
+        const shaderProgram = gl.createProgram();
+        if (!shaderProgram)
+            throw logger.error('Shader program init error');
+        gl.attachShader(shaderProgram, vertexShader);
+        gl.attachShader(shaderProgram, fragmentShader);
+        gl.linkProgram(shaderProgram);
+        if (!gl.getProgramParameter(shaderProgram, gl.LINK_STATUS)) {
+            throw logger.error('Error initializing shader program');
+        }
+        return shaderProgram;
+    }
+    loadShader(ctx, shaderType, code) {
+        const shader = ctx.createShader(shaderType);
+        if (!shader)
+            throw logger.error('Error creating shader');
+        ctx.shaderSource(shader, code);
+        ctx.compileShader(shader);
+        if (!ctx.getShaderParameter(shader, ctx.COMPILE_STATUS)) {
+            const err = logger.error(`Error compiling shaders: ${ctx.getShaderInfoLog(shader)}`);
+            ctx.deleteShader(shader);
+            throw err;
+        }
+        return shader;
+    }
+    getShaderProgram() {
+        if (!this.shaderProgram)
+            throw logger.error('Shader program not initialized');
+        return this.shaderProgram;
+    }
+    getShaderProgramInfo() {
+        if (!this.shaderProgramInfo)
+            throw logger.error('Shader program not initialized');
+        return this.shaderProgramInfo;
+    }
+    writeUniformBuffers(obj) {
+        if (!this.gl || !this.shaderProgramInfo)
+            throw logger.error('Shader not initialized');
+        this.uniformBufferWriter(this.shaderProgramInfo, this.gl, obj, this.buffers);
+    }
+    writeShaderProgramAttributes(buffer, vertexCallOffset, vertexCallBuffer) {
+        if (!this.gl || !this.shaderProgramInfoLayout || !this.shaderProgramInfo) {
+            throw logger.error('Shader not initialized');
+        }
+        const gl = this.gl;
+        buffer.write(vertexCallBuffer, vertexCallOffset);
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer.getBuffer());
+        const STRIDE = this.bufferLength * FLOAT_SIZE;
+        let localOffset = 0;
+        for (let i = 0; i < this.shaderProgramInfo.attributeLocations.length; i++) {
+            const [key, loc] = this.shaderProgramInfo.attributeLocations[i];
+            const size = this.shaderProgramInfoLayout.attributeLocations[i][key];
+            gl.enableVertexAttribArray(loc);
+            gl.vertexAttribPointer(loc, size, gl.FLOAT, false, STRIDE, vertexCallOffset + localOffset);
+            localOffset += size * FLOAT_SIZE;
+        }
+    }
+}
+function defaultWebGLUniformBufferWriter(programInfo, gl, obj, _buffers) {
+    const projBuf = obj.is3d ? worldProjectionMatrix : orthogonalMatrix;
+    let buffer = obj.getUniformBuffer();
+    if (!buffer) {
+        buffer = new WebGLMemoBuffer(gl, gl.ARRAY_BUFFER, gl.DYNAMIC_DRAW, WEBGL_DEFAULT_SHADER_UNIFORM_BUFFER_SIZE);
+        obj.setUniformBuffer(buffer);
+    }
+    else {
+        buffer.as('webgl');
+    }
+    gl.uniformMatrix4fv(programInfo.uniformLocations[0][1], false, projBuf);
+    const modelMatrix = obj.getModelMatrix();
+    gl.uniformMatrix4fv(programInfo.uniformLocations[1][1], false, modelMatrix);
+    // gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    // if (obj.isInstance) {
+    //     buffers[0].write((obj as Instance<SimulationElement3d>).getInstanceBuffer());
+    // }
+    // gl.bindBuffer(gl.ARRAY_BUFFER, buffers[0].getBuffer());
+    // const mat4BaseLoc = programInfo.attributeLocations.instanceMatrix;
+    // const mat4Stride = 64;
+    // for (let i = 0; i < 4; i++) {
+    //     const loc = mat4BaseLoc + i;
+    //     const offset = i * 4 * FLOAT_SIZE;
+    //     gl.enableVertexAttribArray(loc);
+    //     gl.vertexAttribPointer(loc, 4, gl.FLOAT, false, mat4Stride, offset);
+    //     gl.vertexAttribDivisor(loc, 1);
+    // }
+    // gl.bindBuffer(gl.ARRAY_BUFFER, null);
+}
+const defaultWebGLVertexShader = `#version 300 es
+
+// uniforms
+uniform mat4 worldProjectionMatrix;
+uniform mat4 modelProjectionMatrix;
+
+// attributes
+layout(location = 0) in vec3 position;
+layout(location = 1) in vec4 color;
+layout(location = 2) in vec2 uv;
+layout(location = 3) in float drawingInstance;
+
+// consumes locations 4, 5, 6, 7
+//layout(location = 4) in mat4 instanceMatrix; 
+
+out vec2 vFragUV;
+out vec4 vFragColor;
+out vec4 vFragPosition;
+
+void main() {
+    vec4 finalPosition;
+    vec4 posInput = vec4(position, 1.0);
+
+    if (drawingInstance == 1.0) {
+        //finalPosition = worldProjectionMatrix * modelProjectionMatrix * instanceMatrix * posInput;
+        finalPosition = worldProjectionMatrix * modelProjectionMatrix * posInput;
+    } else {
+        finalPosition = worldProjectionMatrix * modelProjectionMatrix * posInput;
+    }
+
+    gl_Position = finalPosition;
+
+    vFragUV = uv;
+    vFragColor = color;
+    vFragPosition = finalPosition;
+}
+`;
+const defaultWebGLFragmentShader = `#version 300 es
+precision mediump float;
+
+in vec2 vFragUV;
+in vec4 vFragColor;
+in vec4 vFragPosition;
+
+layout(location = 0) out vec4 outColor;
+
+void main() {
+    outColor = vFragColor;
+}
+`;
+const WEBGL_DEFAULT_SHADER_UNIFORM_BUFFER_SIZE = mat4ByteLength * 2;
+export const defaultWebGLShader = new SimJSWebGLShader(defaultWebGLVertexShader, defaultWebGLFragmentShader, [
+// {
+//     target: WebGL2RenderingContext.ARRAY_BUFFER,
+//     usage: WebGL2RenderingContext.DYNAMIC_DRAW,
+//     defaultCapacity: 64
+// }
+], defaultWebGLUniformBufferWriter, defaultVertexBufferWriter, () => ({
+    attributeLocations: [
+        { position: 3 },
+        { color: 4 },
+        { uv: 2 },
+        { drawingInstance: 1 }
+        // instanceMatrix: 16
+    ],
+    uniformLocations: [{ worldProjectionMatrix: 64 }, { modelProjectionMatrix: 64 }]
+}));
+export const defaultWebGLVertexColorShader = new SimJSWebGLShader(defaultWebGLVertexShader, defaultWebGLFragmentShader, [
+// {
+//     target: WebGL2RenderingContext.ARRAY_BUFFER,
+//     usage: WebGL2RenderingContext.DYNAMIC_DRAW,
+//     defaultCapacity: 64
+// }
+], defaultWebGLUniformBufferWriter, defaultVertexColorBufferWriter, () => ({
+    attributeLocations: [
+        { position: 3 },
+        { color: 4 },
+        { uv: 2 },
+        { drawingInstance: 1 }
+        // instanceMatrix: 16
+    ],
+    uniformLocations: [{ worldProjectionMatrix: 64 }, { modelProjectionMatrix: 64 }]
+}));

package/dist/shaders/webgpu.d.ts

@@ -0,0 +1,40 @@
+import { WebGPUMemoBuffer } from '../buffers/webgpu.js';
+import { SimulationElement3d } from '../graphics.js';
+import { WebGPUBufferDecleration, Vector3, VertexBufferWriter, VertexParamInfo } from '../types.js';
+import { SimJSShader } from './shader.js';
+export declare const WEBGPU_DEFAULT_SHADER_UNIFORM_BUFFER_SIZE: number;
+type WebGPUUniformBufferWriter = (device: GPUDevice, element: SimulationElement3d, buffers: WebGPUMemoBuffer[]) => void;
+type WebGPUBindGroupGenerator = (device: GPUDevice, element: SimulationElement3d, buffers: WebGPUMemoBuffer[]) => GPUBindGroup[];
+export declare class SimJSWebGPUShader extends SimJSShader {
+    protected buffers: WebGPUMemoBuffer[];
+    private bindGroupLayoutDescriptors;
+    private bindGroupLayouts;
+    private module;
+    private code;
+    private fragmentMain;
+    private vertexMain;
+    private vertexBuffers;
+    private uniformBufferWriter;
+    private bindGroupGenerator;
+    private bufferDeclerations;
+    private device;
+    constructor(code: string, descriptors: GPUBindGroupLayoutDescriptor[], vertexParams: VertexParamInfo[], bufferDeclerations: WebGPUBufferDecleration[], uniformBufferWriter: WebGPUUniformBufferWriter, bindGroupGenerator: WebGPUBindGroupGenerator, vertexBufferWriter: VertexBufferWriter, vertexMain?: string, fragmentMain?: string);
+    init(device: GPUDevice): void;
+    getCode(): string;
+    getVertexBuffers(): GPUVertexBufferLayout;
+    getBindGroupLayouts(): GPUBindGroupLayout[];
+    getBindGroupLayoutDescriptors(): GPUBindGroupLayoutDescriptor[];
+    getBufferInfo(): WebGPUBufferDecleration[];
+    getUniformBufferWriter(): WebGPUUniformBufferWriter;
+    getVertexBufferWriter(): VertexBufferWriter;
+    getBindGroupGenerator(): WebGPUBindGroupGenerator;
+    getModule(): GPUShaderModule;
+    getVertexMain(): string;
+    getFragmentMain(): string;
+    setVertexInfo(element: SimulationElement3d, buffer: Float32Array, vertex: Vector3, vertexIndex: number, offset: number): void;
+    writeUniformBuffers(el: SimulationElement3d): void;
+    getBindGroups(device: GPUDevice, el: SimulationElement3d): GPUBindGroup[];
+}
+export declare const defaultWebGPUShader: SimJSWebGPUShader;
+export declare const defaultWebGPUVertexColorShader: SimJSWebGPUShader;
+export {};