@aethervtt/shard-structure 0.0.0-stage → 0.2.0

package/dist/components.d.ts

@@ -0,0 +1,156 @@
+/** A light channel (0069): `sight` (unset) follows the sight channel. */
+export declare const LIGHT_CHANNELS: readonly ['sight', 'normal', 'none'];
+export declare const Level: import("@aethervtt/shard-core").ComponentDef<{
+    readonly index: import("@aethervtt/shard-core").FieldType<number, "i8">;
+    readonly elevation: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly height: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly interiorAmbient: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    readonly interiorFill: import("@aethervtt/shard-core").FieldType<number, "f32">;
+}>;
+export declare const WALL_SHAPES: readonly ['straight', 'arc', 'bezier'];
+export declare const Wall: import("@aethervtt/shard-core").ComponentDef<{
+    readonly level: import("@aethervtt/shard-core").FieldType<number | null, "f64">;
+    readonly a: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+    readonly b: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+    readonly height: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly thickness: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly elevation: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly material: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").AssetRef<"Material"> | null, "object">;
+    readonly shape: import("@aethervtt/shard-core").FieldType<"arc" | "bezier" | "straight", "u8">;
+    readonly bow: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly c0: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+    readonly c1: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+    readonly light: import("@aethervtt/shard-core").FieldType<"none" | "normal" | "sight", "u8">;
+}>;
+export declare const OPENING_KINDS: readonly ['door', 'window'];
+export declare const HINGES: readonly ['start', 'end'];
+export declare const SWINGS: readonly ['left', 'right'];
+export declare const DOOR_STATES: readonly ['closed', 'open', 'locked'];
+export declare const CHANNELS: readonly ['normal', 'none'];
+export declare const Opening: import("@aethervtt/shard-core").ComponentDef<{
+    readonly wall: import("@aethervtt/shard-core").FieldType<number | null, "f64">;
+    readonly kind: import("@aethervtt/shard-core").FieldType<"door" | "window", "u8">;
+    readonly offset: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly width: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly height: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly sill: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly frameWidth: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly frameDepth: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly frameMaterial: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").AssetRef<"Material"> | null, "object">;
+    readonly hinge: import("@aethervtt/shard-core").FieldType<"end" | "start", "u8">;
+    readonly swing: import("@aethervtt/shard-core").FieldType<"left" | "right", "u8">;
+    readonly state: import("@aethervtt/shard-core").FieldType<"closed" | "locked" | "open", "u8">;
+    readonly sight: import("@aethervtt/shard-core").FieldType<"none" | "normal", "u8">;
+    readonly movement: import("@aethervtt/shard-core").FieldType<"none" | "normal", "u8">;
+    readonly light: import("@aethervtt/shard-core").FieldType<"none" | "normal" | "sight", "u8">;
+}>;
+export declare const Floor: import("@aethervtt/shard-core").ComponentDef<{
+    readonly level: import("@aethervtt/shard-core").FieldType<number | null, "f64">;
+    readonly points: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2[], "object">;
+    readonly elevation: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly thickness: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly material: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").AssetRef<"Material"> | null, "object">;
+}>;
+export declare const Roof: import("@aethervtt/shard-core").ComponentDef<{
+    readonly level: import("@aethervtt/shard-core").FieldType<number | null, "f64">;
+    readonly points: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2[], "object">;
+    readonly height: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly pitch: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly ridge: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+    readonly thickness: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly material: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").AssetRef<"Material"> | null, "object">;
+    readonly shadowWhenHidden: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+    readonly cutaway: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+}>;
+export declare const CUTOUT_KINDS: readonly ['hole', 'hatch', 'skylight'];
+export declare const Cutout: import("@aethervtt/shard-core").ComponentDef<{
+    readonly host: import("@aethervtt/shard-core").FieldType<number | null, "f64">;
+    readonly points: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2[], "object">;
+    readonly kind: import("@aethervtt/shard-core").FieldType<"hatch" | "hole" | "skylight", "u8">;
+    readonly frameWidth: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly frameDepth: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly frameMaterial: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").AssetRef<"Material"> | null, "object">;
+    readonly hinge: import("@aethervtt/shard-core").FieldType<number, "u16">;
+    readonly state: import("@aethervtt/shard-core").FieldType<"closed" | "locked" | "open", "u8">;
+}>;
+export declare const StructureChunk: import("@aethervtt/shard-core").ComponentDef<{
+    readonly group: import("@aethervtt/shard-core").FieldType<number | null, "f64">;
+    readonly x: import("@aethervtt/shard-core").FieldType<number, "i32">;
+    readonly z: import("@aethervtt/shard-core").FieldType<number, "i32">;
+}>;
+export declare const DoorLeaf: import("@aethervtt/shard-core").ComponentDef<{
+    readonly opening: import("@aethervtt/shard-core").FieldType<number | null, "f64">;
+    readonly angle: import("@aethervtt/shard-core").FieldType<number, "f32">;
+}>;
+/** A chunk's contact shade mesh (0068): one per (group, chunk) with walls near floors. */
+export declare const ContactMesh: import("@aethervtt/shard-core").TagDef;
+/** Glass in a window: a pane that structure spawns and keeps. */
+export declare const WindowPane: import("@aethervtt/shard-core").TagDef;
+/** Contact shade (0068): noisy dark strips where walls meet floors and each other. */
+export interface ContactSettings {
+    /** false despawns every contact mesh: no draws, no compile work. */
+    enabled: boolean;
+    /** Floor strips run from a wall's face out this far (m). */
+    floorReach: number;
+    /** Corner strips run from a joint along the face this far (m). */
+    cornerReach: number;
+    /** Alpha scale of the falloff. */
+    opacity: number;
+    /** Alpha never goes above this. */
+    maxAlpha: number;
+    /** What it darkens toward: linear, display-referred. */
+    color: [number, number, number];
+    /** How far the noise moves a strip's edge, as a share of its reach (0 to 1). */
+    wobble: number;
+}
+/** Contact shade's defaults: Aether's, in metres. */
+export declare function defaultContact(): ContactSettings;
+export declare const INTERIOR_QUALITIES: readonly ['low', 'medium', 'high'];
+export type InteriorQuality = (typeof INTERIOR_QUALITIES)[number];
+/** Interior lighting (0069), with interiorLightingPlugin. */
+export interface InteriorSettings {
+    /** Sky visibility: ambient and image-based light scaled by how much sky reaches a point. */
+    sky: boolean;
+    /** Point and spot lights with blockedByWalls are occluded by their level's walls. */
+    blockLights: boolean;
+    /** low: 0.5 m field, 256 bins, 1 tap; medium: 0.25 m, 512, 3; high: 0.125 m, 1024, 5. */
+    quality: InteriorQuality;
+    /** How far sky light spills through an opening (m): the field's screening length. */
+    spillReach: number;
+    /** Rows for blocked lights; more are lit unblocked, with structure/too-many-blocked-lights. */
+    maxBlockedLights: number;
+}
+/** Interior lighting's defaults. */
+export declare function defaultInterior(): InteriorSettings;
+export interface StructureSettingsValue {
+    /** Chunk edge, world units. Changing it rebuilds every chunk. */
+    chunkSize: number;
+    /** How long a door takes to swing, ms. */
+    doorSwingMs: number;
+    /** Doors snap open and closed instead of swinging. */
+    reducedMotion: boolean;
+    /**
+     * How far a curved wall's chords may stray from the curve, metres (0066). planarBarriers must
+     * use the same value, so a server blocks what's drawn. Changing it rebuilds every chunk.
+     */
+    curveTolerance: number;
+    /**
+     * Contact shade (0068). A patch may hold only the fields it changes: the rest keep their values.
+     * Turning it off or on, or changing a reach, rebuilds only contact meshes; the other fields
+     * rebuild nothing.
+     */
+    contact: ContactSettings;
+    /**
+     * Walls open around cameras' reveal points (0070): wall pieces (frames included) draw in meshes
+     * of their own, apart from floors, tagged Cutaway, and so are door leaves and window panes.
+     * Changing it rebuilds every chunk with walls.
+     */
+    cutawayWalls: boolean;
+    /**
+     * Interior lighting (0069), with interiorLightingPlugin. A patch may hold only the fields it
+     * changes. Turning a part off frees its texture; quality or spill reach re-solves the field and
+     * rebuilds every row once.
+     */
+    interior: InteriorSettings;
+}
+export declare const StructureSettings: import("@aethervtt/shard-core").ResourceDef<StructureSettingsValue>;

