@plasius/gpu-world-generator 0.0.4

package/src/mesh.ts

@@ -0,0 +1,285 @@
+export type Vec3 = [number, number, number];
+
+export type MeshGeomorph = {
+  targetY: number;
+  weight?: number;
+};
+
+export interface MeshBuilderOptions {
+  size?: number;
+  includeGeomorph?: boolean;
+  defaultMaterial?: number;
+  foliageMaterial?: number;
+}
+
+export interface MeshBuilder {
+  vertices: number[];
+  boxMin: number[];
+  boxMax: number[];
+  vertexStride: number;
+  includeGeomorph: boolean;
+  addTriangle: (
+    a: Vec3,
+    b: Vec3,
+    c: Vec3,
+    normal: Vec3,
+    color: Vec3,
+    swayA?: number,
+    swayB?: number,
+    swayC?: number,
+    material?: number,
+    morphA?: MeshGeomorph,
+    morphB?: MeshGeomorph,
+    morphC?: MeshGeomorph
+  ) => void;
+  addQuad: (
+    a: Vec3,
+    b: Vec3,
+    c: Vec3,
+    d: Vec3,
+    normal: Vec3,
+    color: Vec3,
+    swayA?: number,
+    swayB?: number,
+    swayC?: number,
+    swayD?: number,
+    material?: number,
+    morphA?: MeshGeomorph,
+    morphB?: MeshGeomorph,
+    morphC?: MeshGeomorph,
+    morphD?: MeshGeomorph
+  ) => void;
+  addTreeMesh: (center: Vec3, baseHeight: number, seedValue: number, material?: number) => void;
+  addBounds: (points: Vec3[], minY?: number, maxYOverride?: number) => void;
+  readonly treeMeshCount: number;
+}
+
+function clamp(value: number, min: number, max: number) {
+  return Math.min(max, Math.max(min, value));
+}
+
+export function normalize(vec: Vec3): Vec3 {
+  const len = Math.hypot(vec[0], vec[1], vec[2]);
+  if (len === 0) return [0, 1, 0];
+  return [vec[0] / len, vec[1] / len, vec[2] / len];
+}
+
+export function computeNormal(a: Vec3, b: Vec3, c: Vec3): Vec3 {
+  const ab: Vec3 = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
+  const ac: Vec3 = [c[0] - a[0], c[1] - a[1], c[2] - a[2]];
+  return normalize([
+    ab[1] * ac[2] - ab[2] * ac[1],
+    ab[2] * ac[0] - ab[0] * ac[2],
+    ab[0] * ac[1] - ab[1] * ac[0],
+  ]);
+}
+
+export function shade(color: Vec3, factor: number): Vec3 {
+  return [color[0] * factor, color[1] * factor, color[2] * factor];
+}
+
+export function createMeshBuilder(sizeOrOptions: number | MeshBuilderOptions = 1): MeshBuilder {
+  const options: MeshBuilderOptions =
+    typeof sizeOrOptions === "number" ? { size: sizeOrOptions } : sizeOrOptions;
+  const size = options.size ?? 1;
+  const includeGeomorph = options.includeGeomorph ?? false;
+  const defaultMaterial = options.defaultMaterial ?? 0;
+  const foliageMaterial = options.foliageMaterial ?? defaultMaterial;
+  const vertices: number[] = [];
+  const boxMin: number[] = [];
+  const boxMax: number[] = [];
+  let treeMeshCount = 0;
+
+  const vertexStride = includeGeomorph ? 13 : 11;
+
+  const pushVertex = (
+    pos: Vec3,
+    normal: Vec3,
+    color: Vec3,
+    sway = 0,
+    material = defaultMaterial,
+    geomorph?: MeshGeomorph
+  ) => {
+    vertices.push(
+      pos[0],
+      pos[1],
+      pos[2],
+      normal[0],
+      normal[1],
+      normal[2],
+      color[0],
+      color[1],
+      color[2],
+      sway,
+      material
+    );
+    if (includeGeomorph) {
+      const targetY = geomorph?.targetY ?? pos[1];
+      const weight = geomorph?.weight ?? 0;
+      vertices.push(targetY, weight);
+    }
+  };
+
+  const addTriangle = (
+    a: Vec3,
+    b: Vec3,
+    c: Vec3,
+    normal: Vec3,
+    color: Vec3,
+    swayA = 0,
+    swayB = swayA,
+    swayC = swayA,
+    material = defaultMaterial,
+    morphA?: MeshGeomorph,
+    morphB?: MeshGeomorph,
+    morphC?: MeshGeomorph
+  ) => {
+    pushVertex(a, normal, color, swayA, material, morphA);
+    pushVertex(b, normal, color, swayB, material, morphB);
+    pushVertex(c, normal, color, swayC, material, morphC);
+  };
+
+  const addQuad = (
+    a: Vec3,
+    b: Vec3,
+    c: Vec3,
+    d: Vec3,
+    normal: Vec3,
+    color: Vec3,
+    swayA = 0,
+    swayB = swayA,
+    swayC = swayA,
+    swayD = swayA,
+    material = defaultMaterial,
+    morphA?: MeshGeomorph,
+    morphB?: MeshGeomorph,
+    morphC?: MeshGeomorph,
+    morphD?: MeshGeomorph
+  ) => {
+    addTriangle(a, b, c, normal, color, swayA, swayB, swayC, material, morphA, morphB, morphC);
+    addTriangle(c, d, a, normal, color, swayC, swayD, swayA, material, morphC, morphD, morphA);
+  };
+
+  const addPrism = (
+    center: Vec3,
+    radius: number,
+    bottom: number,
+    height: number,
+    color: Vec3,
+    swayBase = 0,
+    swayScale = 0,
+    material = defaultMaterial
+  ) => {
+    const top: Vec3[] = [];
+    const base: Vec3[] = [];
+    const baseY = center[1] + bottom;
+    const topY = baseY + height;
+    const safeHeight = Math.max(height, 0.001);
+    const swayFor = (y: number) => swayBase + swayScale * clamp((y - baseY) / safeHeight, 0, 1);
+    for (let i = 0; i < 6; i += 1) {
+      const angle = (Math.PI / 180) * (60 * i - 30);
+      const x = center[0] + radius * Math.cos(angle);
+      const z = center[2] + radius * Math.sin(angle);
+      top.push([x, topY, z]);
+      base.push([x, baseY, z]);
+    }
+    const topCenter: Vec3 = [center[0], topY, center[2]];
+    const topSway = swayFor(topY);
+    for (let i = 0; i < 6; i += 1) {
+      const a = topCenter;
+      const b = top[i];
+      const c = top[(i + 1) % 6];
+      const normal = computeNormal(a, b, c);
+      addTriangle(a, b, c, normal, color, topSway, topSway, topSway, material);
+    }
+    for (let i = 0; i < 6; i += 1) {
+      const top0 = top[i];
+      const top1 = top[(i + 1) % 6];
+      const bottom0 = base[i];
+      const bottom1 = base[(i + 1) % 6];
+      const normal = computeNormal(top0, bottom0, bottom1);
+      const swayTop0 = swayFor(top0[1]);
+      const swayTop1 = swayFor(top1[1]);
+      const swayBottom0 = swayFor(bottom0[1]);
+      const swayBottom1 = swayFor(bottom1[1]);
+      addQuad(
+        top0,
+        bottom0,
+        bottom1,
+        top1,
+        normal,
+        shade(color, 0.85),
+        swayTop0,
+        swayBottom0,
+        swayBottom1,
+        swayTop1,
+        material
+      );
+    }
+  };
+
+  const addTreeMesh = (
+    center: Vec3,
+    baseHeight: number,
+    seedValue: number,
+    material = defaultMaterial
+  ) => {
+    const trunkRadius = size * (0.12 + seedValue * 0.05);
+    const trunkHeight = 0.5 + seedValue * 0.6;
+    const canopyRadius = size * (0.36 + seedValue * 0.18);
+    const canopyHeight = 0.6 + seedValue * 0.4;
+    const trunkColor: Vec3 = [0.28, 0.18, 0.1];
+    const leafColor: Vec3 = [0.18, 0.45, 0.2];
+
+    addPrism(center, trunkRadius, baseHeight, trunkHeight, trunkColor, 0.02, 0.28, material);
+    addPrism(
+      [center[0], baseHeight + trunkHeight * 0.7, center[2]],
+      canopyRadius,
+      0,
+      canopyHeight * 0.55,
+      leafColor,
+      0.12,
+      0.9,
+      foliageMaterial
+    );
+    addPrism(
+      [center[0], baseHeight + trunkHeight + canopyHeight * 0.1, center[2]],
+      canopyRadius * 0.7,
+      0,
+      canopyHeight * 0.35,
+      shade(leafColor, 0.95),
+      0.2,
+      1.1,
+      foliageMaterial
+    );
+    treeMeshCount += 1;
+  };
+
+  const addBounds = (points: Vec3[], minY = 0, maxYOverride?: number) => {
+    const xs = points.map((p) => p[0]);
+    const zs = points.map((p) => p[2]);
+    const ys = points.map((p) => p[1]);
+    const minX = Math.min(...xs);
+    const maxX = Math.max(...xs);
+    const minZ = Math.min(...zs);
+    const maxZ = Math.max(...zs);
+    const maxY = typeof maxYOverride === "number" ? maxYOverride : Math.max(...ys);
+    boxMin.push(minX, minY, minZ, 0);
+    boxMax.push(maxX, maxY, maxZ, 0);
+  };
+
+  return {
+    vertices,
+    boxMin,
+    boxMax,
+    vertexStride,
+    includeGeomorph,
+    addTriangle,
+    addQuad,
+    addTreeMesh,
+    addBounds,
+    get treeMeshCount() {
+      return treeMeshCount;
+    },
+  };
+}

