@genex-ai/cli-demo 0.93.0-dev.247 → 0.94.0-dev.249

package/templates/skills/genex-threejs-lighting-design/references/light-recipes.md

@@ -1,137 +0,0 @@
-# Light Recipes
-
-Contents: rig baselines by environment, the practical couple, shafts and
-visible air, light as information, budgets and lifecycle, the kill-switch
-diagnostic.
-
-Numbers below are relationships, not mandates — validate them against the
-project's renderer baseline (`$genex-threejs-exposure-color-grading`), because
-tone mapping and exposure change what every intensity means.
-
-## Rig baselines by environment
-
-- **Outdoor day** — a warm sun `DirectionalLight` key plus cool sky fill
-  (`HemisphereLight`, or the skybox IBL when one is set). Fill sits well below
-  the key: when fill approaches key strength, shadow shapes die and the scene
-  flattens. The sun owns shadows: size the shadow camera's ortho bounds to the
-  playfield edges, fix acne at contact points with `bias`/`normalBias`, and
-  bump `mapSize` before loosening the frustum. A roaming world (racer, open
-  map) outgrows one frustum — that cascade question is
-  `$genex-threejs-shadow-systems`.
-- **Outdoor night** — the moon is a dim, cool, hard key, not a gray day.
-  Practicals carry visibility; the moon's job is silhouette and geography.
-  Push the fiction's emitters up the ladder before brightening the moon. No
-  moon (a city street)? The settlement's own skyglow is the fill — a dim,
-  warm-tinted hemisphere — and the emitters carry the rest.
-- **Interior** — the openings and fixtures ARE the rig: a window is a
-  `SpotLight` aimed the way the sun outside would aim (or a shaft, below);
-  fixtures are coupled practicals. IBL still fills, well below the windows.
-  When the hard sun-rectangle on the floor IS the shot (a big window, a long
-  room), swap the spot for a shadow-casting `DirectionalLight` through the
-  opening — parallel light keeps the patch's edges straight where a spot's
-  cone diverges.
-- **Cave / underground** — no sky, no free fill. The brightest practical or
-  the crack shaft is the key; darkness is part of the palette, and the
-  player's own torch is a gameplay object. Ration the black, don't erase it.
-- **Space** — one hard star key, black fill, bounce only from IBL or
-  planetshine. The harsh terminator IS the look; softening it reads as a
-  studio shoot.
-
-## The practical couple
-
-- Contain the light: set `distance` so the falloff dies inside the space the
-  source serves, and keep `decay` at the physical `2`. An uncontained point
-  light climbs walls three rooms away, and the scene creeps toward flat.
-- Position the light inside the emitter, slightly above the visible flame or
-  tube — the pool it throws must sit centered under the thing that explains it.
-- An area emitter — neon tube, screen, softbox — is by default a tinted
-  `PointLight` or `SpotLight` sunk into it. Reach for `RectAreaLight` only
-  when the rectangular wash on a nearby wall IS the shot, and know its terms:
-  `RectAreaLightUniformsLib.init()` first, no shadows, standard/physical
-  materials only.
-- When the player roams, the budget follows them — but never add or remove a
-  light mid-play: changing the light count recompiles every shader that sees
-  it, a visible hitch. Allocate a small fixed pool up front, reassign members'
-  position and color to the nearest sources, and retire one by driving its
-  intensity to 0.
-
-## Shafts and visible air
-
-The default shaft is geometry, not a render pass — an open cone or tapered
-cylinder from the aperture, additive, fading along its length:
-
-```ts
-function beamGradient(): THREE.Texture {
-  const c = document.createElement("canvas");
-  c.width = 1; c.height = 64;
-  const ctx = c.getContext("2d")!;
-  const g = ctx.createLinearGradient(0, 0, 0, 64);
-  g.addColorStop(0, "rgba(255,255,255,0.9)");
-  g.addColorStop(1, "rgba(255,255,255,0)");
-  ctx.fillStyle = g;
-  ctx.fillRect(0, 0, 1, 64);
-  const t = new THREE.Texture(c);
-  t.needsUpdate = true;
-  return t;
-}
-
-const shaft = new THREE.Mesh(
-  new THREE.CylinderGeometry(0.25, 1.6, 7, 24, 1, true), // narrow at the crack, wide at the floor
-  new THREE.MeshBasicMaterial({
-    map: beamGradient(),          // flip the gradient if the bright end lands on the floor
-    transparent: true,
-    opacity: 0.35,
-    blending: THREE.AdditiveBlending,
-    depthWrite: false,
-    side: THREE.DoubleSide,
-  }),
-);
-```
-
-- Pair the shaft with a real `SpotLight` from the same aperture: the bright
-  pool at its foot is what sells the beam. A shaft with nothing at its foot
-  reads as a hologram.
-- If the scene earns its one ambient-particle layer (the moment gate's
-  budget), inside the beam is where it pays — slow dust motes, the
-  `$genex-threejs-procedural-vfx` dot-texture recipe.
-- `scene.fog` (or `FogExp2`) is a scene-wide mood decision: every light pool
-  becomes a cone and contrast falls everywhere — choose it for the whole look.
-- A full-screen shaft hanging off the sun disc rides the atmosphere pass
-  (`$genex-threejs-atmosphere-aerial-perspective`); this skill's shafts are
-  per-aperture beams built as geometry. A real raymarched volumetric pass is
-  for scenes whose identity is shafts.
-
-## Light as information
-
-- Reserve a signal hue: pickups and objectives get a color no environment
-  light uses, and it never changes meaning mid-game.
-- Aim the player with brightness before UI: the lit doorway beats the arrow.
-  The eye lands on the highest contrast in frame — put it where the player
-  should go.
-- Telegraph danger with the light's shape — a red cone where the boss will
-  sweep, a pulsing ring under the falling crate — timed to the same event
-  feedback the moment gate placed.
-- A vertical beacon (shaft recipe above) reads across the whole map and over
-  occluding walls — the map's own "you are here".
-
-## Budgets and lifecycle
-
-- The whole rig of most shipped scenes: one shadow-casting key, IBL or
-  hemisphere fill, and a handful of coupled practicals. Each real light
-  beyond that carries a stated reason.
-- A shadow-casting point light renders the scene six more times; a
-  shadow-casting spot, once. Prefer the spot — and prefer no shadow at all on
-  a flickering source, because the moving pool already sells it.
-- `scene.remove(light)` does not free it: call `light.dispose()` when the
-  level unloads, and the shadow map goes with it.
-
-## The kill-switch diagnostic
-
-Wire a debug toggle per light, the same way the other systems expose debug
-views. Turn each light off alone and name what died — "the campfire pool",
-"the corridor signal" — watching the frame time as well as the frame: a light
-whose absence changes nothing is dead weight to delete, and a light that costs
-more milliseconds than the mood it adds is over budget. That observation is
-the budget — there is no magic count. Then take two screenshots with post
-off — the darkest playable corner and the brightest — and check both: if the
-subject and the way forward read in each, the rig holds.