package/dist/components.js

@@ -0,0 +1,294 @@
+import { defineComponent, defineResource, defineTag, t } from "@aethervtt/shard-core";
+import { Transform } from "@aethervtt/shard-transform";
+const LEVEL_FIELD = {
+  level: t.entity({
+    description: "The Level it stands on (0067). Empty is the ground level; elevation is relative to the level."
+  })
+};
+const LIGHT_CHANNELS = ["sight", "normal", "none"];
+const lightField = (what) => t.enum(LIGHT_CHANNELS, {
+  description: `Whether ${what} blocks light (0069): sky light spilling in, and wall-blocked lights. sight (unset) follows its sight channel; set it for a curtain that blocks sight but not light, or the opposite.`
+});
+const Level = defineComponent(
+  "structure/Level",
+  {
+    index: t.i8({
+      min: -16,
+      max: 15,
+      description: "Stacking order: a cellar is -1, the ground level 0. Use it as the GroundLayer.level of what stands on the level."
+    }),
+    elevation: t.f32({
+      unit: "m",
+      description: "Where the level's floor stands (y). Pieces on it are placed relative to it."
+    }),
+    height: t.f32({ default: 3, min: 0, unit: "m", description: "Floor to ceiling." }),
+    interiorAmbient: t.vec3({
+      unit: "cd/m\xB2",
+      description: "Interior lighting (0069): ambient light where the sky doesn't reach, linear colour, added to interiorFill's share of the sky's. A cellar darker than a hall."
+    }),
+    interiorFill: t.f32({
+      default: 0.05,
+      min: 0,
+      max: 1,
+      description: "Interior lighting (0069): the share of the view's sky ambient (uniform or image-based) kept where the sky doesn't reach."
+    })
+  },
+  {
+    description: "A level (0067): its walls, floors and roofs compile into its own group of chunk meshes, children of this entity, so Visibility on it hides the level without a rebuild.",
+    requires: [Transform]
+  }
+);
+const WALL_SHAPES = ["straight", "arc", "bezier"];
+const Wall = defineComponent(
+  "structure/Wall",
+  {
+    a: t.vec2({ description: "Start of the centreline, (x, z) in world units." }),
+    b: t.vec2({ description: "End of the centreline, (x, z) in world units." }),
+    height: t.f32({ default: 3, min: 0, unit: "m", description: "Height above elevation." }),
+    thickness: t.f32({ default: 0.2, min: 0, unit: "m", description: "Full thickness." }),
+    elevation: t.f32({ unit: "m", description: "Where the wall stands (y), above its level." }),
+    ...LEVEL_FIELD,
+    material: t.handle("Material", { description: "Surface material. Empty uses a plain grey." }),
+    shape: t.enum(WALL_SHAPES, {
+      description: "straight; arc (bowed by bow); bezier (a cubic through c0 and c1)."
+    }),
+    bow: t.f32({
+      unit: "m",
+      description: "Arc: how far the midpoint bows off the line from a to b; positive bows to the left of a \u2192 b. More than half the chord is a major arc."
+    }),
+    c0: t.vec2({ description: "B\xE9zier: the first control point, (x, z)." }),
+    c1: t.vec2({ description: "B\xE9zier: the second control point, (x, z)." }),
+    light: lightField("it")
+  },
+  {
+    description: "A wall: straight, an arc or a B\xE9zier (0066). Structure compile draws it into chunked, per-material meshes; the entity itself draws nothing."
+  }
+);
+const OPENING_KINDS = ["door", "window"];
+const HINGES = ["start", "end"];
+const SWINGS = ["left", "right"];
+const DOOR_STATES = ["closed", "open", "locked"];
+const CHANNELS = ["normal", "none"];
+const Opening = defineComponent(
+  "structure/Opening",
+  {
+    wall: t.entity({ description: "The host wall entity." }),
+    kind: t.enum(OPENING_KINDS, {
+      description: "A door (with a leaf that swings) or a window (with glass)."
+    }),
+    offset: t.f32({
+      min: 0,
+      unit: "m",
+      description: "Distance from the wall's start to the opening."
+    }),
+    width: t.f32({ default: 1, min: 0, unit: "m", description: "Width along the wall." }),
+    height: t.f32({ default: 2.1, min: 0, unit: "m", description: "Height of the hole." }),
+    sill: t.f32({
+      min: 0,
+      unit: "m",
+      description: "Height of the hole's bottom above the wall's base."
+    }),
+    frameWidth: t.f32({
+      default: 0.08,
+      min: 0,
+      unit: "m",
+      description: "Width of the frame around the hole."
+    }),
+    frameDepth: t.f32({
+      default: 0.04,
+      min: 0,
+      unit: "m",
+      description: "How far the frame stands out from each face of the wall."
+    }),
+    frameMaterial: t.handle("Material", {
+      description: "Frame and door leaf material. Empty uses the built-in wood (structure:frame)."
+    }),
+    hinge: t.enum(HINGES, { description: "Doors: which end of the opening the leaf hangs from." }),
+    swing: t.enum(SWINGS, { description: "Doors: which side of the wall the leaf opens toward." }),
+    state: t.enum(DOOR_STATES, {
+      description: "Doors: a change swings the leaf and rebuilds no geometry."
+    }),
+    sight: t.enum(CHANNELS, {
+      description: "Whether it blocks sight when closed (planarBarriers)."
+    }),
+    movement: t.enum(CHANNELS, {
+      description: "Whether it blocks movement when closed (planarBarriers)."
+    }),
+    light: lightField("it, closed,")
+  },
+  { description: "A door or window cut into a wall." }
+);
+const Floor = defineComponent(
+  "structure/Floor",
+  {
+    points: t.list(t.vec2, {
+      description: "Outline, (x, z) in world units: a simple polygon of 3 to 256 points, either winding."
+    }),
+    elevation: t.f32({ unit: "m", description: "Height of the floor (y), above its level." }),
+    thickness: t.f32({
+      min: 0,
+      unit: "m",
+      description: "Slab thickness below the surface: 0 draws the top only; more adds the underside, the edges and the rims of its cutouts."
+    }),
+    material: t.handle("Material", { description: "Surface material. Empty uses a plain grey." }),
+    ...LEVEL_FIELD
+  },
+  {
+    description: "A flat floor polygon, triangulated once per edit (with its cutouts as holes) and clipped into chunks."
+  }
+);
+const Roof = defineComponent(
+  "structure/Roof",
+  {
+    points: t.list(t.vec2, {
+      description: "Footprint, (x, z): a simple polygon of 3 to 256 points, either winding."
+    }),
+    height: t.f32({
+      default: 3,
+      min: 0,
+      unit: "m",
+      description: "The eaves' height above its level's elevation."
+    }),
+    pitch: t.f32({
+      min: 0,
+      max: 80,
+      unit: "deg",
+      description: "0 is flat; more is one slope rising toward ridge from the lowest point."
+    }),
+    ridge: t.vec2({ default: [0, 1], description: "The direction the slope rises, (x, z)." }),
+    thickness: t.f32({ default: 0.2, min: 0, unit: "m", description: "Measured straight down." }),
+    material: t.handle("Material", { description: "Surface material. Empty uses a plain grey." }),
+    shadowWhenHidden: t.bool({
+      default: true,
+      description: "While hidden (Visibility), it still casts shadows, keeping the interior dark."
+    }),
+    cutaway: t.bool({
+      description: "Opens around cameras' reveal points (CutawayView, 0070) instead of hiding whole: its chunk meshes, hatches and skylights are Cutaway. It still casts whole."
+    }),
+    ...LEVEL_FIELD
+  },
+  {
+    description: "A roof (0067): its own group of chunk meshes, children of this entity, so it hides alone and nothing under it rebuilds.",
+    requires: [Transform]
+  }
+);
+const CUTOUT_KINDS = ["hole", "hatch", "skylight"];
+const Cutout = defineComponent(
+  "structure/Cutout",
+  {
+    host: t.entity({ description: "The Floor or Roof it cuts." }),
+    points: t.list(t.vec2, {
+      description: "The hole, (x, z): a simple polygon inside its host, either winding."
+    }),
+    kind: t.enum(CUTOUT_KINDS, {
+      description: "hole (a gap), hatch (a leaf that swings up) or skylight (glass)."
+    }),
+    frameWidth: t.f32({
+      default: 0.06,
+      min: 0,
+      unit: "m",
+      description: "Width of the frame around the hole, on the host surface."
+    }),
+    frameDepth: t.f32({
+      default: 0.03,
+      min: 0,
+      unit: "m",
+      description: "How far the frame stands above the host surface."
+    }),
+    frameMaterial: t.handle("Material", {
+      description: "Frame and hatch leaf material. Empty uses the built-in wood (structure:frame)."
+    }),
+    hinge: t.u16({
+      description: "Hatches: the outline edge the leaf hangs from (edge i runs from point i to i + 1)."
+    }),
+    state: t.enum(DOOR_STATES, {
+      description: "Hatches: a change swings the leaf and rebuilds no geometry."
+    })
+  },
+  { description: "A hole, hatch or skylight cut into a floor or a roof (0067)." }
+);
+const StructureChunk = defineComponent(
+  "structure/Chunk",
+  {
+    group: t.entity({
+      readonly: true,
+      description: "The group it belongs to: a Level, a Roof, or the ground level."
+    }),
+    x: t.i32({ readonly: true, description: "Chunk column (x / chunkSize)." }),
+    z: t.i32({ readonly: true, description: "Chunk row (z / chunkSize)." })
+  },
+  {
+    description: "One group's geometry in one chunk and one material, rebuilt by structure compile.",
+    serialize: false,
+    save: false
+  }
+);
+const DoorLeaf = defineComponent(
+  "structure/DoorLeaf",
+  {
+    opening: t.entity({
+      readonly: true,
+      description: "The Opening (a door or window) or Cutout (a hatch or skylight) it belongs to."
+    }),
+    angle: t.f32({ readonly: true, description: "How far open, 0 (closed) to 1 (open)." })
+  },
+  {
+    description: "A door leaf (or a window pane) that structure spawns for an opening. Picks resolve through `opening`.",
+    serialize: false,
+    save: false
+  }
+);
+const ContactMesh = defineTag("structure/ContactMesh", { serialize: false, save: false });
+const WindowPane = defineTag("structure/WindowPane", { serialize: false, save: false });
+function defaultContact() {
+  return {
+    enabled: true,
+    floorReach: 0.7,
+    cornerReach: 0.43,
+    opacity: 0.2,
+    maxAlpha: 0.42,
+    color: [33e-4, 52e-4, 8e-3],
+    wobble: 0.2
+  };
+}
+const INTERIOR_QUALITIES = ["low", "medium", "high"];
+function defaultInterior() {
+  return { sky: true, blockLights: true, quality: "medium", spillReach: 3, maxBlockedLights: 256 };
+}
+const StructureSettings = defineResource("structure/Settings", {
+  description: "Chunk size, door swing time, reduced motion, curve tolerance, contact shade, cutaway walls and interior lighting. Write with patchResource.",
+  init: () => ({
+    chunkSize: 8,
+    doorSwingMs: 250,
+    reducedMotion: false,
+    curveTolerance: 0.01,
+    contact: defaultContact(),
+    cutawayWalls: false,
+    interior: defaultInterior()
+  }),
+  hostWritable: true
+});
+export {
+  CHANNELS,
+  CUTOUT_KINDS,
+  ContactMesh,
+  Cutout,
+  DOOR_STATES,
+  DoorLeaf,
+  Floor,
+  HINGES,
+  INTERIOR_QUALITIES,
+  LIGHT_CHANNELS,
+  Level,
+  OPENING_KINDS,
+  Opening,
+  Roof,
+  SWINGS,
+  StructureChunk,
+  StructureSettings,
+  WALL_SHAPES,
+  Wall,
+  WindowPane,
+  defaultContact,
+  defaultInterior
+};

