@driftengine/core 4.2.1 → 4.4.0

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

@@ -0,0 +1,47 @@
+/**
+ * The lens and the print: a vignette in scene light, and grain in display values.
+ *
+ * **The vignette is the lens's, so it acts on light rather than on the picture.** A lens loses light
+ * toward its corners by roughly the fourth power of the cosine of the angle off axis, which for a
+ * point `r` from the centre is `1 / (1 + k r^2)^2`. Applied to scene light before the tone curve,
+ * a bright corner rolls off through the curve's shoulder the way a photographed one does, where a
+ * vignette painted over the finished picture greys it. `r` is measured to the frame's corner on a
+ * circle, not an ellipse, so a wide window is not darker at its sides than at its top.
+ *
+ * **The grain is the print's, so it acts on display values after the grade and the veil.** It is
+ * one value a pixel, the same on all three channels, weighted toward the midtones where film shows
+ * it and kept faint in deep shadow and highlight, where adding it would lift black and grey white.
+ * It also dithers: a dark gradient quantised to eight bits bands, and a noise of a few levels breaks
+ * the bands up. **The seed is the caller's**, because the engine takes time from its caller: a held
+ * capture passes the same seed and is identical run to run, and a playing scene passes a new one
+ * each frame and the grain moves as film does.
+ *
+ * Zero strength for each is the whole of its off path: a branch on a uniform, and the frame is what
+ * it was byte for byte.
+ */
+/**
+ * `uVignette`, `uGrain`, `withVignette` and `withGrain`. The rush composite includes it once.
+ *
+ * `withVignette` takes the pixel's coordinate and the scene's size, since a distance to the corner
+ * has to know the aspect. `withGrain` takes the fragment's integer position, so the grain is one
+ * value a pixel whatever the resolution.
+ */
+export declare const FILM_LOOK_GLSL = "\n/** How strongly the lens darkens its corners: 0 is none, 0.5 about 1.2 stops at the corner. */\nuniform float uVignette;\n/** x: the grain's amplitude in display values, 0 for none. y: this frame's seed, the caller's. */\nuniform vec2 uGrain;\n\nvec3 withVignette(vec3 c, vec2 uv, vec2 size) {\n  if (uVignette <= 0.0) return c;\n  vec2 d = (uv - 0.5) * size;\n  vec2 corner = 0.5 * size;\n  float r2 = dot(d, d) / dot(corner, corner);\n  float falloff = 1.0 + uVignette * r2;\n  return c / (falloff * falloff);\n}\n\nfloat grainNoise(uvec2 p, uint seed) {\n  uint h = p.x * 1664525u + p.y * 1013904223u + seed * 2654435769u;\n  h ^= h >> 16u;\n  h *= 2246822519u;\n  h ^= h >> 13u;\n  h *= 3266489917u;\n  h ^= h >> 16u;\n  return float(h) * (1.0 / 4294967295.0);\n}\n\nvec3 withGrain(vec3 c, vec2 fragCoord) {\n  if (uGrain.x <= 0.0) return c;\n  float luma = dot(clamp(c, 0.0, 1.0), vec3(0.2126, 0.7152, 0.0722));\n  float weight = 0.25 + 3.0 * luma * (1.0 - luma);\n  float n = grainNoise(uvec2(fragCoord), uint(uGrain.y)) - 0.5;\n  return c + vec3(2.0 * n * uGrain.x * weight);\n}\n";
+/**
+ * The vignette's factor at `uv` on a `width` by `height` frame, as the shader computes it.
+ * The shader's arithmetic written out once more, so a test can pin it to hand-derived values.
+ */
+export declare function vignetteFactor(u: number, v: number, width: number, height: number, strength: number): number;
+/** How much of the grain a display luminance takes: full in the midtones, a quarter at the ends. */
+export declare function grainWeight(luma: number): number;
+/** Both backends' words when there is no composite to apply the look in. */
+export declare const FILM_LOOK_WITHOUT_COMPOSITE: string;
+/** A vignette strength as the shader takes it: 0 to 4, anything else off. */
+export declare function clampVignette(strength: number): number;
+/** A grain amplitude in display values: 0 to 0.5, anything else off. */
+export declare function clampGrain(strength: number): number;
+/**
+ * A seed as the shader reads it: a whole number below 2^24, which a 32-bit float carries exactly,
+ * so the same seed is the same grain on both backends. Any number a caller has is accepted.
+ */
+export declare function grainSeed(seed: number): number;

