@driftengine/core 3.61.0

package/dist/render/shaders/film.js

@@ -0,0 +1,283 @@
+import { FOG_GLSL } from './fog.js';
+/**
+ * A thin, wet, iridescent film lying on a surface.
+ *
+ * The material an oil slick is made of, described without knowing what oil is.
+ * Flat dark geometry cannot do this job — it reads as a hole in the world, which
+ * is exactly how the first version looked. What makes a film read as *wet* is
+ * that it changes with the angle you see it from: almost black looking straight
+ * down, and a shifting sheen at a glance.
+ *
+ * Textureless, per the standing rule. The iridescence is a hue swept by the
+ * view angle plus a slow travelling ripple, both evaluated per fragment; the
+ * rainbow is generated rather than sampled.
+ */
+export const FILM_VERT = `#version 300 es
+precision highp float;
+
+layout(location = 0) in vec3 aPosition;
+layout(location = 1) in vec3 aNormal;
+layout(location = 2) in vec3 aColor;
+/*
+ * Coverage, on the attribute the mesh format calls emissive.
+ *
+ * A film has no use for self-illumination, and it very much needs an edge that
+ * dissolves: the first oil was flat squares, and a hard straight edge is what made
+ * it read as a decal dropped on the world rather than a puddle lying in it. One
+ * float per vertex, 1 in the middle of a slick and 0 at its rim.
+ */
+layout(location = 3) in float aCoverage;
+
+uniform mat4 uViewProj;
+/* The mirrored camera's projection, so a film can sample the planar target the way water does. */
+uniform mat4 uReflectionViewProj;
+
+out vec3 vWorld;
+out vec3 vNormal;
+out vec3 vTint;
+out vec4 vReflectionClip;
+out float vCoverage;
+
+void main() {
+  vWorld = aPosition;
+  vNormal = normalize(aNormal);
+  vTint = aColor;
+  vCoverage = aCoverage;
+  vReflectionClip = uReflectionViewProj * vec4(aPosition, 1.0);
+  gl_Position = uViewProj * vec4(aPosition, 1.0);
+}
+`;
+export const FILM_FRAG = `#version 300 es
+precision highp float;
+
+in vec3 vWorld;
+in vec3 vNormal;
+in vec3 vTint;
+in vec4 vReflectionClip;
+/*
+ * The scene mirrored across the plane this film lies on, and how much of it to show.
+ *
+ * **Sheen is iridescence and this is the image**, which is the split a consumer asked for after
+ * finding that raising sheen to make a road wetter only made it oilier. A wet street at night is
+ * defined by everything above it appearing twice, and no amount of interference pattern is that.
+ *
+ * The projection is the water shader's, unchanged and deliberately so: reproducing it outside the
+ * engine is the piece most likely to be subtly wrong and least likely to be noticed, since a
+ * mirror off by a small skew looks like a wet road until somebody puts a straight line across it.
+ */
+uniform sampler2D uReflectionMap;
+uniform int uReflectionEnabled;
+uniform float uReflectionStrength;
+in float vCoverage;
+
+uniform vec3 uCameraPos;
+uniform float uTime;
+/*
+ * The mirrored pass clips at the water plane, and it does so **in the fragment
+ * shader** rather than with gl_ClipDistance.
+ *
+ * That is not a style choice. Clip distances in WebGL2 need
+ * EXT_clip_cull_distance both enabled on the context and declared with an
+ * #extension line, and without the declaration the shader fails to *compile* —
+ * which, since programs are built when the renderer is constructed, takes the
+ * whole boot with it and leaves a black screen. This shader had never been
+ * compiled when it was written, so the mistake sat harmlessly in the file until
+ * the day it was wired to something. Discarding is what flat.ts does, it needs
+ * no extension, and a film is a thin translucent layer where the cost of a
+ * discarded fragment is nothing.
+ */
+uniform vec4 uClipPlane;
+uniform int uClipEnabled;
+${FOG_GLSL}
+/** How strong the sheen is. Zero leaves a plain dark film. */
+uniform float uSheen;
+
+/**
+ * How rough the film's own surface is, 0 to 1, and how coarse that roughness is.
+ *
+ * **A film had exactly one finish before this: mirror.** That is right for standing water and
+ * wrong for the thing this pass is most used for, because a wet road is not a mirror — it is
+ * water lying *in* aggregate, and the stone underneath breaks the reflection into a smear. With
+ * no way to say so, a patch of film over a textured road met it at a hard rim: mirror on one
+ * side, stone on the other, with nothing able to cross it. Feathering the coverage cannot fix
+ * that, and it was tried — the alpha was never what the eye was reading.
+ *
+ * So the reflection is displaced by a noise field rather than blurred. **Displaced, because a
+ * blur is the wrong phenomenon**: a rough surface does not soften what it reflects, it scatters
+ * it, and a lamp on wet tarmac smears into a streak rather than becoming a soft disc. It is also
+ * what a blur cannot afford here — the mirror has no mip chain (see the \`textureLod\` note
+ * below), so softening it honestly would cost several taps where this costs none.
+ *
+ * \`uFilmRoughnessCycles\` is bumps to the metre, and it is the same quantity
+ * \`Renderer.setSurfaceRelief\` takes. **Matching it to the surface underneath is the point**:
+ * given the same field at the same scale, the water is broken up by the aggregate that the dry
+ * road beside it is showing, and the two stop being different materials.
+ *
+ * Zero is the mirror this pass has always been, exactly, so nothing that does not ask for
+ * roughness renders differently.
+ */
+uniform float uFilmRoughness;
+uniform float uFilmRoughnessCycles;
+
+out vec4 fragColor;
+
+/** A hue wheel, without a texture. Standard 6-segment ramp. */
+vec3 hue(float h) {
+  h = fract(h) * 6.0;
+  vec3 c = clamp(vec3(abs(h - 3.0) - 1.0, 2.0 - abs(h - 2.0), 2.0 - abs(h - 4.0)), 0.0, 1.0);
+  return c;
+}
+
+/**
+ * The same value noise \`flat.ts\` builds its relief from, and deliberately the same.
+ *
+ * Copied rather than shared because these two shaders have no common include beyond the fog, and
+ * a film that used a *different* field would defeat the whole purpose of taking a cycle count:
+ * the water would be broken up by one pattern and the road by another, which is two materials
+ * again with extra steps.
+ */
+float filmHash(vec3 p) {
+  p = fract(p * 0.1031);
+  p += dot(p, p.zyx + 31.32);
+  return fract((p.x + p.y) * p.z);
+}
+
+float filmNoise(vec3 p) {
+  vec3 i = floor(p);
+  vec3 f = fract(p);
+  vec3 u = f * f * (3.0 - 2.0 * f);
+  return mix(
+    mix(
+      mix(filmHash(i + vec3(0.0, 0.0, 0.0)), filmHash(i + vec3(1.0, 0.0, 0.0)), u.x),
+      mix(filmHash(i + vec3(0.0, 1.0, 0.0)), filmHash(i + vec3(1.0, 1.0, 0.0)), u.x),
+      u.y
+    ),
+    mix(
+      mix(filmHash(i + vec3(0.0, 0.0, 1.0)), filmHash(i + vec3(1.0, 0.0, 1.0)), u.x),
+      mix(filmHash(i + vec3(0.0, 1.0, 1.0)), filmHash(i + vec3(1.0, 1.0, 1.0)), u.x),
+      u.y
+    ),
+    u.z
+  );
+}
+
+void main() {
+  if (uClipEnabled != 0 && dot(vec4(vWorld, 1.0), uClipPlane) < 0.0) discard;
+
+  vec3 view = normalize(uCameraPos - vWorld);
+  float facing = max(dot(normalize(vNormal), view), 0.0);
+  /*
+   * Fresnel-ish: dark looking straight down at it, bright at a grazing angle.
+   * This is the whole effect — it is what makes a wet patch look wet rather
+   * than looking like a patch of dark paint.
+   */
+  float grazing = pow(1.0 - facing, 3.0);
+
+  /*
+   * A slow travelling interference, so the sheen crawls rather than sitting
+   * still. Two frequencies that do not divide each other, or the pattern
+   * repeats visibly across a long slick.
+   */
+  float ripple =
+    sin(vWorld.x * 0.73 + vWorld.z * 0.41 + uTime * 0.55) *
+    cos(vWorld.z * 0.91 - vWorld.x * 0.29 - uTime * 0.37);
+
+  vec3 sheen = hue(grazing * 1.35 + ripple * 0.14 + 0.55);
+  /*
+   * Dark underneath, so the film always reads as *less* than the surface it lies on even where
+   * the sheen is strongest — but not so dark that it disappears.
+   *
+   * A slick that has just launched somebody has to be findable afterwards. It was rounded,
+   * feathered and iridescent — and at a fifth of an opaque tint on a pale deck at dusk,
+   * invisible. A hazard you cannot find is not a hazard, it is a trap.
+   *
+   * So the base is darker and the sheen has a floor: even looking straight down, where the
+   * Fresnel term is nearly nothing, a slick is a distinctly wet patch rather than a faint one.
+   */
+  vec3 base = vTint * 0.9;
+  vec3 color = base + sheen * uSheen * (0.22 + grazing * 0.75);
+
+  /*
+   * The mirrored scene, under the sheen rather than instead of it.
+   *
+   * Screen-space from the mirrored clip position, exactly as the water pass does it, with the
+   * same fade as the sample leaves the target: a reflection that stopped dead at the edge of its
+   * own buffer would draw a line across the road where nothing is.
+   *
+   * Weighted by the grazing term as well as by strength, because that is what a reflection does:
+   * a wet surface underfoot shows almost nothing and the same surface down the street shows the
+   * whole scene. Added before the fog so the image recedes with everything else in the frame.
+   */
+  if (uReflectionEnabled != 0 && uReflectionStrength > 0.0 && vReflectionClip.w > 0.0) {
+    vec2 reflectionUv = vReflectionClip.xy / vReflectionClip.w * 0.5 + 0.5;
+    vec2 border = min(reflectionUv, 1.0 - reflectionUv);
+    float valid = smoothstep(0.0, 0.025, min(border.x, border.y));
+    /*
+     * An explicit level, not an implicit one, and the branch above is the whole reason.
+     *
+     * An implicit derivative inside control flow that is not provably uniform is what lets a
+     * compiler flatten the branch and pay for every arm — AGENTS.md, 2026-08-07 — and WGSL
+     * does not merely warn: the module fails to compile with "textureSample must only be
+     * called from uniform control flow", which invalidates the pipeline, which invalidates
+     * the command buffer, and the frame still presents. The fifth time on this branch. The
+     * mirror has no mip chain, so level 0 is the only level there is; the water shader
+     * reaches the same conclusion for the same lookup.
+     */
+    /*
+     * The aggregate under the water, as a displacement of what the water shows.
+     *
+     * The gradient of the same field the road's relief uses, taken across the surface and used
+     * to push the lookup. **Stretched along the reflection rather than isotropic**, and that is
+     * the half that makes it read as a road: a reflection on a rough horizontal surface smears
+     * *towards the viewer*, because a bump tilts the ray in the plane it is already travelling
+     * in. Displacing in a circle gives frosted glass instead, which is a different wet thing.
+     *
+     * Scaled by the grazing term for the same reason the mirror is: looking straight down at a
+     * puddle the reflection is compressed into almost nothing and a displacement of it would be
+     * enormous, so the scatter has to fall off exactly where the image does.
+     */
+    if (uFilmRoughness > 0.0) {
+      vec3 at = vWorld * uFilmRoughnessCycles;
+      float here = filmNoise(at);
+      vec2 slope = vec2(
+        filmNoise(at + vec3(0.5, 0.0, 0.0)) - here,
+        filmNoise(at + vec3(0.0, 0.0, 0.5)) - here
+      );
+      /* Along the view, which on a horizontal film is where the image runs. */
+      vec2 along = normalize(vec2(view.x, view.z) + vec2(1e-5, 0.0));
+      vec2 smear = along * dot(slope, along) * 3.0 + slope * 0.35;
+      reflectionUv += smear * uFilmRoughness * 0.016 * (0.2 + grazing * 0.8);
+      /* Re-fade at the border: a displaced sample can leave the target the original did not. */
+      vec2 movedBorder = min(reflectionUv, 1.0 - reflectionUv);
+      valid = min(valid, smoothstep(0.0, 0.025, min(movedBorder.x, movedBorder.y)));
+    }
+    vec3 mirrored = textureLod(uReflectionMap, clamp(reflectionUv, 0.0, 1.0), 0.0).rgb;
+    color = mix(color, mirrored, valid * uReflectionStrength * (0.25 + grazing * 0.75));
+  }
+
+  // The same fog every other pass applies — and now literally the same code, which
+  // it was not: this ran its own curve while claiming otherwise, so a slick receded
+  // at a different rate than the deck it was lying on.
+  float fog = mediumFog(length(uCameraPos - vWorld), vWorld.y);
+  color = mix(color, mediumColor(), fog);
+
+  /*
+   * Alpha from coverage, squared.
+   *
+   * Squared because a linear ramp across the rim still reads as a visible band —
+   * the eye finds the constant-gradient edge. Squaring pushes the falloff outward
+   * so the slick has a soft shoulder and no perceptible boundary. The sheen fades
+   * with it, which is right: the thinnest part of a film is the least iridescent.
+   */
+  /*
+   * Alpha from coverage, and the rim is what is squared — not the whole patch.
+   *
+   * Squaring the coverage outright made the *middle* translucent too, which is most of why a
+   * slick could not be found. The shoulder still needs to be soft, so the square is mixed in
+   * near the edge only: solid through the body, dissolving at the rim.
+   */
+  float coverage = clamp(vCoverage, 0.0, 1.0);
+  float alpha = mix(coverage * coverage, coverage, 0.65) * 0.92;
+  fragColor = vec4(color, alpha);
+}
+`;