package/templates/skills/genex-threejs-open-world/SKILL.md

@@ -1,149 +0,0 @@
----
-name: genex-threejs-open-world
-description: Build a big explorable world that stays fast — seeded heightfield terrain with chunk streaming, biomes, points of interest, instanced scatter, and honest world bounds. Use when the ask says big or open world, multiple regions or locations, exploration, or any map beyond one arena — before the first terrain code, instead of one flat plane with fog.
----
-
-# Genex Three.js Open World
-
-"Big world" in a request is a size class, not a mood. A 300 m plane with fog
-pulled in to hide the walls is an arena wearing a costume — the player finds
-the invisible wall in the first two minutes, and no amount of dressing
-survives that. This skill is the recipe for a world that is actually big —
-kilometers-class, streamed, varied — at a cost one session can afford.
-
-## Decide the scale first, as a number
-
-Put the world's size in the plan (and in the content contract's `world:` line
-when `$genex-threejs-game-content` is loaded — a big world exists to hold
-content, so the two skills almost always load together):
-
-- **One arena** (~100–300 m): only when the ask says so (a shooter map, a
-  sports pitch, a boss rush). Never the silent fallback for "big world".
-- **A district** (~500 m – 1 km): a town + surroundings; streaming optional.
-- **Open world** (2–4 km bounded): the default meaning of "big/open world" —
-  a dozen locations, real travel time between them, streamed terrain. Beyond
-  ~4 km you're spending budget on emptiness; density beats acreage.
-
-Bound the world honestly: an edge-mountain ring, a coastline, or a cliff
-reads as "the world ends here" — an invisible wall on a flat horizon reads as
-a bug. Fog is atmosphere and draw-distance management
-(`$genex-threejs-atmosphere-aerial-perspective` for the real thing), never a
-wall to hide how small the map is.
-
-## The scaling law: procedural fabric, generated landmarks
-
-The single decision that determines whether a big world is affordable:
-
-- **The world's FABRIC is procedural** — a seeded heightfield, instanced
-  vegetation, scattered rocks and props built from primitives and the
-  procedural skills (`$genex-threejs-procedural-vegetation`,
-  `$genex-threejs-procedural-geometry`). Procedural fabric costs the same at
-  4 km as at 300 m; that is what makes the size class reachable.
-- **Generated assets are LANDMARKS** — `npx genex model` set pieces placed at
-  points of interest (the village well, the boss lair gate, the shrine), a
-  ground texture (`npx genex texture --terrain`, UVs from `worldUV` — never a
-  hand-picked repeat), a skybox. Hero assets decorate the world's landmarks;
-  they never decide the world's size, because a world assembled from
-  hand-placed generated meshes caps out at a diorama.
-
-Wire generated pieces in as upgrades over procedural placeholders (the
-standard swap discipline), so the world is walkable at full size from the
-first hour.
-
-## One height function to rule everything
-
-Terrain is a seeded fBm heightfield (`$genex-threejs-procedural-fields` owns
-the noise craft) with ridges for drama, an edge-mountain ring for the bound,
-and **flattened pads blended in around each location** so structures sit on
-level ground. The load-bearing rule: **exactly one canonical
-`getHeightAt(x, z)`** that chunk meshing, physics grounding, placement
-scatter, NPC spawns, and the minimap all share. The moment a second height
-formula exists, trees float and feet sink — every large-world bug report
-starts there.
-
-Full copy-paste module — noise, fBm, location flattening, chunk manager,
-instanced scatter — in
-[references/terrain-streaming.md](references/terrain-streaming.md).
-
-## Stream chunks, budget the frame
-
-Build the terrain as fixed-size chunks (128 m is a good default) around the
-player: load radius ~5 chunks (~600 m view with fog), unload behind, and
-build queued chunks inside a **per-frame time budget** (a few ms) so streaming
-never hitches the game. Seam rule: compute normals with a one-vertex apron
-into the neighbor chunk, or every chunk border shows as a lighting crease.
-Far distance is fog + the skybox — a low-res far ring is an upgrade, not a
-requirement.
-
-Physics grounding: keep the character/vehicle on the ground via the canonical
-`getHeightAt` (cheap, always loaded) or per-chunk Rapier heightfield
-colliders (`$genex-threejs-physics-rapier`) when projectiles and ragdolls
-need real collision — but never build colliders for chunks the player isn't
-near.
-
-## Biomes: variety from two noise fields
-
-Two low-frequency noise fields (temperature, moisture) + altitude + slope
-give 4–7 biomes from one lookup: meadow, forest, marsh, desert, alpine, snow.
-The biome function drives everything downstream from ONE place — vertex
-colors or texture blend, vegetation species and density
-(`$genex-threejs-procedural-vegetation`, instanced), enemy spawn tables and
-ambient audio per biome (that's the content hookup). "Different locations" in
-an ask is only half-answered by placed structures; the other half is the
-ground itself changing as you travel.
-
-## Points of interest: the world's content skeleton
-
-A data table of locations — id, name, position, radius, builder function —
-is the spine the content contract hangs from (quest givers live somewhere;
-"locations: 8" means eight entries here):
-
-- **Density beats acreage:** a point of interest every ~300–500 m of travel
-  on the natural routes. A 4 km world with three POIs is emptier than a 1 km
-  world with eight.
-- Each location: terrain pad flattened (blend into the heightfield — see the
-  reference), a hand-authored builder (walls, tents, standing stones — merged
-  primitive geometry + generated landmark pieces), spawns, loot, and its
-  compass/minimap marker.
-- Light budget: point lights per location, hard cap world-wide (~6 active) —
-  swap distant ones for emissive materials (`$genex-threejs-lighting-design`
-  owns the walk).
-- Roads or worn paths between major POIs guide travel and double as the
-  navigation answer ("follow the road north beats a quest arrow").
-
-## Performance floors (the size class depends on them)
-
-- **Instancing for everything repeated**: trees, grass, rocks are
-  `InstancedMesh` per chunk — thousands of draw calls is the classic
-  big-world death; hundreds is the target.
-- **Merge static location geometry** per material into a handful of meshes.
-- Shadows at scale need a strategy, not defaults: a tight shadow camera
-  following the player, or cascades — `$genex-threejs-shadow-systems`.
-- Keep per-frame allocation out of the loop (reuse vectors), and keep chunk
-  building inside its time budget.
-- Phone-survivable stays the bar: pixel ratio cap, texture ≤ 2048², and the
-  chunk radius is the quality knob to shrink first.
-
-## Day/night: cheap and almost expected
-
-A big explorable world reads twice as alive with a sun cycle: one animated
-`DirectionalLight` angle + a palette lerp (sky, fog, ambient) + practical
-lights that matter at night. It's ~50 lines against the lighting rig
-(`$genex-threejs-lighting-design`), and it makes travel time feel like time.
-Optional — but when the ask says "like the big RPGs", this is one of the
-three things they mean.
-
-## Failure modes to catch
-
-- A flat plane with invisible walls and close fog shipped as "big world" —
-  the defining failure this skill exists to prevent.
-- Two height functions (mesh vs physics vs placement) drifting apart —
-  floating trees, buried chests.
-- Hand-placing every tree at world scale — placement must be seeded scatter
-  with biome rules, or the world stays empty.
-- Per-chunk geometry that never unloads or shares materials — memory climbs,
-  draw calls explode.
-- POIs as map dots only — a named location with nothing to do fails the
-  content contract it was meant to serve (`$genex-threejs-game-content`).
-- Seams: normal creases at every chunk border (missing apron), or texture
-  tiling picked by eye instead of `worldUV` (`$genex-ai-texture`).

package/templates/skills/genex-threejs-open-world/references/terrain-streaming.md

@@ -1,215 +0,0 @@
-# Genex open-world terrain — copy-paste streaming heightfield
-
-One module: seeded noise → fBm heightfield with location pads → chunked,
-time-budgeted streaming with seam-free normals → instanced scatter. Plain
-vanilla-ts, three.js only. Copy it, then tune the named constants at the top —
-they are the whole difficulty/size surface.
-
-## Constants + the canonical height function
-
-```ts
-// world-terrain.ts
-import * as THREE from "three";
-
-export const WORLD_SEED = 1337;      // one seed → same world on every machine
-export const WORLD_BOUND = 2048;     // half-size: playable area is 4096×4096 m
-export const CHUNK = 128;            // chunk side in meters
-export const CHUNK_RES = 32;         // vertices per side (33×33 grid)
-export const VIEW_CHUNKS = 5;        // load radius → ~600 m view with fog
-
-// --- seeded value noise + fBm (swap in $genex-threejs-procedural-fields'
-// simplex if it's already loaded; the shape below is what matters) ---
-const hash2 = (x: number, y: number): number => {
-  let h = (Math.imul(x, 374761393) + Math.imul(y, 668265263) + WORLD_SEED) | 0;
-  h = Math.imul(h ^ (h >>> 13), 1274126177);
-  return ((h ^ (h >>> 16)) >>> 0) / 0xffffffff;
-};
-const smooth = (t: number): number => t * t * (3 - 2 * t);
-function valueNoise(x: number, y: number): number {
-  const xi = Math.floor(x), yi = Math.floor(y);
-  const tx = smooth(x - xi), ty = smooth(y - yi);
-  const a = hash2(xi, yi), b = hash2(xi + 1, yi);
-  const c = hash2(xi, yi + 1), d = hash2(xi + 1, yi + 1);
-  return (a + (b - a) * tx) * (1 - ty) + (c + (d - c) * tx) * ty; // 0..1
-}
-function fbm(x: number, y: number, octaves = 5): number {
-  let sum = 0, amp = 0.5, freq = 1;
-  for (let i = 0; i < octaves; i++) {
-    sum += amp * (valueNoise(x * freq, y * freq) * 2 - 1);
-    amp *= 0.5; freq *= 2;
-  }
-  return sum; // ~-1..1
-}
-
-// --- location pads: level ground for structures, BLENDED into the field ---
-type Pad = { x: number; z: number; radius: number; height: number };
-export const PADS: Pad[] = []; // fill from your POI table before first chunk build
-
-function baseHeight(x: number, z: number): number {
-  const n = fbm(x * 0.0016, z * 0.0016);            // rolling base, ~600 m features
-  const ridge = 1 - Math.abs(fbm(x * 0.004, z * 0.004)); // sharp ridge lines
-  let h = n * 26 + ridge * ridge * 18;
-  // edge-mountain ring: the honest world bound the player can SEE
-  const edge = Math.max(Math.abs(x), Math.abs(z)) / WORLD_BOUND; // 0..1
-  if (edge > 0.85) h += ((edge - 0.85) / 0.15) ** 2 * 90;
-  return h;
-}
-
-/**
- * THE canonical height. Chunk meshing, physics grounding, scatter, spawns,
- * and the minimap all call THIS — a second height formula anywhere is how
- * trees float and feet sink.
- */
-export function getHeightAt(x: number, z: number): number {
-  let h = baseHeight(x, z);
-  for (const p of PADS) {
-    const d = Math.hypot(x - p.x, z - p.z);
-    if (d < p.radius) {
-      const t = smooth(1 - d / p.radius); // 1 at center → 0 at rim
-      h = h * (1 - t) + p.height * t;     // flat pad blended into the hills
-    }
-  }
-  return h;
-}
-```
-
-## Chunk manager — streamed, time-budgeted, seam-free
-
-```ts
-// world-chunks.ts
-const chunkKey = (cx: number, cz: number): string => `${cx},${cz}`;
-const live = new Map<string, THREE.Mesh>();
-const queue: Array<{ cx: number; cz: number }> = [];
-const material = new THREE.MeshStandardMaterial({ vertexColors: true });
-
-function buildChunk(cx: number, cz: number): THREE.Mesh {
-  const geo = new THREE.PlaneGeometry(CHUNK, CHUNK, CHUNK_RES, CHUNK_RES);
-  geo.rotateX(-Math.PI / 2);
-  const pos = geo.attributes.position;
-  const colors = new Float32Array(pos.count * 3);
-  const x0 = cx * CHUNK, z0 = cz * CHUNK;
-  for (let i = 0; i < pos.count; i++) {
-    const wx = x0 + pos.getX(i), wz = z0 + pos.getZ(i);
-    const h = getHeightAt(wx, wz);
-    pos.setY(i, h);
-    const c = biomeColor(wx, wz, h); // your biome lookup (see below)
-    colors.set([c.r, c.g, c.b], i * 3);
-  }
-  geo.setAttribute("color", new THREE.BufferAttribute(colors, 3));
-  // Seam rule: analytic normals from the SAME height field (an implicit
-  // one-vertex apron) — computeVertexNormals() per chunk creases every border.
-  const nrm = geo.attributes.normal;
-  const eps = CHUNK / CHUNK_RES;
-  for (let i = 0; i < pos.count; i++) {
-    const wx = x0 + pos.getX(i), wz = z0 + pos.getZ(i);
-    const hx = getHeightAt(wx + eps, wz) - getHeightAt(wx - eps, wz);
-    const hz = getHeightAt(wx, wz + eps) - getHeightAt(wx, wz - eps);
-    const n = new THREE.Vector3(-hx, 2 * eps, -hz).normalize();
-    nrm.setXYZ(i, n.x, n.y, n.z);
-  }
-  const mesh = new THREE.Mesh(geo, material);
-  mesh.position.set(x0, 0, z0);
-  mesh.receiveShadow = true;
-  return mesh;
-}
-
-/** Call every frame. Streams chunks around the player inside a ms budget. */
-export function updateChunks(scene: THREE.Scene, px: number, pz: number, budgetMs = 5): void {
-  const ccx = Math.round(px / CHUNK), ccz = Math.round(pz / CHUNK);
-  for (let dz = -VIEW_CHUNKS; dz <= VIEW_CHUNKS; dz++) {
-    for (let dx = -VIEW_CHUNKS; dx <= VIEW_CHUNKS; dx++) {
-      const key = chunkKey(ccx + dx, ccz + dz);
-      if (!live.has(key) && !queue.some((q) => chunkKey(q.cx, q.cz) === key)) {
-        queue.push({ cx: ccx + dx, cz: ccz + dz });
-      }
-    }
-  }
-  const start = performance.now();
-  while (queue.length && performance.now() - start < budgetMs) {
-    const { cx, cz } = queue.shift()!;
-    const mesh = buildChunk(cx, cz);
-    live.set(chunkKey(cx, cz), mesh);
-    scene.add(mesh);
-    // scatterChunk(scene, cx, cz) — instanced vegetation, below
-  }
-  for (const [key, mesh] of live) {
-    const [cx, cz] = key.split(",").map(Number);
-    if (Math.max(Math.abs(cx - ccx), Math.abs(cz - ccz)) > VIEW_CHUNKS + 1) {
-      scene.remove(mesh);
-      mesh.geometry.dispose(); // material is shared — never dispose it here
-      live.delete(key);
-    }
-  }
-}
-```
-
-## Biomes — one lookup drives color, scatter, and spawns
-
-```ts
-type Biome = "meadow" | "forest" | "marsh" | "desert" | "alpine";
-export function biomeAt(x: number, z: number, h: number): Biome {
-  if (h > 55) return "alpine";
-  const temp = valueNoise(x * 0.0006 + 100, z * 0.0006);     // slow fields:
-  const moist = valueNoise(x * 0.0006, z * 0.0006 + 100);    // ~1.5 km regions
-  if (temp > 0.62 && moist < 0.4) return "desert";
-  if (moist > 0.62 && h < 12) return "marsh";
-  if (moist > 0.45) return "forest";
-  return "meadow";
-}
-const BIOME_TINT: Record<Biome, THREE.Color> = {
-  meadow: new THREE.Color(0x5d7f3a), forest: new THREE.Color(0x3f5f31),
-  marsh: new THREE.Color(0x4a5a3c), desert: new THREE.Color(0xb59a63),
-  alpine: new THREE.Color(0x8d8d94),
-};
-function biomeColor(x: number, z: number, h: number): THREE.Color {
-  const c = BIOME_TINT[biomeAt(x, z, h)].clone();
-  // slope → rock, shoreline → sand: cheap reads that sell the terrain
-  return c;
-}
-```
-
-Spawn tables and ambient audio key off `biomeAt` too — that is the content
-hookup (`$genex-threejs-game-content`'s enemy line usually reads "wolves in
-the forest, bandits on the roads": this function is where that sentence
-becomes true).
-
-## Instanced scatter — a forest for one draw call
-
-```ts
-export function scatterChunk(scene: THREE.Scene, cx: number, cz: number): void {
-  const rng = seededRng((cx * 73856093) ^ (cz * 19349663) ^ WORLD_SEED);
-  const spots: THREE.Matrix4[] = [];
-  for (let i = 0; i < 40; i++) {
-    const x = (cx + rng()) * CHUNK, z = (cz + rng()) * CHUNK;
-    const h = getHeightAt(x, z);
-    if (biomeAt(x, z, h) !== "forest") continue;
-    if (PADS.some((p) => Math.hypot(x - p.x, z - p.z) < p.radius + 6)) continue;
-    const s = 0.8 + rng() * 0.7;
-    spots.push(new THREE.Matrix4().compose(
-      new THREE.Vector3(x, h, z),
-      new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), rng() * Math.PI * 2),
-      new THREE.Vector3(s, s, s),
-    ));
-  }
-  if (!spots.length) return;
-  const tree = new THREE.InstancedMesh(sharedTreeGeometry, sharedTreeMaterial, spots.length);
-  spots.forEach((m, i) => tree.setMatrixAt(i, m));
-  tree.castShadow = true;
-  scene.add(tree); // track per chunk-key and remove alongside the chunk
-}
-```
-
-(`seededRng` is the one from `$genex-threejs-game-content`'s reference —
-share it. `sharedTreeGeometry`/`sharedTreeMaterial` are module-level ONE-time
-allocations: per-chunk geometry allocation is the classic memory leak here.
-Real trees come from `$genex-threejs-procedural-vegetation`; a cone-on-
-cylinder placeholder is fine until it loads.)
-
-## Grounding the player
-
-For the character/vehicle, the cheap path is the canonical function itself —
-`y = getHeightAt(x, z)` plus a small offset for walking, with slopes from the
-same finite differences as the normals. Move to per-chunk Rapier heightfield
-colliders (`$genex-threejs-physics-rapier`) when projectiles, ragdolls, or
-rolling props need true collision — build them only for the chunks around the
-player, and from the SAME `getHeightAt`, never a copy.

package/templates/skills/genex-threejs-precipitation-surfaces/SKILL.md

@@ -1,59 +0,0 @@
----
-name: genex-threejs-precipitation-surfaces
-description: Build coupled precipitation and weather-affected surfaces for Genex Three.js games. Use for falling snow, snow accumulation, model snow caps, rain, wet asphalt puddles, procedural ripple normals, splash flipbooks, rain streaks, shared weather envelopes, and surface wetness or coverage transitions.
----
-
-# Genex Three.js Precipitation Surfaces
-
-Treat weather as a coupled event, particle, and surface-response system. Do not
-add rain or snow particles that are visually disconnected from the ground.
-
-## Build order
-
-```text
-weather envelope
-  -> falling precipitation volume
-  -> world/object surface mask
-  -> displaced or optical surface response
-  -> impact residue and splashes
-  -> shared lighting/post presentation
-```
-
-Read [references/precipitation-surfaces.md](references/precipitation-surfaces.md)
-for snow accumulation, object capping, wrapped precipitation volumes, wet
-puddle masks, procedural ripple normals, splash placement, and debug outputs.
-
-For the base ground surface under the wetness or snow (asphalt, dirt, stone),
-generate a real texture with `npx genex texture` and load it via
-`$genex-ai-texture`, then build the precipitation response on top of it.
-Splash flipbook atlases and ripple normals stay procedural (for example a
-canvas-drawn expanding-ring atlas) — they are not generated assets.
-
-## Required controls
-
-- precipitation density and speed;
-- wind direction and strength;
-- shared weather progress or coverage;
-- wetness, snow, or puddle mask threshold and softness;
-- ripple or drift normal strength;
-- surface roughness response;
-- particle/splash opacity;
-- debug modes for masks, normals, particles, and event progress.
-
-## Failure conditions
-
-- falling precipitation ignores the wind or timing used by surface response;
-- snow height and snow normals come from different fields;
-- model snow sticks to vertical faces without an upward-facing filter;
-- puddles only lower roughness without a mask, normal response, or ripples;
-- splashes appear on downward or hidden faces;
-- rain streaks allocate per drop or fail to wrap around the camera;
-- temporal wetness is faked with unrelated time noise.
-
-## Routing boundary
-
-Use `$genex-threejs-water-optics` for bounded pool simulation, caustics, Fresnel,
-refraction, and Beer-Lambert water volumes. Use `$genex-threejs-procedural-vfx` for
-general sparks, plasma, trails, and non-weather particles. Use
-`$genex-threejs-temporal-surfaces` for screen-space touch history or frost clearing.
-This skill owns precipitation events and the surfaces they visibly alter.