174 lines
5.3 KiB
JavaScript
174 lines
5.3 KiB
JavaScript
// Minimal WebGL-based fluid simulation
|
|
// Based on GPU Gems approach: Stam's stable fluids on GPU
|
|
|
|
(function() {
|
|
const canvas = document.querySelector('canvas') || (() => {
|
|
const c = document.createElement('canvas');
|
|
document.body.appendChild(c);
|
|
return c;
|
|
})();
|
|
|
|
const gl = canvas.getContext('webgl2');
|
|
if (!gl) return console.error('WebGL2 not available');
|
|
|
|
canvas.width = window.innerWidth;
|
|
canvas.height = window.innerHeight;
|
|
gl.viewport(0, 0, canvas.width, canvas.height);
|
|
|
|
let time = 0;
|
|
const dt = 0.016; // 60fps
|
|
|
|
// Particle-based fluid: velocity grid + density grid
|
|
const gridW = 64, gridH = 64;
|
|
|
|
// Create float textures for velocity and density
|
|
const ext = gl.getExtension('EXT_color_buffer_float');
|
|
const createTexture = () => {
|
|
const tex = gl.createTexture();
|
|
gl.bindTexture(gl.TEXTURE_2D, tex);
|
|
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA32F, gridW, gridH, 0, gl.RGBA, gl.FLOAT, null);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT);
|
|
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT);
|
|
return tex;
|
|
};
|
|
|
|
const velTex = [createTexture(), createTexture()];
|
|
const denTex = [createTexture(), createTexture()];
|
|
let velIdx = 0, denIdx = 0;
|
|
|
|
// Framebuffer for offscreen rendering
|
|
const fbo = gl.createFramebuffer();
|
|
|
|
// Advection shader
|
|
const advectShader = compileShader(gl, `#version 300 es
|
|
precision highp float;
|
|
in vec2 uv;
|
|
out vec4 outColor;
|
|
uniform sampler2D field;
|
|
uniform sampler2D vel;
|
|
uniform float dt;
|
|
uniform vec2 gridSize;
|
|
|
|
void main() {
|
|
vec2 coord = uv - dt * texture(vel, uv).xy * gridSize;
|
|
outColor = texture(field, fract(coord));
|
|
}
|
|
`, gl.FRAGMENT_SHADER);
|
|
|
|
// Divergence shader
|
|
const divShader = compileShader(gl, `#version 300 es
|
|
precision highp float;
|
|
in vec2 uv;
|
|
out vec4 outColor;
|
|
uniform sampler2D vel;
|
|
uniform vec2 gridSize;
|
|
|
|
void main() {
|
|
vec2 texel = 1.0 / gridSize;
|
|
float left = texture(vel, uv - vec2(texel.x, 0)).x;
|
|
float right = texture(vel, uv + vec2(texel.x, 0)).x;
|
|
float down = texture(vel, uv - vec2(0, texel.y)).y;
|
|
float up = texture(vel, uv + vec2(0, texel.y)).y;
|
|
outColor = vec4((right - left + up - down) * 0.5, 0, 0, 0);
|
|
}
|
|
`, gl.FRAGMENT_SHADER);
|
|
|
|
// Display shader
|
|
const displayShader = compileShader(gl, `#version 300 es
|
|
precision highp float;
|
|
in vec2 uv;
|
|
out vec4 outColor;
|
|
uniform sampler2D density;
|
|
|
|
void main() {
|
|
vec4 den = texture(density, uv);
|
|
outColor = vec4(den.r * 2.0, den.g * 1.5, den.b * 0.8, 1.0);
|
|
}
|
|
`, gl.FRAGMENT_SHADER);
|
|
|
|
const quadVao = createQuadVao(gl);
|
|
|
|
function render() {
|
|
time += dt;
|
|
|
|
// Add source (force input)
|
|
const mx = (Math.sin(time) * 0.3 + 0.5);
|
|
const my = (Math.cos(time * 0.7) * 0.3 + 0.5);
|
|
addSource(gl, denTex[denIdx], mx, my, 0.1);
|
|
|
|
// Advect density
|
|
denIdx = 1 - denIdx;
|
|
renderToTexture(gl, fbo, denTex[denIdx], advectShader, denTex[1-denIdx], velTex[velIdx]);
|
|
|
|
// Advect velocity
|
|
velIdx = 1 - velIdx;
|
|
renderToTexture(gl, fbo, velTex[velIdx], advectShader, velTex[1-velIdx], velTex[1-velIdx]);
|
|
|
|
// Apply forces (vorticity, gravity)
|
|
applyForces(gl, fbo, velTex[velIdx], time);
|
|
|
|
// Display
|
|
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
|
|
gl.viewport(0, 0, canvas.width, canvas.height);
|
|
gl.useProgram(displayShader.program);
|
|
gl.bindTexture(gl.TEXTURE_2D, denTex[denIdx]);
|
|
gl.uniform1i(gl.getUniformLocation(displayShader.program, 'density'), 0);
|
|
gl.bindVertexArray(quadVao);
|
|
gl.drawArrays(gl.TRIANGLES, 0, 6);
|
|
|
|
requestAnimationFrame(render);
|
|
}
|
|
|
|
render();
|
|
|
|
function compileShader(gl, src, type) {
|
|
const shader = gl.createShader(type);
|
|
gl.shaderSource(shader, src);
|
|
gl.compileShader(shader);
|
|
if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
|
|
console.error(gl.getShaderInfoLog(shader));
|
|
}
|
|
return shader;
|
|
}
|
|
|
|
function createProgram(gl, vertSrc, fragSrc) {
|
|
const vert = compileShader(gl, vertSrc, gl.VERTEX_SHADER);
|
|
const frag = compileShader(gl, fragSrc, gl.FRAGMENT_SHADER);
|
|
const prog = gl.createProgram();
|
|
gl.attachShader(prog, vert);
|
|
gl.attachShader(prog, frag);
|
|
gl.linkProgram(prog);
|
|
return { program: prog, vert, frag };
|
|
}
|
|
|
|
function createQuadVao(gl) {
|
|
const vao = gl.createVertexArray();
|
|
gl.bindVertexArray(vao);
|
|
const positions = new Float32Array([-1, -1, 1, -1, -1, 1, 1, -1, 1, 1, -1, 1]);
|
|
const buf = gl.createBuffer();
|
|
gl.bindBuffer(gl.ARRAY_BUFFER, buf);
|
|
gl.bufferData(gl.ARRAY_BUFFER, positions, gl.STATIC_DRAW);
|
|
gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
|
|
gl.enableVertexAttribArray(0);
|
|
return vao;
|
|
}
|
|
|
|
function renderToTexture(gl, fbo, target, shader, field, vel) {
|
|
gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
|
|
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, target, 0);
|
|
gl.viewport(0, 0, gridW, gridH);
|
|
gl.useProgram(shader);
|
|
// ... bind uniforms and draw
|
|
}
|
|
|
|
function addSource(gl, tex, x, y, amount) {
|
|
// Add dye at (x, y)
|
|
}
|
|
|
|
function applyForces(gl, fbo, velTex, time) {
|
|
// Apply vorticity confinement, buoyancy
|
|
}
|
|
})();
|