package/dist/render/shaders/fire.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Procedural flames: camera-facing quads whose shape and colour come entirely
+ * from animated noise. No sprite sheets, no image assets — and no static
+ * geometry pretending to be fire either (AGENTS.md, fidelity).
+ *
+ * The flame silhouette is carved by thresholding rising turbulence against a
+ * tapered mask, so it licks and breaks up at the tip the way a real flame does
+ * rather than pulsing as a whole.
+ */
+/** Shared billboard vertex stage: used by fire, smoke and any future plume. */
+export declare const PLUME_VERT = "#version 300 es\nlayout(location = 0) in vec3 aCenter;\nlayout(location = 1) in vec2 aCorner;\nlayout(location = 2) in vec2 aSize;\nlayout(location = 3) in float aSeed;\nlayout(location = 4) in float aBlade;\n\nuniform mat4 uViewProj;\nuniform vec3 uCameraPos;\nuniform float uTime;\n/** Amplitude of the size pulse; 0 keeps the quad a fixed size. */\nuniform float uSizePulse;\n/**\n * Horizontal wind, m/s. Plumes lean with it, increasingly toward their top \u2014\n * the base is anchored to whatever is burning, the crown is free. Sharing one\n * wind with the rest of the world is the point: smoke drifting one way while\n * foliage leans another is the clearest tell that a scene is a pile of effects\n * rather than a place.\n */\nuniform vec2 uWind;\n/**\n * Whole-batch offset. Plume centres live in a static buffer because braziers\n * never move; a batch that *does* move \u2014 a tornado \u2014 shifts by a uniform rather\n * than rewriting geometry every frame.\n */\nuniform vec3 uOrigin;\n/** How strongly this plume type answers the wind; smoke far more than flame. */\nuniform float uWindResponse;\n\nout vec2 vUv;\nout float vSeed;\nout float vDistance;\nout vec3 vWorldPos;\n\n/**\n * Plumes are not a constant size: a fire flares and dies back, a smoke column\n * swells and thins. Two out-of-phase sines, offset per plume, so the whole\n * effect breathes rather than only its interior pattern animating.\n */\nfloat sizePulse(float seed) {\n  return 1.0 + uSizePulse * (\n    sin(uTime * 1.7 + seed * 9.1) * 0.62 +\n    sin(uTime * 3.3 + seed * 4.7) * 0.38\n  );\n}\n\nvoid main() {\n  // Height swells more than width, the way a real flame stretches upward.\n  vec3 anchor = aCenter + uOrigin;\n\n  /*\n   * No billboarding at all: the blade's heading is fixed in the world.\n   *\n   * Each plume is drawn as a CROSS of two blades 90 degrees apart (see BLADES in\n   * plumeRenderer), and aSeed advances by the golden ratio per plume, so the crosses\n   * themselves are scattered by the golden angle rather than aligned into a grid.\n   *\n   * Nothing here reads the camera, and that is the fix. Anything that does - a full\n   * billboard, or merely leaning edge-on cards toward the viewer - rotates geometry\n   * as the camera moves, which is exactly what reads as flat: orbiting a fire showed\n   * the same silhouette from every angle. A cross cannot track the viewer, so turning\n   * around a fire genuinely brings one blade broadside while the other goes edge-on.\n   * That is the parallax a volume has, and it is also why no blade needs to be turned\n   * to stay visible - its partner is square-on whenever it is not.\n   *\n   * World up stays the vertical axis: a flame that tilts with the camera reads as a\n   * decal.\n   */\n  vec3 up = vec3(0.0, 1.0, 0.0);\n  float yaw = aSeed * 6.28318530718 + aBlade * 1.57079632679;\n  vec3 right = vec3(cos(yaw), 0.0, sin(yaw));\n  float pulse = sizePulse(aSeed);\n  vec2 size = vec2(aSize.x * mix(1.0, pulse, 0.55), aSize.y * pulse);\n\n  float rise = aCorner.y * 0.5 + 0.5;\n  vec3 world = anchor\n    + right * (aCorner.x * size.x)\n    + up * (rise * size.y);\n\n  // Quadratic in height: a column bends away from its anchor rather than\n  // shearing uniformly, which would slide its base off the fire.\n  world.xz += uWind * (uWindResponse * rise * rise * size.y);\n\n  vUv = vec2(aCorner.x * 0.5 + 0.5, aCorner.y * 0.5 + 0.5);\n  vSeed = aSeed;\n  vDistance = distance(world, uCameraPos);\n  vWorldPos = world;\n  gl_Position = uViewProj * vec4(world, 1.0);\n}\n";
+export declare const FIRE_FRAG = "#version 300 es\nprecision highp float;\n\nin vec2 vUv;\nin float vSeed;\nin float vDistance;\nin vec3 vWorldPos;\n\nuniform float uTime;\n\nuniform vec3 uFogColor;\n/** Extinction per metre **at the camera's own height**, not at the base. */\nuniform float uFogDensity;\n/** Reciprocal scale height of the haze, per metre. 0 is a uniform medium. */\nuniform float uFogHeightFalloff;\n/** The camera's height, so a fragment's own height is one subtraction away. */\nuniform float uFogEyeY;\nuniform vec3 uUnderwaterColor;\nuniform float uUnderwaterFogDensity;\nuniform float uUnderwaterFactor;\n/** 0 integrates a medium (Beer-Lambert); 1 ramps linearly between near and far. */\nuniform int uFogMode;\n/** Linear mode only: where haze begins, and where it is total. */\nuniform float uFogNear;\nuniform float uFogFar;\n\n/** What distance converges toward: the day's haze, or the water column. */\nvec3 mediumColor() {\n  return mix(uFogColor, uUnderwaterColor, uUnderwaterFactor);\n}\n\n/**\n * How much of a surface standing at height pointY, dist metres away, is lost to\n * the medium in between. 0 is perfectly clear, 1 is the medium's own colour.\n */\nfloat mediumFog(float dist, float pointY) {\n  /*\n   * A depth ramp rather than a medium, for worlds authored against one.\n   *\n   * Beer-Lambert is the honest model and stays the default: it integrates something\n   * physically there, so extinction begins at the eye and never stops. A linear near/far\n   * fog is not that \u2014 it is a *look*, with a hard start distance before which the air is\n   * perfectly clear, and it is what the fixed-function pipeline offered and what several\n   * renderers still expose. Approximating one with the other is not a matter of tuning:\n   * matched at half occlusion, the exponential curve still lays haze over everything\n   * inside near, where the ramp lays none, and near-field colour desaturates toward the\n   * fog colour with nothing to show for it.\n   *\n   * Height falloff has no meaning here and is ignored: a ramp is defined on distance\n   * alone.\n   */\n  if (uFogMode == 1) {\n    float span = max(uFogFar - uFogNear, 1e-4);\n    float ramp = clamp((dist - uFogNear) / span, 0.0, 1.0);\n    if (uUnderwaterFactor <= 0.0) return ramp;\n    float wetLinear = uUnderwaterFogDensity * dist;\n    return mix(ramp, 1.0 - exp2(-wetLinear * wetLinear * 1.442695), uUnderwaterFactor);\n  }\n\n  float t = (pointY - uFogEyeY) * uFogHeightFalloff;\n  // (1 - e^-t)/t, which tends to 1 as the ray levels out. Guarded rather than\n  // branched: at t = 0 the quotient is 0/0, and 1e-4 of a scale height is 8 mm.\n  float denom = abs(t) < 1e-4 ? 1e-4 : t;\n  float air = 1.0 - exp(-uFogDensity * dist * (1.0 - exp(-denom)) / denom);\n  if (uUnderwaterFactor <= 0.0) return air;\n  // Water is its own medium and keeps its own curve, so crossing the surface\n  // changes nothing about how the water column reads.\n  float wet = uUnderwaterFogDensity * dist;\n  return mix(air, 1.0 - exp2(-wet * wet * 1.442695), uUnderwaterFactor);\n}\n\nuniform int uNoiseOctaves;\nuniform vec4 uClipPlane;\nuniform int uClipEnabled;\n\nout vec4 outColor;\n\nfloat hash21(vec2 p) {\n  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);\n}\n\nfloat valueNoise(vec2 p) {\n  vec2 i = floor(p);\n  vec2 f = fract(p);\n  vec2 u = f * f * (3.0 - 2.0 * f);\n  return mix(\n    mix(hash21(i), hash21(i + vec2(1.0, 0.0)), u.x),\n    mix(hash21(i + vec2(0.0, 1.0)), hash21(i + vec2(1.0, 1.0)), u.x),\n    u.y\n  );\n}\n\n/** Rising turbulence: octaves scrolled upward at different rates. */\nfloat turbulence(vec2 p, float t) {\n  float v = valueNoise(p * 3.0 + vec2(0.0, -t * 1.9)) * 0.55;\n  if (uNoiseOctaves == 1) return v / 0.55;\n  v += valueNoise(p * 6.5 + vec2(t * 0.3, -t * 3.1)) * 0.28;\n  if (uNoiseOctaves == 2) return v / 0.83;\n  return v + valueNoise(p * 13.0 + vec2(-t * 0.2, -t * 4.6)) * 0.17;\n}\n\nvoid main() {\n  if (uClipEnabled != 0 && dot(vec4(vWorldPos, 1.0), uClipPlane) < 0.0) discard;\n\n  vec2 uv = vUv;\n  float t = uTime + vSeed * 37.0;\n\n  // Taper toward the tip and pinch the sides, so the quad never shows.\n  float sides = 1.0 - abs(uv.x - 0.5) * 2.0;\n  float taper = sides * (1.0 - uv.y * 0.72);\n  if (taper <= 0.0) discard;\n\n  // Sway: the column leans and wanders instead of standing to attention.\n  float sway = (valueNoise(vec2(t * 0.55, vSeed * 11.0)) - 0.5) * 0.34 * uv.y;\n  vec2 p = vec2(uv.x + sway, uv.y);\n\n  float n = turbulence(p, t);\n  // Flame body: noise must beat a threshold that rises with height, which is\n  // what makes the tip break into separate licks.\n  float body = n * taper * 1.9 - uv.y * 0.55;\n  if (body <= 0.02) discard;\n\n  // Colour ramp: white-hot core through yellow and orange to a dark red edge.\n  float heat = clamp(body * 1.5, 0.0, 1.0);\n  vec3 col = mix(vec3(0.62, 0.06, 0.02), vec3(1.0, 0.45, 0.06), smoothstep(0.0, 0.45, heat));\n  col = mix(col, vec3(1.0, 0.85, 0.35), smoothstep(0.45, 0.75, heat));\n  col = mix(col, vec3(1.0, 0.98, 0.88), smoothstep(0.78, 1.0, heat));\n\n  float alpha = clamp(body * 2.2, 0.0, 1.0) * (1.0 - smoothstep(0.72, 1.0, uv.y));\n  // Additive light must lose alpha as it scatters, or mixing its colour alone\n  // still makes a distant flame glow through fog and through water.\n  float fog = mediumFog(vDistance, vWorldPos.y);\n  col = mix(col, mediumColor(), fog);\n  alpha *= 1.0 - fog;\n\n  outColor = vec4(col, alpha);\n}\n";

