@plasius/gpu-world-generator 0.0.4

package/src/shaders/demo-trees.wgsl

@@ -0,0 +1,172 @@
+struct TreeUniforms {
+  viewProj: mat4x4<f32>,
+  cameraPos: vec4<f32>,
+  cameraRight: vec4<f32>,
+  cameraUp: vec4<f32>,
+  season: vec4<f32>,
+  wind: vec4<f32>,
+};
+
+struct TreeInstance {
+  posHeight: vec4<f32>,
+  canopySeed: vec4<f32>,
+};
+
+struct VSOut {
+  @builtin(position) position: vec4<f32>,
+  @location(0) uv: vec2<f32>,
+  @location(1) baseColor: vec3<f32>,
+  @location(2) trunkColor: vec3<f32>,
+  @location(3) height: f32,
+  @location(4) leafiness: f32,
+  @location(5) deciduous: f32,
+  @location(6) lod: f32,
+  @location(7) worldPos: vec3<f32>,
+  @location(8) seed: f32,
+};
+
+@group(0) @binding(0) var<uniform> scene: TreeUniforms;
+@group(0) @binding(1) var<storage, read> trees: array<TreeInstance>;
+
+fn quad_uv(vid: u32) -> vec2<f32> {
+  let uv = array<vec2<f32>, 6>(
+    vec2<f32>(0.0, 0.0),
+    vec2<f32>(1.0, 0.0),
+    vec2<f32>(1.0, 1.0),
+    vec2<f32>(0.0, 0.0),
+    vec2<f32>(1.0, 1.0),
+    vec2<f32>(0.0, 1.0)
+  );
+  return uv[vid];
+}
+
+fn mandelbrot(c: vec2<f32>, iterations: u32) -> f32 {
+  var z = vec2<f32>(0.0);
+  var i: u32 = 0u;
+  loop {
+    if (i >= iterations) {
+      break;
+    }
+    let x = z.x * z.x - z.y * z.y + c.x;
+    let y = 2.0 * z.x * z.y + c.y;
+    z = vec2<f32>(x, y);
+    if (dot(z, z) > 4.0) {
+      break;
+    }
+    i = i + 1u;
+  }
+  return f32(i) / f32(iterations);
+}
+
+@vertex
+fn vs_main(@builtin(vertex_index) vid: u32, @builtin(instance_index) iid: u32) -> VSOut {
+  let data = trees[iid];
+  let pos = data.posHeight.xyz;
+  let height = data.posHeight.w;
+  let canopy = data.canopySeed.x;
+  let seed = data.canopySeed.y;
+  let deciduous = data.canopySeed.z;
+  let leafiness = data.canopySeed.w;
+
+  let quadIndex = vid / 6u;
+  let localVid = vid % 6u;
+  let uv = quad_uv(localVid);
+  let right = scene.cameraRight.xyz;
+  let up = scene.cameraUp.xyz;
+  let forward = normalize(cross(right, up));
+  let diag = normalize(right + forward);
+  let anti = normalize(right - forward);
+  var basis = right;
+  if (quadIndex == 1u) {
+    basis = forward;
+  } else if (quadIndex == 2u) {
+    basis = diag;
+  } else if (quadIndex == 3u) {
+    basis = anti;
+  }
+
+  let dist = length(scene.cameraPos.xyz - pos);
+  let lod = clamp((dist - 6.0) / 20.0, 0.0, 1.0);
+  let lodScale = mix(1.0, 0.6, lod);
+
+  let partIndex = quadIndex / 4u;
+  var localY = uv.y;
+  if (partIndex == 0u) {
+    localY = uv.y * 0.55;
+  } else if (partIndex == 1u) {
+    localY = 0.5 + uv.y * 0.45;
+  } else {
+    localY = 0.78 + uv.y * 0.35;
+  }
+  let canopyScale = mix(0.5, 1.0, f32(partIndex) / 2.0);
+
+  var out: VSOut;
+  let basePos = pos + basis * (uv.x - 0.5) * canopy * 1.2 * canopyScale * lodScale + up * (localY) * height * lodScale;
+  let windDir = normalize(scene.wind.xyz);
+  let time = scene.wind.w;
+  let windStrength = scene.season.y;
+  let gustiness = scene.season.z;
+  let heightFactor = clamp(localY, 0.0, 1.0);
+  let swayBase = smoothstep(0.15, 0.95, heightFactor);
+  let sway = sin(time * (0.6 + gustiness) + seed * 6.1 + uv.y * 2.1) * windStrength * swayBase;
+  let flutter = sin(time * 1.7 + seed * 3.3 + uv.x * 6.0) * windStrength * 0.2 * leafiness;
+  let windOffset = windDir * (sway + flutter) * (1.0 - lod * 0.6);
+  let worldPos = basePos + windOffset;
+  out.position = scene.viewProj * vec4<f32>(worldPos, 1.0);
+  out.uv = uv;
+  out.baseColor = vec3<f32>(0.18, 0.48, 0.2);
+  out.trunkColor = vec3<f32>(0.25, 0.16, 0.08);
+  out.height = height;
+  out.leafiness = leafiness;
+  out.deciduous = deciduous;
+  out.lod = lod;
+  out.worldPos = worldPos;
+  out.seed = seed;
+  return out;
+}
+
+@fragment
+fn fs_main(input: VSOut) -> @location(0) vec4<f32> {
+  let uv = input.uv;
+  let trunkHeight = 0.42;
+  let trunkWidth = mix(0.18, 0.08, uv.y / trunkHeight);
+  let centerX = abs(uv.x - 0.5);
+
+  if (uv.y <= trunkHeight && centerX < trunkWidth) {
+    return vec4<f32>(input.trunkColor, 1.0);
+  }
+
+  if (uv.y > trunkHeight && uv.y < 0.7) {
+    let branchWave = sin((uv.y + input.seed * 1.7) * 12.0) * 0.5 + 0.5;
+    let branchOffset = (branchWave - 0.5) * 0.35;
+    let branchWidth = mix(0.12, 0.04, uv.y);
+    if (abs(uv.x - (0.5 + branchOffset)) < branchWidth) {
+      return vec4<f32>(input.trunkColor * 0.9, 1.0);
+    }
+  }
+
+  let canopyCenter = vec2<f32>(0.5, 0.7);
+  let rel = uv - canopyCenter;
+  let radius = length(rel);
+
+  let iterCount = u32(round(mix(20.0, 6.0, input.lod)));
+  let c = rel * 2.2 + vec2<f32>(input.seed * 0.35, input.seed * -0.22);
+  let fract = mandelbrot(c, iterCount);
+  let leafMask = smoothstep(0.85, 0.35, radius + fract * 0.2);
+
+  let season = scene.season.x;
+  var leafAlpha = leafMask * input.leafiness * mix(1.0, 0.6, input.lod);
+  if (input.deciduous > 0.5) {
+    leafAlpha = leafAlpha * mix(1.0, 0.35, season);
+  }
+
+  if (leafAlpha < 0.02) {
+    discard;
+  }
+
+  let summer = vec3<f32>(0.2, 0.55, 0.24);
+  let autumn = vec3<f32>(0.72, 0.38, 0.18);
+  let leafColor = mix(summer, autumn, season * input.deciduous);
+
+  return vec4<f32>(leafColor, leafAlpha);
+}