package/dist/render/shaders/filmLook.js

@@ -0,0 +1,98 @@
+/**
+ * The lens and the print: a vignette in scene light, and grain in display values.
+ *
+ * **The vignette is the lens's, so it acts on light rather than on the picture.** A lens loses light
+ * toward its corners by roughly the fourth power of the cosine of the angle off axis, which for a
+ * point `r` from the centre is `1 / (1 + k r^2)^2`. Applied to scene light before the tone curve,
+ * a bright corner rolls off through the curve's shoulder the way a photographed one does, where a
+ * vignette painted over the finished picture greys it. `r` is measured to the frame's corner on a
+ * circle, not an ellipse, so a wide window is not darker at its sides than at its top.
+ *
+ * **The grain is the print's, so it acts on display values after the grade and the veil.** It is
+ * one value a pixel, the same on all three channels, weighted toward the midtones where film shows
+ * it and kept faint in deep shadow and highlight, where adding it would lift black and grey white.
+ * It also dithers: a dark gradient quantised to eight bits bands, and a noise of a few levels breaks
+ * the bands up. **The seed is the caller's**, because the engine takes time from its caller: a held
+ * capture passes the same seed and is identical run to run, and a playing scene passes a new one
+ * each frame and the grain moves as film does.
+ *
+ * Zero strength for each is the whole of its off path: a branch on a uniform, and the frame is what
+ * it was byte for byte.
+ */
+/**
+ * `uVignette`, `uGrain`, `withVignette` and `withGrain`. The rush composite includes it once.
+ *
+ * `withVignette` takes the pixel's coordinate and the scene's size, since a distance to the corner
+ * has to know the aspect. `withGrain` takes the fragment's integer position, so the grain is one
+ * value a pixel whatever the resolution.
+ */
+export const FILM_LOOK_GLSL = `
+/** How strongly the lens darkens its corners: 0 is none, 0.5 about 1.2 stops at the corner. */
+uniform float uVignette;
+/** x: the grain's amplitude in display values, 0 for none. y: this frame's seed, the caller's. */
+uniform vec2 uGrain;
+
+vec3 withVignette(vec3 c, vec2 uv, vec2 size) {
+  if (uVignette <= 0.0) return c;
+  vec2 d = (uv - 0.5) * size;
+  vec2 corner = 0.5 * size;
+  float r2 = dot(d, d) / dot(corner, corner);
+  float falloff = 1.0 + uVignette * r2;
+  return c / (falloff * falloff);
+}
+
+float grainNoise(uvec2 p, uint seed) {
+  uint h = p.x * 1664525u + p.y * 1013904223u + seed * 2654435769u;
+  h ^= h >> 16u;
+  h *= 2246822519u;
+  h ^= h >> 13u;
+  h *= 3266489917u;
+  h ^= h >> 16u;
+  return float(h) * (1.0 / 4294967295.0);
+}
+
+vec3 withGrain(vec3 c, vec2 fragCoord) {
+  if (uGrain.x <= 0.0) return c;
+  float luma = dot(clamp(c, 0.0, 1.0), vec3(0.2126, 0.7152, 0.0722));
+  float weight = 0.25 + 3.0 * luma * (1.0 - luma);
+  float n = grainNoise(uvec2(fragCoord), uint(uGrain.y)) - 0.5;
+  return c + vec3(2.0 * n * uGrain.x * weight);
+}
+`;
+/**
+ * The vignette's factor at `uv` on a `width` by `height` frame, as the shader computes it.
+ * The shader's arithmetic written out once more, so a test can pin it to hand-derived values.
+ */
+export function vignetteFactor(u, v, width, height, strength) {
+    if (strength <= 0)
+        return 1;
+    const dx = (u - 0.5) * width;
+    const dy = (v - 0.5) * height;
+    const r2 = (dx * dx + dy * dy) / (0.25 * (width * width + height * height));
+    const falloff = 1 + strength * r2;
+    return 1 / (falloff * falloff);
+}
+/** How much of the grain a display luminance takes: full in the midtones, a quarter at the ends. */
+export function grainWeight(luma) {
+    const l = Math.min(Math.max(luma, 0), 1);
+    return 0.25 + 3 * l * (1 - l);
+}
+/** Both backends' words when there is no composite to apply the look in. */
+export const FILM_LOOK_WITHOUT_COMPOSITE = '[driftengine] setVignette and setFilmGrain need `screenEffects`: without a composite every ' +
+    'pass is the last thing to touch the frame, so there is no one place to apply a lens or a ' +
+    'print. The look was not applied.';
+/** A vignette strength as the shader takes it: 0 to 4, anything else off. */
+export function clampVignette(strength) {
+    return Number.isFinite(strength) ? Math.min(Math.max(strength, 0), 4) : 0;
+}
+/** A grain amplitude in display values: 0 to 0.5, anything else off. */
+export function clampGrain(strength) {
+    return Number.isFinite(strength) ? Math.min(Math.max(strength, 0), 0.5) : 0;
+}
+/**
+ * A seed as the shader reads it: a whole number below 2^24, which a 32-bit float carries exactly,
+ * so the same seed is the same grain on both backends. Any number a caller has is accepted.
+ */
+export function grainSeed(seed) {
+    return Number.isFinite(seed) ? Math.floor(Math.abs(seed)) % 16777216 : 0;
+}