package/dist/render/shaders/fire.js

@@ -0,0 +1,178 @@
+import { FOG_GLSL } from './fog.js';
+/**
+ * Procedural flames: camera-facing quads whose shape and colour come entirely
+ * from animated noise. No sprite sheets, no image assets — and no static
+ * geometry pretending to be fire either (AGENTS.md, fidelity).
+ *
+ * The flame silhouette is carved by thresholding rising turbulence against a
+ * tapered mask, so it licks and breaks up at the tip the way a real flame does
+ * rather than pulsing as a whole.
+ */
+/** Shared billboard vertex stage: used by fire, smoke and any future plume. */
+export const PLUME_VERT = `#version 300 es
+layout(location = 0) in vec3 aCenter;
+layout(location = 1) in vec2 aCorner;
+layout(location = 2) in vec2 aSize;
+layout(location = 3) in float aSeed;
+layout(location = 4) in float aBlade;
+
+uniform mat4 uViewProj;
+uniform vec3 uCameraPos;
+uniform float uTime;
+/** Amplitude of the size pulse; 0 keeps the quad a fixed size. */
+uniform float uSizePulse;
+/**
+ * Horizontal wind, m/s. Plumes lean with it, increasingly toward their top —
+ * the base is anchored to whatever is burning, the crown is free. Sharing one
+ * wind with the rest of the world is the point: smoke drifting one way while
+ * foliage leans another is the clearest tell that a scene is a pile of effects
+ * rather than a place.
+ */
+uniform vec2 uWind;
+/**
+ * Whole-batch offset. Plume centres live in a static buffer because braziers
+ * never move; a batch that *does* move — a tornado — shifts by a uniform rather
+ * than rewriting geometry every frame.
+ */
+uniform vec3 uOrigin;
+/** How strongly this plume type answers the wind; smoke far more than flame. */
+uniform float uWindResponse;
+
+out vec2 vUv;
+out float vSeed;
+out float vDistance;
+out vec3 vWorldPos;
+
+/**
+ * Plumes are not a constant size: a fire flares and dies back, a smoke column
+ * swells and thins. Two out-of-phase sines, offset per plume, so the whole
+ * effect breathes rather than only its interior pattern animating.
+ */
+float sizePulse(float seed) {
+  return 1.0 + uSizePulse * (
+    sin(uTime * 1.7 + seed * 9.1) * 0.62 +
+    sin(uTime * 3.3 + seed * 4.7) * 0.38
+  );
+}
+
+void main() {
+  // Height swells more than width, the way a real flame stretches upward.
+  vec3 anchor = aCenter + uOrigin;
+
+  /*
+   * No billboarding at all: the blade's heading is fixed in the world.
+   *
+   * Each plume is drawn as a CROSS of two blades 90 degrees apart (see BLADES in
+   * plumeRenderer), and aSeed advances by the golden ratio per plume, so the crosses
+   * themselves are scattered by the golden angle rather than aligned into a grid.
+   *
+   * Nothing here reads the camera, and that is the fix. Anything that does - a full
+   * billboard, or merely leaning edge-on cards toward the viewer - rotates geometry
+   * as the camera moves, which is exactly what reads as flat: orbiting a fire showed
+   * the same silhouette from every angle. A cross cannot track the viewer, so turning
+   * around a fire genuinely brings one blade broadside while the other goes edge-on.
+   * That is the parallax a volume has, and it is also why no blade needs to be turned
+   * to stay visible - its partner is square-on whenever it is not.
+   *
+   * World up stays the vertical axis: a flame that tilts with the camera reads as a
+   * decal.
+   */
+  vec3 up = vec3(0.0, 1.0, 0.0);
+  float yaw = aSeed * 6.28318530718 + aBlade * 1.57079632679;
+  vec3 right = vec3(cos(yaw), 0.0, sin(yaw));
+  float pulse = sizePulse(aSeed);
+  vec2 size = vec2(aSize.x * mix(1.0, pulse, 0.55), aSize.y * pulse);
+
+  float rise = aCorner.y * 0.5 + 0.5;
+  vec3 world = anchor
+    + right * (aCorner.x * size.x)
+    + up * (rise * size.y);
+
+  // Quadratic in height: a column bends away from its anchor rather than
+  // shearing uniformly, which would slide its base off the fire.
+  world.xz += uWind * (uWindResponse * rise * rise * size.y);
+
+  vUv = vec2(aCorner.x * 0.5 + 0.5, aCorner.y * 0.5 + 0.5);
+  vSeed = aSeed;
+  vDistance = distance(world, uCameraPos);
+  vWorldPos = world;
+  gl_Position = uViewProj * vec4(world, 1.0);
+}
+`;
+export const FIRE_FRAG = `#version 300 es
+precision highp float;
+
+in vec2 vUv;
+in float vSeed;
+in float vDistance;
+in vec3 vWorldPos;
+
+uniform float uTime;
+${FOG_GLSL}
+uniform int uNoiseOctaves;
+uniform vec4 uClipPlane;
+uniform int uClipEnabled;
+
+out vec4 outColor;
+
+float hash21(vec2 p) {
+  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);
+}
+
+float valueNoise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  vec2 u = f * f * (3.0 - 2.0 * f);
+  return mix(
+    mix(hash21(i), hash21(i + vec2(1.0, 0.0)), u.x),
+    mix(hash21(i + vec2(0.0, 1.0)), hash21(i + vec2(1.0, 1.0)), u.x),
+    u.y
+  );
+}
+
+/** Rising turbulence: octaves scrolled upward at different rates. */
+float turbulence(vec2 p, float t) {
+  float v = valueNoise(p * 3.0 + vec2(0.0, -t * 1.9)) * 0.55;
+  if (uNoiseOctaves == 1) return v / 0.55;
+  v += valueNoise(p * 6.5 + vec2(t * 0.3, -t * 3.1)) * 0.28;
+  if (uNoiseOctaves == 2) return v / 0.83;
+  return v + valueNoise(p * 13.0 + vec2(-t * 0.2, -t * 4.6)) * 0.17;
+}
+
+void main() {
+  if (uClipEnabled != 0 && dot(vec4(vWorldPos, 1.0), uClipPlane) < 0.0) discard;
+
+  vec2 uv = vUv;
+  float t = uTime + vSeed * 37.0;
+
+  // Taper toward the tip and pinch the sides, so the quad never shows.
+  float sides = 1.0 - abs(uv.x - 0.5) * 2.0;
+  float taper = sides * (1.0 - uv.y * 0.72);
+  if (taper <= 0.0) discard;
+
+  // Sway: the column leans and wanders instead of standing to attention.
+  float sway = (valueNoise(vec2(t * 0.55, vSeed * 11.0)) - 0.5) * 0.34 * uv.y;
+  vec2 p = vec2(uv.x + sway, uv.y);
+
+  float n = turbulence(p, t);
+  // Flame body: noise must beat a threshold that rises with height, which is
+  // what makes the tip break into separate licks.
+  float body = n * taper * 1.9 - uv.y * 0.55;
+  if (body <= 0.02) discard;
+
+  // Colour ramp: white-hot core through yellow and orange to a dark red edge.
+  float heat = clamp(body * 1.5, 0.0, 1.0);
+  vec3 col = mix(vec3(0.62, 0.06, 0.02), vec3(1.0, 0.45, 0.06), smoothstep(0.0, 0.45, heat));
+  col = mix(col, vec3(1.0, 0.85, 0.35), smoothstep(0.45, 0.75, heat));
+  col = mix(col, vec3(1.0, 0.98, 0.88), smoothstep(0.78, 1.0, heat));
+
+  float alpha = clamp(body * 2.2, 0.0, 1.0) * (1.0 - smoothstep(0.72, 1.0, uv.y));
+  // Additive light must lose alpha as it scatters, or mixing its colour alone
+  // still makes a distant flame glow through fog and through water.
+  float fog = mediumFog(vDistance, vWorldPos.y);
+  col = mix(col, mediumColor(), fog);
+  alpha *= 1.0 - fog;
+
+  outColor = vec4(col, alpha);
+}
+`;

package/dist/render/shaders/flat/directionalShadow.d.ts

@@ -0,0 +1 @@
+export declare const DIRECTIONALSHADOW_GLSL: string;