package/src/shaders/demo-water-sim.wgsl

@@ -0,0 +1,361 @@
+struct SimParams {
+  sim0: vec4<f32>, // origin.x, origin.z, invSize, gridSize
+  sim1: vec4<f32>, // dt, flipRatio, particleCount, pad
+  sim2: vec4<f32>, // velScale, weightScale, heightScale, densityScale
+  sim3: vec4<f32>, // damping, bounce, pad, pad
+};
+
+struct GridAccum {
+  velX: atomic<i32>,
+  velY: atomic<i32>,
+  weight: atomic<i32>,
+  pad: atomic<i32>,
+};
+
+@group(0) @binding(0) var<uniform> params: SimParams;
+@group(0) @binding(1) var<storage, read_write> particles: array<vec4<f32>>;
+@group(0) @binding(2) var<storage, read_write> gridAccum: array<GridAccum>;
+@group(0) @binding(3) var<storage, read_write> gridVel: array<vec2<f32>>;
+@group(0) @binding(4) var<storage, read_write> gridVelPrev: array<vec2<f32>>;
+@group(0) @binding(5) var<storage, read_write> gridDivergence: array<f32>;
+@group(0) @binding(6) var<storage, read_write> gridPressure: array<f32>;
+@group(0) @binding(7) var<storage, read_write> gridPressurePrev: array<f32>;
+@group(0) @binding(8) var<storage, read_write> gridHeight: array<f32>;
+
+fn grid_size() -> i32 {
+  return i32(params.sim0.w);
+}
+
+fn grid_count() -> i32 {
+  let size = grid_size();
+  return size * size;
+}
+
+fn grid_index(ix: i32, iy: i32, size: i32) -> i32 {
+  return iy * size + ix;
+}
+
+fn clamp_cell(ix: i32, size: i32) -> i32 {
+  return clamp(ix, 0, size - 1);
+}
+
+fn sample_grid_vel_current(uv: vec2<f32>) -> vec2<f32> {
+  let size = grid_size();
+  let grid_max = f32(size - 1);
+  let gx = uv.x * grid_max;
+  let gy = uv.y * grid_max;
+  let ix = i32(floor(gx));
+  let iy = i32(floor(gy));
+  let fx = fract(gx);
+  let fy = fract(gy);
+  let ix0 = clamp(ix, 0, size - 1);
+  let iy0 = clamp(iy, 0, size - 1);
+  let ix1 = clamp(ix + 1, 0, size - 1);
+  let iy1 = clamp(iy + 1, 0, size - 1);
+  let idx00 = grid_index(ix0, iy0, size);
+  let idx10 = grid_index(ix1, iy0, size);
+  let idx01 = grid_index(ix0, iy1, size);
+  let idx11 = grid_index(ix1, iy1, size);
+  let v00 = gridVel[idx00];
+  let v10 = gridVel[idx10];
+  let v01 = gridVel[idx01];
+  let v11 = gridVel[idx11];
+  let vx0 = mix(v00, v10, fx);
+  let vx1 = mix(v01, v11, fx);
+  return mix(vx0, vx1, fy);
+}
+
+fn sample_grid_vel_prev(uv: vec2<f32>) -> vec2<f32> {
+  let size = grid_size();
+  let grid_max = f32(size - 1);
+  let gx = uv.x * grid_max;
+  let gy = uv.y * grid_max;
+  let ix = i32(floor(gx));
+  let iy = i32(floor(gy));
+  let fx = fract(gx);
+  let fy = fract(gy);
+  let ix0 = clamp(ix, 0, size - 1);
+  let iy0 = clamp(iy, 0, size - 1);
+  let ix1 = clamp(ix + 1, 0, size - 1);
+  let iy1 = clamp(iy + 1, 0, size - 1);
+  let idx00 = grid_index(ix0, iy0, size);
+  let idx10 = grid_index(ix1, iy0, size);
+  let idx01 = grid_index(ix0, iy1, size);
+  let idx11 = grid_index(ix1, iy1, size);
+  let v00 = gridVelPrev[idx00];
+  let v10 = gridVelPrev[idx10];
+  let v01 = gridVelPrev[idx01];
+  let v11 = gridVelPrev[idx11];
+  let vx0 = mix(v00, v10, fx);
+  let vx1 = mix(v01, v11, fx);
+  return mix(vx0, vx1, fy);
+}
+
+fn particle_uv(pos: vec2<f32>) -> vec2<f32> {
+  let origin = params.sim0.xy;
+  let invSize = params.sim0.z;
+  return clamp((pos - origin) * invSize, vec2<f32>(0.0), vec2<f32>(1.0));
+}
+
+@compute @workgroup_size(128)
+fn copy_grid(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = i32(gid.x);
+  let count = grid_count();
+  if (idx >= count) {
+    return;
+  }
+  gridVelPrev[idx] = gridVel[idx];
+}
+
+@compute @workgroup_size(128)
+fn clear_grid(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = i32(gid.x);
+  let count = grid_count();
+  if (idx >= count) {
+    return;
+  }
+  atomicStore(&gridAccum[idx].velX, 0);
+  atomicStore(&gridAccum[idx].velY, 0);
+  atomicStore(&gridAccum[idx].weight, 0);
+  atomicStore(&gridAccum[idx].pad, 0);
+  gridVel[idx] = vec2<f32>(0.0);
+  gridDivergence[idx] = 0.0;
+  gridPressure[idx] = 0.0;
+  gridPressurePrev[idx] = 0.0;
+  gridHeight[idx] = 0.0;
+}
+
+@compute @workgroup_size(128)
+fn particles_to_grid(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = i32(gid.x);
+  let count = i32(params.sim1.z);
+  if (idx >= count) {
+    return;
+  }
+  let pos = particles[idx].xy;
+  let vel = particles[idx].zw;
+  let size = grid_size();
+  let grid_max = f32(size - 1);
+  let uv = particle_uv(pos);
+  let gx = uv.x * grid_max;
+  let gy = uv.y * grid_max;
+  let ix = i32(floor(gx));
+  let iy = i32(floor(gy));
+  let fx = fract(gx);
+  let fy = fract(gy);
+  let ix0 = clamp(ix, 0, size - 2);
+  let iy0 = clamp(iy, 0, size - 2);
+  let ix1 = ix0 + 1;
+  let iy1 = iy0 + 1;
+
+  let w00 = (1.0 - fx) * (1.0 - fy);
+  let w10 = fx * (1.0 - fy);
+  let w01 = (1.0 - fx) * fy;
+  let w11 = fx * fy;
+
+  let velScale = params.sim2.x;
+  let weightScale = params.sim2.y;
+
+  let v00x = i32(round(vel.x * velScale * w00));
+  let v00y = i32(round(vel.y * velScale * w00));
+  let v10x = i32(round(vel.x * velScale * w10));
+  let v10y = i32(round(vel.y * velScale * w10));
+  let v01x = i32(round(vel.x * velScale * w01));
+  let v01y = i32(round(vel.y * velScale * w01));
+  let v11x = i32(round(vel.x * velScale * w11));
+  let v11y = i32(round(vel.y * velScale * w11));
+
+  let w00i = i32(round(weightScale * w00));
+  let w10i = i32(round(weightScale * w10));
+  let w01i = i32(round(weightScale * w01));
+  let w11i = i32(round(weightScale * w11));
+
+  let idx00 = grid_index(ix0, iy0, size);
+  let idx10 = grid_index(ix1, iy0, size);
+  let idx01 = grid_index(ix0, iy1, size);
+  let idx11 = grid_index(ix1, iy1, size);
+
+  atomicAdd(&gridAccum[idx00].velX, v00x);
+  atomicAdd(&gridAccum[idx00].velY, v00y);
+  atomicAdd(&gridAccum[idx00].weight, w00i);
+
+  atomicAdd(&gridAccum[idx10].velX, v10x);
+  atomicAdd(&gridAccum[idx10].velY, v10y);
+  atomicAdd(&gridAccum[idx10].weight, w10i);
+
+  atomicAdd(&gridAccum[idx01].velX, v01x);
+  atomicAdd(&gridAccum[idx01].velY, v01y);
+  atomicAdd(&gridAccum[idx01].weight, w01i);
+
+  atomicAdd(&gridAccum[idx11].velX, v11x);
+  atomicAdd(&gridAccum[idx11].velY, v11y);
+  atomicAdd(&gridAccum[idx11].weight, w11i);
+}
+
+@compute @workgroup_size(128)
+fn normalize_grid(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = i32(gid.x);
+  let count = grid_count();
+  if (idx >= count) {
+    return;
+  }
+  let weightScale = params.sim2.y;
+  let velScale = params.sim2.x;
+  let damping = params.sim3.x;
+  let heightScale = params.sim2.z;
+  let densityScale = max(params.sim2.w, 1e-3);
+
+  let w = f32(atomicLoad(&gridAccum[idx].weight)) / weightScale;
+  var vel = vec2<f32>(0.0);
+  if (w > 0.0) {
+    let vx = f32(atomicLoad(&gridAccum[idx].velX)) / (velScale * w);
+    let vy = f32(atomicLoad(&gridAccum[idx].velY)) / (velScale * w);
+    vel = vec2<f32>(vx, vy);
+  }
+  vel = vel * (1.0 - damping);
+  gridVel[idx] = vel;
+  let height = clamp(w / densityScale, 0.0, 1.0) * heightScale;
+  gridHeight[idx] = height;
+}
+
+@compute @workgroup_size(128)
+fn compute_divergence(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = i32(gid.x);
+  let size = grid_size();
+  let count = size * size;
+  if (idx >= count) {
+    return;
+  }
+  let ix = idx % size;
+  let iy = idx / size;
+  let invCell = params.sim0.z * (f32(size - 1));
+
+  var left = vec2<f32>(0.0);
+  var right = vec2<f32>(0.0);
+  var down = vec2<f32>(0.0);
+  var up = vec2<f32>(0.0);
+  if (ix > 0) {
+    left = gridVel[grid_index(ix - 1, iy, size)];
+  }
+  if (ix < size - 1) {
+    right = gridVel[grid_index(ix + 1, iy, size)];
+  }
+  if (iy > 0) {
+    down = gridVel[grid_index(ix, iy - 1, size)];
+  }
+  if (iy < size - 1) {
+    up = gridVel[grid_index(ix, iy + 1, size)];
+  }
+
+  let div = (right.x - left.x + up.y - down.y) * 0.5 * invCell;
+  gridDivergence[idx] = div;
+}
+
+@compute @workgroup_size(128)
+fn pressure_jacobi(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = i32(gid.x);
+  let size = grid_size();
+  let count = size * size;
+  if (idx >= count) {
+    return;
+  }
+  let ix = idx % size;
+  let iy = idx / size;
+
+  var pL = 0.0;
+  var pR = 0.0;
+  var pB = 0.0;
+  var pT = 0.0;
+  if (ix > 0) {
+    pL = gridPressurePrev[grid_index(ix - 1, iy, size)];
+  }
+  if (ix < size - 1) {
+    pR = gridPressurePrev[grid_index(ix + 1, iy, size)];
+  }
+  if (iy > 0) {
+    pB = gridPressurePrev[grid_index(ix, iy - 1, size)];
+  }
+  if (iy < size - 1) {
+    pT = gridPressurePrev[grid_index(ix, iy + 1, size)];
+  }
+  let div = gridDivergence[idx];
+  gridPressure[idx] = (pL + pR + pB + pT - div) * 0.25;
+}
+
+@compute @workgroup_size(128)
+fn project_grid(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = i32(gid.x);
+  let size = grid_size();
+  let count = size * size;
+  if (idx >= count) {
+    return;
+  }
+  let ix = idx % size;
+  let iy = idx / size;
+  let invCell = params.sim0.z * (f32(size - 1));
+
+  var pL = 0.0;
+  var pR = 0.0;
+  var pB = 0.0;
+  var pT = 0.0;
+  if (ix > 0) {
+    pL = gridPressure[grid_index(ix - 1, iy, size)];
+  }
+  if (ix < size - 1) {
+    pR = gridPressure[grid_index(ix + 1, iy, size)];
+  }
+  if (iy > 0) {
+    pB = gridPressure[grid_index(ix, iy - 1, size)];
+  }
+  if (iy < size - 1) {
+    pT = gridPressure[grid_index(ix, iy + 1, size)];
+  }
+  var vel = gridVel[idx];
+  vel.x = vel.x - (pR - pL) * 0.5 * invCell;
+  vel.y = vel.y - (pT - pB) * 0.5 * invCell;
+  gridVel[idx] = vel;
+}
+
+@compute @workgroup_size(128)
+fn update_particles(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = i32(gid.x);
+  let count = i32(params.sim1.z);
+  if (idx >= count) {
+    return;
+  }
+  let dt = params.sim1.x;
+  let flipRatio = params.sim1.y;
+  let bounce = params.sim3.y;
+  let origin = params.sim0.xy;
+  let size = 1.0 / params.sim0.z;
+
+  var pos = particles[idx].xy;
+  var vel = particles[idx].zw;
+  let uv = particle_uv(pos);
+
+  let pic = sample_grid_vel_current(uv);
+  let prev = sample_grid_vel_prev(uv);
+  let flip = vel + (pic - prev);
+  vel = mix(pic, flip, flipRatio);
+
+  pos = pos + vel * dt;
+
+  let minPos = origin;
+  let maxPos = origin + vec2<f32>(size);
+  if (pos.x < minPos.x) {
+    pos.x = minPos.x;
+    vel.x = -vel.x * bounce;
+  } else if (pos.x > maxPos.x) {
+    pos.x = maxPos.x;
+    vel.x = -vel.x * bounce;
+  }
+  if (pos.y < minPos.y) {
+    pos.y = minPos.y;
+    vel.y = -vel.y * bounce;
+  } else if (pos.y > maxPos.y) {
+    pos.y = maxPos.y;
+    vel.y = -vel.y * bounce;
+  }
+
+  particles[idx] = vec4<f32>(pos, vel);
+}