package/src/perf-monitor.ts

@@ -0,0 +1,133 @@
+export interface PerfMonitorOptions {
+  targetFps?: number;
+  tolerance?: number;
+  sampleSize?: number;
+  minSampleFraction?: number;
+  cooldownMs?: number;
+  qualitySlew?: number;
+  initialBudget?: number;
+  auto?: boolean;
+}
+
+export interface PerfMonitorUpdate {
+  budget: number;
+  medianFps: number | null;
+  miss: number | null;
+  adjusted: boolean;
+  stable: boolean;
+}
+
+export interface PerfMonitor {
+  sampleFrame: (dtSeconds: number) => void;
+  sampleFps: (fps: number) => void;
+  update: (nowMs: number) => PerfMonitorUpdate;
+  resetSamples: () => void;
+  setBudget: (budget: number) => void;
+  getBudget: () => number;
+  setAuto: (enabled: boolean) => void;
+  getConfig: () => Required<PerfMonitorOptions>;
+}
+
+const defaultOptions: Required<PerfMonitorOptions> = {
+  targetFps: 120,
+  tolerance: 6,
+  sampleSize: 90,
+  minSampleFraction: 0.6,
+  cooldownMs: 1200,
+  qualitySlew: 0.05,
+  initialBudget: 0.5,
+  auto: true,
+};
+
+function clamp(value: number, min: number, max: number) {
+  return Math.min(max, Math.max(min, value));
+}
+
+function clamp01(value: number) {
+  return clamp(value, 0, 1);
+}
+
+function median(values: number[]) {
+  if (!values.length) return 0;
+  const sorted = values.slice().sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  if (sorted.length % 2 === 0) {
+    return (sorted[mid - 1] + sorted[mid]) * 0.5;
+  }
+  return sorted[mid];
+}
+
+export function createPerfMonitor(options: PerfMonitorOptions = {}): PerfMonitor {
+  const config: Required<PerfMonitorOptions> = { ...defaultOptions, ...options };
+  let budget = clamp01(config.initialBudget);
+  let lastAdjust = 0;
+  const samples: number[] = [];
+
+  const sampleFps = (fps: number) => {
+    if (!Number.isFinite(fps) || fps <= 0) return;
+    samples.push(fps);
+    if (samples.length > config.sampleSize) {
+      samples.shift();
+    }
+  };
+
+  const sampleFrame = (dtSeconds: number) => {
+    if (!Number.isFinite(dtSeconds) || dtSeconds <= 0) return;
+    sampleFps(1 / dtSeconds);
+  };
+
+  const update = (nowMs: number): PerfMonitorUpdate => {
+    if (!config.auto) {
+      return { budget, medianFps: null, miss: null, adjusted: false, stable: true };
+    }
+    if (nowMs - lastAdjust < config.cooldownMs) {
+      return { budget, medianFps: null, miss: null, adjusted: false, stable: false };
+    }
+    if (samples.length < Math.floor(config.sampleSize * config.minSampleFraction)) {
+      return { budget, medianFps: null, miss: null, adjusted: false, stable: false };
+    }
+
+    const med = median(samples);
+    const miss = config.targetFps - med;
+    const tol = config.tolerance;
+    if (Math.abs(miss) <= tol) {
+      lastAdjust = nowMs;
+      return { budget, medianFps: med, miss, adjusted: false, stable: true };
+    }
+
+    const magnitude = Math.min(1, (Math.abs(miss) - tol) / tol);
+    const direction = miss > 0 ? -1 : 1;
+    const next = clamp01(budget + direction * magnitude * config.qualitySlew);
+    const adjusted = next !== budget;
+    budget = next;
+    lastAdjust = nowMs;
+    return { budget, medianFps: med, miss, adjusted, stable: false };
+  };
+
+  const resetSamples = () => {
+    samples.length = 0;
+  };
+
+  const setBudget = (next: number) => {
+    budget = clamp01(next);
+  };
+
+  const getBudget = () => budget;
+
+  const setAuto = (enabled: boolean) => {
+    config.auto = enabled;
+  };
+
+  const getConfig = () => ({ ...config });
+
+  return {
+    sampleFrame,
+    sampleFps,
+    update,
+    resetSamples,
+    setBudget,
+    getBudget,
+    setAuto,
+    getConfig,
+  };
+}