package/dist/contact-shade.d.ts

@@ -0,0 +1,4 @@
+/** The material key of the built-in contact shade. */
+export declare const CONTACT_KEY = "structure:contact";
+export declare const ContactShade: import("@aethervtt/shard-render").MaterialType;
+export declare const CONTACT_SHADERS: Record<string, string>;

package/dist/contact-shade.js

@@ -0,0 +1,76 @@
+import { t } from "@aethervtt/shard-core";
+import { defineMaterial } from "@aethervtt/shard-render";
+import { CONTACT_CORE, CONTACT_CORE_BOOST } from "./contact.js";
+const CONTACT_KEY = "structure:contact";
+const ContactShade = defineMaterial("structure/ContactShade", {
+  extends: "none",
+  blend: "alpha",
+  pickable: false,
+  fields: {
+    opacity: t.f32({ default: 0.2, min: 0, max: 1, description: "Alpha scale of the falloff." }),
+    maxAlpha: t.f32({ default: 0.42, min: 0, max: 1, description: "Alpha never goes above this." }),
+    color: t.vec3({
+      default: [33e-4, 52e-4, 8e-3],
+      min: 0,
+      description: "What it darkens toward: linear, display-referred (exposure is undone)."
+    }),
+    wobble: t.f32({
+      default: 0.2,
+      min: 0,
+      max: 1,
+      description: "How far the noise moves the strip's edge, as a share of its reach."
+    })
+  },
+  shader: "structure::contact",
+  description: "Structure's contact shade (0068): dark strips where walls meet floors and each other. Built in; StructureSettings.contact sets its fields."
+});
+const CONTACT_SHADERS = {
+  "structure::contact": `
+import shard::view::view;
+import shard::pbr::types::VertexOutput;
+import material::contact_shade::ContactShade;
+
+fn contact_hash(x: u32) -> u32 {
+  var h = x * 747796405u + 2891336453u;
+  h = ((h >> ((h >> 28u) + 4u)) ^ h) * 277803737u;
+  return (h >> 22u) ^ h;
+}
+
+fn contact_cell(c: vec2i) -> f32 {
+  let h = contact_hash(bitcast<u32>(c.x) ^ contact_hash(bitcast<u32>(c.y)));
+  return f32(h >> 8u) * (1.0 / 16777216.0);
+}
+
+/** One octave of value noise in [0, 1]. */
+fn contact_noise(p: vec2f) -> f32 {
+  let i = floor(p);
+  let f = p - i;
+  let u = f * f * (3.0 - 2.0 * f);
+  let c = vec2i(i);
+  return mix(
+    mix(contact_cell(c), contact_cell(c + vec2i(1, 0)), u.x),
+    mix(contact_cell(c + vec2i(0, 1)), contact_cell(c + vec2i(1, 1)), u.x),
+    u.y,
+  );
+}
+
+/** u is fade: 0 at the contact line, 1 at the reach. */
+override fn shade(in: VertexOutput) -> vec4f {
+  let p = in.world_position;
+  // World space, so strips meet across chunks and walls; y folds in for the corner strips.
+  let n = contact_noise(vec2f(p.x + p.y * 0.61, p.z - p.y * 0.83) / 0.6);
+  let wobble = clamp(ContactShade.wobble, 0.0, 1.0);
+  let fade = in.uv.x;
+  let f = clamp(fade * (1.0 + wobble * (2.0 * n - 1.0)), 0.0, 1.0);
+  let falloff = 1.0 - smoothstep(0.0, 1.0, f);
+  let core = 1.0 - smoothstep(0.0, ${CONTACT_CORE.toFixed(2)}, f);
+  let edge = 1.0 - smoothstep(0.8, 1.0, fade);
+  let alpha = ContactShade.opacity * (falloff * (0.8 + 0.2 * falloff) + core * ${CONTACT_CORE_BOOST.toFixed(2)}) * (0.94 + 0.12 * n);
+  return vec4f(ContactShade.color / max(view.exposure, 1e-12), min(ContactShade.maxAlpha, alpha) * edge);
+}`
+};
+export {
+  CONTACT_KEY,
+  CONTACT_SHADERS,
+  ContactShade
+};