package/src/shaders/library/common.wgsl

@@ -0,0 +1,38 @@
+const PI: f32 = 3.1415926535;
+
+fn hash12(p: vec2<f32>) -> f32 {
+  let h = dot(p, vec2<f32>(127.1, 311.7));
+  return fract(sin(h) * 43758.5453123);
+}
+
+fn noise2(p: vec2<f32>) -> f32 {
+  let i = floor(p);
+  let f = fract(p);
+  let a = hash12(i);
+  let b = hash12(i + vec2<f32>(1.0, 0.0));
+  let c = hash12(i + vec2<f32>(0.0, 1.0));
+  let d = hash12(i + vec2<f32>(1.0, 1.0));
+  let u = f * f * (3.0 - 2.0 * f);
+  return mix(a, b, u.x) + (c - a) * u.y * (1.0 - u.x) + (d - b) * u.x * u.y;
+}
+
+fn fbm2(p: vec2<f32>) -> f32 {
+  var value = 0.0;
+  var amp = 0.5;
+  var freq = 1.0;
+  var coord = p;
+  value = value + amp * noise2(coord * freq);
+  amp = amp * 0.5;
+  freq = freq * 2.0;
+  coord = coord + vec2<f32>(1.7, 9.2);
+  value = value + amp * noise2(coord * freq);
+  amp = amp * 0.5;
+  freq = freq * 2.0;
+  coord = coord + vec2<f32>(8.3, 2.8);
+  value = value + amp * noise2(coord * freq);
+  return value;
+}
+
+fn clamp01(v: f32) -> f32 {
+  return clamp(v, 0.0, 1.0);
+}