package/src/shaders/demo-terrain.wgsl

@@ -0,0 +1,193 @@
+struct Scene {
+  viewProj: mat4x4<f32>,
+  lightPos: vec4<f32>,
+  cameraPos: vec4<f32>,
+  boxCount: vec4<f32>,
+  wind: vec4<f32>,
+  weather: vec4<f32>,
+  waterSim: vec4<f32>,
+  debug: vec4<f32>,
+};
+
+@group(0) @binding(0) var<uniform> scene: Scene;
+@group(0) @binding(1) var<storage, read> boxMin: array<vec4<f32>>;
+@group(0) @binding(2) var<storage, read> boxMax: array<vec4<f32>>;
+@group(0) @binding(3) var<storage, read> waterHeight: array<f32>;
+
+struct VertexIn {
+  @location(0) position: vec3<f32>,
+  @location(1) normal: vec3<f32>,
+  @location(2) color: vec3<f32>,
+  @location(3) sway: f32,
+  @location(4) material: f32,
+};
+
+struct VertexOut {
+  @builtin(position) position: vec4<f32>,
+  @location(0) normal: vec3<f32>,
+  @location(1) color: vec3<f32>,
+  @location(2) worldPos: vec3<f32>,
+  @location(3) material: f32,
+};
+
+@vertex
+fn vs_main(input: VertexIn) -> VertexOut {
+  var out: VertexOut;
+  let windStrength = scene.boxCount.y;
+  let windGust = scene.boxCount.z;
+  let windDir = normalize(scene.wind.xyz);
+  let time = scene.wind.w;
+  var worldPos = input.position;
+  if (input.sway > 0.0001) {
+    let wave = sin(time * (0.8 + windGust) + input.position.x * 0.6 + input.position.z * 0.4);
+    let gust = sin(time * 1.7 + input.position.x * 0.9 + input.position.z * 1.1);
+    let sway = (wave + gust * 0.35) * windStrength * input.sway;
+    worldPos = worldPos + windDir * sway;
+  }
+  out.position = scene.viewProj * vec4<f32>(worldPos, 1.0);
+  out.normal = input.normal;
+  out.color = input.color;
+  out.worldPos = worldPos;
+  out.material = input.material;
+  return out;
+}
+
+fn ray_box_intersect(origin: vec3<f32>, dir: vec3<f32>, bmin: vec3<f32>, bmax: vec3<f32>) -> f32 {
+  let inv = 1.0 / dir;
+  let t0 = (bmin - origin) * inv;
+  let t1 = (bmax - origin) * inv;
+  let tmin = max(max(min(t0.x, t1.x), min(t0.y, t1.y)), min(t0.z, t1.z));
+  let tmax = min(min(max(t0.x, t1.x), max(t0.y, t1.y)), max(t0.z, t1.z));
+  if (tmax >= max(tmin, 0.0)) {
+    return tmin;
+  }
+  return -1.0;
+}
+
+fn is_occluded(pos: vec3<f32>, light_pos: vec3<f32>) -> bool {
+  let to_light = light_pos - pos;
+  let dist = length(to_light);
+  if (dist < 1e-3) {
+    return false;
+  }
+  let dir = to_light / dist;
+  let origin = pos + dir * 0.02;
+  let count = u32(scene.boxCount.x);
+  let maxCount = arrayLength(&boxMin);
+  for (var i: u32 = 0u; i < maxCount; i = i + 1u) {
+    if (i >= count) {
+      break;
+    }
+    let t = ray_box_intersect(origin, dir, boxMin[i].xyz, boxMax[i].xyz);
+    if (t > 0.0 && t < dist) {
+      return true;
+    }
+  }
+  return false;
+}
+
+fn sample_water_height(world_pos: vec3<f32>) -> f32 {
+  let gridSize = i32(scene.waterSim.w);
+  if (gridSize < 2) {
+    return 0.0;
+  }
+  let origin = scene.waterSim.xy;
+  let invSize = scene.waterSim.z;
+  let uv = clamp((world_pos.xz - origin) * invSize, vec2<f32>(0.0), vec2<f32>(1.0));
+  let gridMax = f32(gridSize - 1);
+  let gx = uv.x * gridMax;
+  let gy = uv.y * gridMax;
+  let ix = i32(floor(gx));
+  let iy = i32(floor(gy));
+  let fx = fract(gx);
+  let fy = fract(gy);
+  let ix0 = clamp(ix, 0, gridSize - 1);
+  let iy0 = clamp(iy, 0, gridSize - 1);
+  let ix1 = clamp(ix + 1, 0, gridSize - 1);
+  let iy1 = clamp(iy + 1, 0, gridSize - 1);
+  let idx00 = iy0 * gridSize + ix0;
+  let idx10 = iy0 * gridSize + ix1;
+  let idx01 = iy1 * gridSize + ix0;
+  let idx11 = iy1 * gridSize + ix1;
+  let h00 = waterHeight[idx00];
+  let h10 = waterHeight[idx10];
+  let h01 = waterHeight[idx01];
+  let h11 = waterHeight[idx11];
+  let hx0 = mix(h00, h10, fx);
+  let hx1 = mix(h01, h11, fx);
+  return mix(hx0, hx1, fy);
+}
+
+fn sample_water_normal(world_pos: vec3<f32>) -> vec3<f32> {
+  let gridSize = i32(scene.waterSim.w);
+  if (gridSize < 2) {
+    return vec3<f32>(0.0, 1.0, 0.0);
+  }
+  let invSize = scene.waterSim.z;
+  let cellWorld = 1.0 / max(invSize * (f32(gridSize) - 1.0), 1e-3);
+  let hL = sample_water_height(world_pos + vec3<f32>(-cellWorld, 0.0, 0.0));
+  let hR = sample_water_height(world_pos + vec3<f32>(cellWorld, 0.0, 0.0));
+  let hB = sample_water_height(world_pos + vec3<f32>(0.0, 0.0, -cellWorld));
+  let hT = sample_water_height(world_pos + vec3<f32>(0.0, 0.0, cellWorld));
+  let scale = 1.2 / max(cellWorld, 1e-3);
+  let dx = (hR - hL) * scale;
+  let dz = (hT - hB) * scale;
+  return normalize(vec3<f32>(-dx, 1.0, -dz));
+}
+
+fn heatmap_color(t: f32) -> vec3<f32> {
+  let low = vec3<f32>(0.08, 0.12, 0.35);
+  let mid = vec3<f32>(0.18, 0.6, 0.28);
+  let high = vec3<f32>(0.95, 0.85, 0.55);
+  if (t < 0.5) {
+    return mix(low, mid, t * 2.0);
+  }
+  return mix(mid, high, (t - 0.5) * 2.0);
+}
+
+@fragment
+fn fs_main(input: VertexOut) -> @location(0) vec4<f32> {
+  if (scene.debug.x > 0.5) {
+    let minH = scene.debug.y;
+    let maxH = scene.debug.z;
+    let denom = max(maxH - minH, 1e-3);
+    let t = clamp((input.worldPos.y - minH) / denom, 0.0, 1.0);
+    return vec4<f32>(heatmap_color(t), 1.0);
+  }
+  var n = normalize(input.normal);
+  let to_light = scene.lightPos.xyz - input.worldPos;
+  let dist = length(to_light);
+  let dir = to_light / max(dist, 1e-3);
+  let view_vec = scene.cameraPos.xyz - input.worldPos;
+  let view_dist = length(view_vec);
+  let view_dir = view_vec / max(view_dist, 1e-3);
+  let material_id = u32(round(input.material));
+  if (material_id == MATERIAL_WATER) {
+    let sim_normal = sample_water_normal(input.worldPos);
+    n = normalize(mix(n, sim_normal, 0.85));
+  }
+  let material = apply_surface_material(
+    material_id,
+    input.color,
+    n,
+    input.worldPos,
+    scene.wind,
+    scene.weather,
+    view_dir,
+    view_dist
+  );
+  let diff = max(dot(material.normal, dir), 0.0);
+  let dist2 = max(dist * dist, 0.4);
+  let attenuation = scene.lightPos.w / dist2;
+  var shadow = 1.0;
+  if (is_occluded(input.worldPos + n * 0.02, scene.lightPos.xyz)) {
+    shadow = 0.25;
+  }
+  let ambient = 0.24;
+  var color = material.albedo * (ambient + diff * attenuation * shadow);
+  let half_vec = normalize(view_dir + dir);
+  let spec = pow(max(dot(material.normal, half_vec), 0.0), mix(8.0, 64.0, material.specular));
+  color = color + spec * material.specular * attenuation * 0.6;
+  color = color + material.emission;
+  return vec4<f32>(color, 1.0);
+}