package/dist/contact.d.ts

@@ -0,0 +1,65 @@
+import { type MeshBuilder, type OpeningShape, type WallShape } from './geometry.js';
+/** Floats per quad: its normal (x, y, z, 0), then four corners (x, y, z, fade). */
+export declare const CONTACT_STRIDE = 20;
+/** Floor strips are walked in pieces of at most this (m): each decides its sides on its own. */
+export declare const CONTACT_STEP = 1.8;
+/** How far strips stand off what they shade (m), above the floor or off the face. */
+export declare const CONTACT_LIFT = 0.002;
+/** Quads, grown as needed: `count` quads of CONTACT_STRIDE floats in `data`. */
+export declare class ContactQuads {
+    data: Float64Array<ArrayBuffer>;
+    count: number;
+    reset(): void;
+    /** Room for one more quad; returns its offset. */
+    next(): number;
+    /** Whether `other` holds the same quads (an edit that changed nothing here). */
+    equals(other: ContactQuads): boolean;
+    copy(other: ContactQuads): void;
+}
+export interface ContactReach {
+    /** Floor strips: from the face out to here (m). */
+    floorReach: number;
+    /** Corner strips: from the joint along the face to here (m). */
+    cornerReach: number;
+}
+/** What a wall's contact geometry needs to know about its surroundings. */
+export interface ContactEnv {
+    /**
+     * The top (y) of the floor on the wall's level containing (x, z), the one closest to `base` if
+     * several do; NaN if none does.
+     */
+    floorTop(x: number, z: number, base: number): number;
+    /**
+     * The joint at an end (0: the start, 1: the end), into `out`: the height the walls there share
+     * (y0, y1, before insets), and how far along the face the joined walls cover. False if no other
+     * wall meets that end.
+     */
+    joint(end: 0 | 1, out: Float64Array): boolean;
+}
+/**
+ * A wall's contact quads into `out` (reset first): floor strips on each side that faces a floor,
+ * skipping door openings (`openings` sorted by offset), and corner strips at joined ends.
+ */
+export declare function contactQuads(w: WallShape, openings: readonly OpeningShape[], reach: ContactReach, env: ContactEnv, out: ContactQuads): void;
+/** Adds the keys of every chunk a wall's contact quads have area (or length) in to `out`. */
+export declare function contactChunks(quads: ContactQuads, size: number, out: Set<number>): void;
+/**
+ * Emits the parts of contact quads inside one chunk square into `m`: positions, normals, and fade
+ * in u. Returns whether anything was emitted.
+ */
+export declare function emitContact(quads: ContactQuads, minX: number, minZ: number, maxX: number, maxZ: number, m: MeshBuilder): boolean;
+/** What the contact fragment reads (StructureSettings.contact's appearance). */
+export interface ContactLook {
+    opacity: number;
+    maxAlpha: number;
+    wobble: number;
+}
+/** The share of the reach the contact core darkens. */
+export declare const CONTACT_CORE = 0.1;
+/** How much the core adds over the falloff. */
+export declare const CONTACT_CORE_BOOST = 0.55;
+/**
+ * The contact strip's alpha at `fade` (0 at the contact line, 1 at the reach) for noise value `n`
+ * in [0, 1]: the CPU mirror of `structure::contact`'s shade. Non-increasing in fade for any n.
+ */
+export declare function contactAlpha(fade: number, n: number, look: ContactLook): number;