package/dist/render/shaders/flat/directionalShadow.js

@@ -67,10 +67,13 @@ float shadowFactor(float directionalNdl) {
   // Near a surface's own light terminator its direct-light term is already
   // approaching zero, while the orthographic projection of that surface
   // collapses toward a line. No finite contact-safe bias can represent that
-  // slope reliably. Fade only the shadow modulation through this narrow band;
-  // the Lambert term still supplies the physically dominant falloff.
+  // slope reliably, so through this band the fine filter below hands over to the
+  // coarse test after it. \`directionalNdl\` is the surface's own, before any normal
+  // map: the band is about the receiving plane, and a map's tilt says nothing about it.
   float receiverFade = smoothstep(0.08, 0.20, directionalNdl);
-  if (receiverFade <= 0.0) return 1.0;
+  /* A surface turned from the light takes none of it, so there is nothing to shadow; what reads
+     this there is the emissive share, which has always seen such a surface as unshadowed. */
+  if (directionalNdl <= 0.0) return 1.0;
 
   // The receiver stays at its real position, computed above. A normal offset changes
   // direction at a hard mesh edge and tears one continuous shadow where it crosses from
@@ -103,6 +106,34 @@ float shadowFactor(float directionalNdl) {
   );
   if (lowElevationFade <= 0.0) return 1.0;
 
+  /*
+   * **The coarse test: is there anything a metre or more between this point and the sun.**
+   *
+   * One tap at the receiver's own texel, with a metre of tolerance where the filter below allows
+   * fourteen centimetres. It cannot see a contact shadow, and it does not need the plane's slope:
+   * a grazing plane's own depth moves about a centimetre times the tangent of its angle to the
+   * light across a texel, which stays under a metre down to a hundredth of n·l on a map with
+   * centimetre texels. What it does see is a roof.
+   *
+   * **This band used to return fully lit**, on the argument that the Lambert term was already
+   * near zero there. Under a high sun that is every vertical wall: at 70° of elevation a wall's
+   * n·l is at most 0.34, and one turned from the sun's bearing sits inside the band. A gallery's
+   * back wall under its vault took the sun through the vault, and so did the faces of its
+   * columns, which read as lit stone in shade; with a normal map carrying that n·l per texel it
+   * was a field of white specks. What would make this wrong is a map whose texels are tens of
+   * centimetres, where a grazing plane's own depth moves more than the tolerance and the band
+   * draws the acne it exists to avoid.
+   */
+  float coarseCompare = p.z - 1.0 / uShadowDepthSpan;
+  float coarse =
+    directionalVisibility(p.z, coarseCompare, textureLod(uStaticShadowMap, p.xy, 0.0).r) *
+    directionalVisibility(p.z, coarseCompare, textureLod(uDynamicShadowMap, p.xy, 0.0).r);
+  if (uPeeledShadowEnabled != 0) {
+    coarse *= directionalVisibility(p.z, coarseCompare, textureLod(uPeeledShadowMap, p.xy, 0.0).r);
+  }
+  float strength = uShadowStrength * edgeFade * lowElevationFade;
+  if (receiverFade <= 0.0) return mix(1.0, coarse, strength);
+
   float texel = 1.35 / uShadowMapSize;
   /*
    * How far the plane compensation below may carry a tap's depth, in the map's own units.
@@ -181,7 +212,7 @@ float shadowFactor(float directionalNdl) {
   // conventional one-depth map would discard; movers remain independent too.
   float lit = staticLit * peeledLit * dynamicLit;
 
-  return mix(1.0, lit, uShadowStrength * edgeFade * lowElevationFade * receiverFade);
+  return mix(1.0, mix(coarse, lit, receiverFade), strength);
 }
 #endif
 

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

@@ -0,0 +1,29 @@
+/**
+ * DriftLight in the lit shader: how much of a pixel the summed light stands in for, and the summed
+ * light itself, read from the field's sparse volume.
+ *
+ * **The split is per pixel.** Inside the frame's completeness radius (`uDriftLight.y`, measured from
+ * the eye) every light that reaches the pixel was chosen, so it is shaded exactly; past it the
+ * volume stands in, and across the band before the radius the two crossfade. The choice was made
+ * about some centre, which need not be the eye; `uniforms.ts` takes the distance between the two
+ * off the radius, so a pixel inside it is inside the choice's radius too. A field light's
+ * exact contribution is scaled by the share left over (`main.ts`, where its weight's sign is read),
+ * so a light is counted once however the pixel is split.
+ *
+ * **One index fetch and two filtered ones.** The index finds the brick; the brick's four samples a
+ * side share their faces with the next brick's, so the hardware's trilinear lookup inside one is
+ * seamless across the join. The light texel carries in its fourth channel whether each sample is a
+ * sample at all, and dividing by the filtered value drops the samples buried in walls rather than
+ * blending their darkness into the surface. The lookup is nudged half a spacing along the normal,
+ * which keeps a surface reading the air in front of it rather than the wall it is part of.
+ *
+ * **Two vectors of uniforms, and the sizes read off the textures.** The lit stage sits two vectors
+ * under the 256 a reported part offers at eight lights, and the first cut of this, at five, took that
+ * part down a rung to four. So the grid's extent and the atlas's are what `textureSize` answers, and
+ * the radius is measured from `uCameraPos`, which the stage already has, rather than from a centre
+ * of its own. What it gives up is two integer queries a pixel past the radius.
+ *
+ * `textureLod` throughout, by the 2026-08-07 rule: this is reached through branches no compiler can
+ * prove uniform. Both samplers are declared `highp` because GLSL ES gives 3D samplers no default.
+ */
+export declare const DRIFT_LIGHT_GLSL = "\n/** x how much of the summed light is in the frame (0 off), y the radius, z the band, w the scale. */\nuniform vec4 uDriftLight;\n/** xyz the first brick's first sample; w metres between samples, a third of a brick. */\nuniform vec4 uDriftLightOrigin;\nuniform highp usampler3D uDriftLightIndex;  // wgsl:share shadow\nuniform highp sampler3D uDriftLightAtlas;\n\n/** The share of this pixel's field light the volume stands in for: 0 inside the radius, 1 past it. */\nfloat driftLightShare(vec3 world) {\n  if (uDriftLight.x <= 0.0) return 0.0;\n  float away = distance(world, uCameraPos);\n  return smoothstep(uDriftLight.y - uDriftLight.z, uDriftLight.y, away) * uDriftLight.x;\n}\n\n/** The summed light arriving on a surface at `world` facing `n`. */\nvec3 driftLightIrradiance(vec3 world, vec3 n) {\n  float spacing = uDriftLightOrigin.w;\n  vec3 at = (world + n * (0.5 * spacing) - uDriftLightOrigin.xyz) / (3.0 * spacing);\n  ivec3 cell = ivec3(floor(at));\n  if (any(lessThan(cell, ivec3(0))) || any(greaterThanEqual(cell, textureSize(uDriftLightIndex, 0)))) {\n    return vec3(0.0);\n  }\n  uint id = texelFetch(uDriftLightIndex, cell, 0).r;\n  if (id == 0u) return vec3(0.0);\n  /* A brick is eight texels across (its light block, then its direction block) and four up and deep. */\n  ivec3 size = textureSize(uDriftLightAtlas, 0);\n  int brick = int(id) - 1;\n  int across = size.x / 8;\n  int down = size.y / 4;\n  vec3 corner = vec3(\n    float((brick % across) * 8),\n    float(((brick / across) % down) * 4),\n    float((brick / (across * down)) * 4)\n  );\n  vec3 texel = 1.0 / vec3(size);\n  vec3 inside = (at - vec3(cell)) * 3.0 + 0.5;\n  vec4 light = textureLod(uDriftLightAtlas, (corner + inside) * texel, 0.0);\n  if (light.a < 1e-3) return vec3(0.0);\n  vec4 toward = textureLod(uDriftLightAtlas, (corner + vec3(4.0, 0.0, 0.0) + inside) * texel, 0.0);\n  vec3 arriving = light.rgb / light.a;\n  vec3 from = toward.xyz / light.a;\n  /* Lambert for a single light, a quarter for light arriving from everywhere: see `bake.ts`. */\n  float facing = max(dot(n, from), 0.0) + (1.0 - min(length(from), 1.0)) * 0.25;\n  return arriving * facing;\n}\n";

package/dist/render/shaders/flat/driftLight.js

@@ -0,0 +1,75 @@
+/**
+ * DriftLight in the lit shader: how much of a pixel the summed light stands in for, and the summed
+ * light itself, read from the field's sparse volume.
+ *
+ * **The split is per pixel.** Inside the frame's completeness radius (`uDriftLight.y`, measured from
+ * the eye) every light that reaches the pixel was chosen, so it is shaded exactly; past it the
+ * volume stands in, and across the band before the radius the two crossfade. The choice was made
+ * about some centre, which need not be the eye; `uniforms.ts` takes the distance between the two
+ * off the radius, so a pixel inside it is inside the choice's radius too. A field light's
+ * exact contribution is scaled by the share left over (`main.ts`, where its weight's sign is read),
+ * so a light is counted once however the pixel is split.
+ *
+ * **One index fetch and two filtered ones.** The index finds the brick; the brick's four samples a
+ * side share their faces with the next brick's, so the hardware's trilinear lookup inside one is
+ * seamless across the join. The light texel carries in its fourth channel whether each sample is a
+ * sample at all, and dividing by the filtered value drops the samples buried in walls rather than
+ * blending their darkness into the surface. The lookup is nudged half a spacing along the normal,
+ * which keeps a surface reading the air in front of it rather than the wall it is part of.
+ *
+ * **Two vectors of uniforms, and the sizes read off the textures.** The lit stage sits two vectors
+ * under the 256 a reported part offers at eight lights, and the first cut of this, at five, took that
+ * part down a rung to four. So the grid's extent and the atlas's are what `textureSize` answers, and
+ * the radius is measured from `uCameraPos`, which the stage already has, rather than from a centre
+ * of its own. What it gives up is two integer queries a pixel past the radius.
+ *
+ * `textureLod` throughout, by the 2026-08-07 rule: this is reached through branches no compiler can
+ * prove uniform. Both samplers are declared `highp` because GLSL ES gives 3D samplers no default.
+ */
+export const DRIFT_LIGHT_GLSL = /* glsl */ `
+/** x how much of the summed light is in the frame (0 off), y the radius, z the band, w the scale. */
+uniform vec4 uDriftLight;
+/** xyz the first brick's first sample; w metres between samples, a third of a brick. */
+uniform vec4 uDriftLightOrigin;
+uniform highp usampler3D uDriftLightIndex;  // wgsl:share shadow
+uniform highp sampler3D uDriftLightAtlas;
+
+/** The share of this pixel's field light the volume stands in for: 0 inside the radius, 1 past it. */
+float driftLightShare(vec3 world) {
+  if (uDriftLight.x <= 0.0) return 0.0;
+  float away = distance(world, uCameraPos);
+  return smoothstep(uDriftLight.y - uDriftLight.z, uDriftLight.y, away) * uDriftLight.x;
+}
+
+/** The summed light arriving on a surface at \`world\` facing \`n\`. */
+vec3 driftLightIrradiance(vec3 world, vec3 n) {
+  float spacing = uDriftLightOrigin.w;
+  vec3 at = (world + n * (0.5 * spacing) - uDriftLightOrigin.xyz) / (3.0 * spacing);
+  ivec3 cell = ivec3(floor(at));
+  if (any(lessThan(cell, ivec3(0))) || any(greaterThanEqual(cell, textureSize(uDriftLightIndex, 0)))) {
+    return vec3(0.0);
+  }
+  uint id = texelFetch(uDriftLightIndex, cell, 0).r;
+  if (id == 0u) return vec3(0.0);
+  /* A brick is eight texels across (its light block, then its direction block) and four up and deep. */
+  ivec3 size = textureSize(uDriftLightAtlas, 0);
+  int brick = int(id) - 1;
+  int across = size.x / 8;
+  int down = size.y / 4;
+  vec3 corner = vec3(
+    float((brick % across) * 8),
+    float(((brick / across) % down) * 4),
+    float((brick / (across * down)) * 4)
+  );
+  vec3 texel = 1.0 / vec3(size);
+  vec3 inside = (at - vec3(cell)) * 3.0 + 0.5;
+  vec4 light = textureLod(uDriftLightAtlas, (corner + inside) * texel, 0.0);
+  if (light.a < 1e-3) return vec3(0.0);
+  vec4 toward = textureLod(uDriftLightAtlas, (corner + vec3(4.0, 0.0, 0.0) + inside) * texel, 0.0);
+  vec3 arriving = light.rgb / light.a;
+  vec3 from = toward.xyz / light.a;
+  /* Lambert for a single light, a quarter for light arriving from everywhere: see \`bake.ts\`. */
+  float facing = max(dot(n, from), 0.0) + (1.0 - min(length(from), 1.0)) * 0.25;
+  return arriving * facing;
+}
+`;

package/dist/render/shaders/flat/index.js

@@ -2,6 +2,7 @@ import { resolveConditionals } from '../conditionals.js';
 import { OCTAHEDRAL_GLSL } from '../octahedral.js';
 import { PROBEGRID_GLSL } from './probeGrid.js';
 import { TANGENT_FRAME_GLSL } from '../tangentFrame.js';
+import { CUTOUT_COVERAGE_GLSL } from '../cutoutCoverage.js';
 import { preambleGlsl } from './preamble.js';
 import { LOBES_GLSL } from './lobes.js';
 import { POINTSHADOW_GLSL } from './pointShadow.js';
@@ -10,6 +11,7 @@ import { MORPH_GLSL } from '../morph.js';
 import { SKINNING_GLSL } from '../skinning.js';
 import { SURFACE_GLSL } from './surface.js';
 import { MAIN_GLSL } from './main.js';
+import { DRIFT_LIGHT_GLSL } from './driftLight.js';
 import { CHANNEL_ATTRIBUTE, CHANNEL_BEND } from '../vertexChannel.js';
 import { FULL_LIGHT_BUDGET } from '../../uniformVectorBudget.js';
 /**
@@ -377,6 +379,9 @@ export function flatFrag(options) {
          * and `main` is unconditional by construction.
          */
         TANGENT_FRAME_GLSL,
+        /* Unconditional for the same reason, and called only where a cutoff was asked for. */
+        CUTOUT_COVERAGE_GLSL,
+        DRIFT_LIGHT_GLSL,
         MAIN_GLSL,
     ].join('\n'), {
         POINT_SHADOWS: options.pointShadows,

package/dist/render/shaders/flat/lobes.js

@@ -71,6 +71,19 @@ const float PENUMBRA_FADE = 1.6;
  */
 const float MAX_FILTER_RADIUS = 0.25;
 
+/**
+ * The weight below which a point light's shadow is not looked up at all.
+ *
+ * A light's shadow is blended toward none as the light falls off, \`mix(1, occl, weight)\` with the
+ * weight twice the falloff, so a shadow looked up under this floor changes at most three per cent
+ * of a light that has already all but faded: with the inverse-square falloff, past about eight
+ * metres from it. Measured on a lantern-lit courtyard, the lookups the floor skips were most of a
+ * night's frame: 14 ms of 26 at 1440p, a blocker tap and twelve filter taps for every light in every
+ * froxel. What it gives up is the last three per cent of a distant light's shadow, which the blend
+ * was already taking away; what would make it wrong is a falloff that stays strong far out.
+ */
+const float POINT_SHADOW_MIN_WEIGHT = 0.03;
+
 /**
  * How much of a self-lit surface's glow a lamp's shadow may take.
  *