Compute Shader
WARNING
WebGPU Only
ts
import {
bufferField,
bufferLayout,
bufferRecorder,
BufferUsage,
Color,
createDevice,
Device,
FrameContext,
PlatformId,
shaderConstants,
WebGpuDevice,
} from '@gglib/graphics'
import { lerp } from '@gglib/math'
const WORKGROUP_SIZE = 64
export default async (canvas: HTMLCanvasElement, tools: HTMLElement, platform: PlatformId) => {
const device: Device = await createDevice({ canvas, platform, autosize: true }).ready
const shader = device.createShaderModule({
wgsl: { source: wgslRender },
glsl: null!, // not supported
})
const compute = device.createShaderModule({
wgsl: {
source: wgslCompute,
computeConstants: shaderConstants({ WORKGROUP_SIZE }),
},
glsl: null!, // not supported
})
const numBodies = 4096
// prettier-ignore
const layout = bufferLayout([
bufferField('position', 'vec2f'),
bufferField('velocity', 'vec2f'),
])
let verticesIn = device.createVertexBuffer([
{
size: numBodies * layout.byteSize,
usage: BufferUsage.STORAGE | BufferUsage.VERTEX,
layout: layout.vertex,
},
])
let verticesOut = device.createVertexBuffer([
{
size: numBodies * layout.byteSize,
usage: BufferUsage.STORAGE | BufferUsage.VERTEX,
layout: layout.vertex,
},
])
const writer = bufferRecorder({
capacity: numBodies,
recordByteSize: layout.byteSize,
})
for (let i = 0; i < numBodies; i++) {
writer.seek(i)
const r = lerp(0.1, 0.9, Math.random())
const a = Math.random() * Math.PI * 2
const x = Math.cos(a) * r
const y = Math.sin(a) * r * 0.6
const speed = Math.sqrt(1.0 / (r + 0.05)) * 0.18
writer.writeFloat32x2(x, y)
writer.writeFloat32x2(-Math.sin(a) * speed, Math.cos(a) * speed * 0.6)
}
writer.upload(verticesIn.buffers[0])
function computeFrame(ctx: FrameContext) {
const pass = (device as WebGpuDevice).computePass
if (!compute.isValid) {
return
}
compute.program.mustSet('params.dt', ctx.delta)
compute.program.mustSet('params.count', numBodies)
compute.program.mustGet('bodiesIn').setBuffer(verticesIn.buffers[0])
compute.program.mustGet('bodiesOut').setBuffer(verticesOut.buffers[0])
compute.program.commit()
pass.setProgram(compute.program)
pass.dispatch(Math.ceil(numBodies / WORKGROUP_SIZE))
pass.submit()
pass.flush()
}
function renderFrame(ctx: FrameContext) {
const pass = device.renderPass
pass.setClearColor(0, Color.Black)
pass.clear()
if (!shader.isValid) {
return
}
pass.setPrimitiveType('point-list')
pass.setVertexBuffer(verticesOut)
pass.setProgram(shader.program)
pass.draw(numBodies)
pass.flush()
}
function frame(ctx: FrameContext) {
if (!compute.isValid) {
return
}
computeFrame(ctx)
renderFrame(ctx)
;[verticesIn, verticesOut] = [verticesOut, verticesIn]
}
device.schedule(frame)
return () => {
device.dispose()
}
}
const wgslCompute = /* wgsl */ `
override WORKGROUP_SIZE: u32 = 64;
struct Body {
pos: vec2f,
vel: vec2f
};
struct Params {
dt: f32,
count: u32
};
@group(0) @binding(0) var<storage, read> bodiesIn: array<Body>;
@group(0) @binding(1) var<storage, read_write> bodiesOut: array<Body>;
@group(0) @binding(2) var<uniform> params: Params;
const G: f32 = 0.00004;
const SOFTEN: f32 = 0.2;
@compute @workgroup_size(WORKGROUP_SIZE)
fn main(@builtin(global_invocation_id) id: vec3u) {
let i = id.x;
if (i >= params.count) {
return;
}
let body = bodiesIn[i];
var acc = vec2f(0.0, 0.0);
for (var j: u32 = 0u; j < params.count; j = j + 1u) {
if (j == i) {
continue;
}
let other = bodiesIn[j];
let d = other.pos - body.pos;
let distSq = dot(d, d) + SOFTEN * SOFTEN;
let invDist = inverseSqrt(distSq);
acc = acc + d * (G * invDist * invDist * invDist);
}
var vel = (body.vel + acc * params.dt) * 0.9999;
let pos = body.pos + vel * params.dt;
bodiesOut[i] = Body(pos, vel);
}
`
const wgslRender = /* wgsl */ `
struct VertexInput {
@location(0) position: vec2f,
@location(1) velocity: vec2f
}
struct FragmentInput {
@builtin(position) position: vec4f,
@location(0) speed: f32
}
@vertex
fn vs(in: VertexInput) -> FragmentInput {
var out: FragmentInput;
out.position = vec4f(in.position, 0.0, 1.0);
out.speed = length(in.velocity);
return out;
}
@fragment
fn fs(in: FragmentInput) -> @location(0) vec4f {
let s = clamp(in.speed * 6.0, 0.0, 1.0);
return vec4f(1.0, s, s * 0.3, 1.0);
}
`