@adatechnology/game-fluids 0.1.8 → 0.2.1

package/dist/index.js

@@ -11,7 +11,7 @@ var liquids_default = [
     stainColor: 7309206,
     viscosity: 1,
     density: 1e3,
-    dryTime: 600,
+    dryTime: 180,
     gloss: 0.9,
     drink: {
       thirst: 100,
@@ -189,9 +189,9 @@ var liquids_default = [
     stainColor: 7232298,
     viscosity: 0.6,
     density: 740,
-    dryTime: 120,
+    dryTime: 60,
     gloss: 0.95,
-    leavesMark: true,
+    leavesMark: false,
     flammable: true,
     drink: {
       thirst: 0,
@@ -272,10 +272,10 @@ var liquids_default = [
     id: "blood",
     color: 7997964,
     opacity: 0.92,
-    stainColor: 4850950,
+    stainColor: 3874068,
     viscosity: 4,
     density: 1060,
-    dryTime: 1200,
+    dryTime: 600,
     gloss: 0.75,
     leavesMark: true,
     drink: {
@@ -288,6 +288,46 @@ var liquids_default = [
       "organic"
     ]
   },
+  {
+    id: "old_blood",
+    color: 7085078,
+    opacity: 0.92,
+    stainColor: 2758158,
+    viscosity: 4,
+    density: 1060,
+    dryTime: 360,
+    gloss: 0.7,
+    leavesMark: true,
+    drink: {
+      thirst: 10,
+      effects: [
+        "disgust"
+      ]
+    },
+    tags: [
+      "organic"
+    ]
+  },
+  {
+    id: "bile",
+    color: 9083434,
+    opacity: 0.9,
+    stainColor: 4080160,
+    viscosity: 6,
+    density: 1020,
+    dryTime: 900,
+    gloss: 0.75,
+    leavesMark: true,
+    drink: {
+      thirst: 0,
+      effects: [
+        "disgust"
+      ]
+    },
+    tags: [
+      "organic"
+    ]
+  },
   {
     id: "sap",
     color: 13146940,
@@ -530,6 +570,8 @@ var locales = {
       motor_oil: "motor oil",
       cooking_oil: "cooking oil",
       blood: "blood",
+      old_blood: "old blood",
+      bile: "bile",
       sap: "sap",
       acid: "acid",
       paint: "paint",
@@ -570,6 +612,8 @@ var locales = {
       motor_oil: "\xF3leo de motor",
       cooking_oil: "\xF3leo de cozinha",
       blood: "sangue",
+      old_blood: "sangue antigo",
+      bile: "bile",
       sap: "seiva",
       acid: "\xE1cido",
       paint: "tinta",
@@ -1081,7 +1125,7 @@ function createFluids(options = {}) {
     }
     if (victim) stains.delete(victim.id);
   };
-  const deposit = (liquid, hit, liters, velocity) => {
+  const deposit = (liquid, hit, liters, velocity, tint) => {
     const def = liquids.get(liquid);
     if (!def || liters <= 0) return;
     let s = stainAt(hit.surface, liquid, hit.point);
@@ -1089,6 +1133,7 @@ function createFluids(options = {}) {
       const basis2 = { normal: s.normal, t1: s.tangent, t2: cross(s.normal, s.tangent) };
       nudgeCenter(s, hit.point, clamp(liters / (s.liters + liters) * 0.5, 0, 0.5), basis2);
       addInflow(s, liters, velocity);
+      if (tint) s.tint = { ...tint };
       return;
     }
     while (stains.size >= maxStains) evictStain();
@@ -1096,6 +1141,7 @@ function createFluids(options = {}) {
     const basis = hit.surface === GROUND_ID ? makeBasis(hit.normal) : surface;
     s = createStain(`stain_${++counters.stain}`, hit.surface, def, basis, hit.point, liters, rng);
     if (velocity) addInflow(s, 0, velocity);
+    if (tint) s.tint = { ...tint };
     s.sinceInflow = 0;
     stains.set(s.id, s);
     emit({ type: "stain", stain: s.id, surface: hit.surface, liquid, point: copy3(hit.point) });
@@ -1288,7 +1334,8 @@ function createFluids(options = {}) {
     tangent: copy3(s.tangent),
     flow: s.flow ? copy3(s.flow) : void 0,
     mark: s.mark,
-    age: s.age
+    age: s.age,
+    tint: s.tint ? { ...s.tint } : void 0
   });
   const world = {
     liquids,
@@ -1473,14 +1520,14 @@ function createFluids(options = {}) {
       surfaces.delete(id);
       for (const s of [...stains.values()]) if (s.surface === id) stains.delete(s.id);
     },
-    splash(liquid, point, liters, velocity) {
+    splash(liquid, point, liters, velocity, options2) {
       if (!liquids.has(liquid) || !(liters > 0)) return;
       const v = velocity ?? [0, -0.1, 0];
       const origin = add(point, [0, 0.02, 0]);
       const hit = trace(landingSurfaces(), groundAt, origin, v, gravity);
       if (!hit) return;
       emit({ type: "splash", liquid, point: copy3(hit.point), intensity: clamp(0.3 + liters * 2, 0, 1) });
-      deposit(liquid, hit, liters, length(v) > 0.3 ? hit.velocity : null);
+      deposit(liquid, hit, liters, length(v) > 0.3 ? hit.velocity : null, options2?.tint);
     },
     clearStains(point, radius) {
       for (const s of [...stains.values()]) {
@@ -2168,17 +2215,996 @@ function createItemUse(world, containerId, def, getHandTransform) {
   };
   return player;
 }
+
+// src/film/deposit.ts
+var VISIBLE_THICKNESS = 0.035;
+function depositCell(context, rowIn, columnIn, amount) {
+  const { field } = context;
+  const row = Math.round(rowIn);
+  const column = Math.round(columnIn);
+  if (row < 0 || column < 0 || row >= field.height || column >= field.width || !(amount > 0)) return;
+  const index = row * field.width + column;
+  field.thickness[index] += amount;
+  if (amount > 0.02) field.dryness[index] *= 0.15;
+  field.dampness[index] = 1;
+}
+function wetCellCount(field) {
+  let cells = 0;
+  for (let index = 0; index < field.thickness.length; index++) if (field.thickness[index] > VISIBLE_THICKNESS) cells++;
+  return cells;
+}
+function depositBlob(context, centerRow, centerColumn, along, across, directionColumn, directionRow, amount, roughness) {
+  const random = context.random;
+  const phaseA = random() * 6.28;
+  const phaseB = random() * 6.28;
+  const phaseC = random() * 6.28;
+  const phaseD = random() * 6.28;
+  const reach = Math.ceil(Math.max(along, across) * (1 + roughness) + 1.5);
+  for (let row = Math.floor(centerRow - reach); row <= centerRow + reach; row++) {
+    for (let column = Math.floor(centerColumn - reach); column <= centerColumn + reach; column++) {
+      const dx = column + 0.5 - centerColumn;
+      const dy = row + 0.5 - centerRow;
+      const alongDistance = dx * directionColumn + dy * directionRow;
+      const acrossDistance = -dx * directionRow + dy * directionColumn;
+      const angle = Math.atan2(acrossDistance / across, alongDistance / along);
+      const edge = 1 + roughness * (0.45 * Math.sin(3 * angle + phaseA) + 0.3 * Math.sin(5 * angle + phaseB) + 0.18 * Math.sin(8 * angle + phaseC) + 0.12 * Math.sin(13 * angle + phaseD));
+      const squared = (alongDistance / along * (alongDistance / along) + acrossDistance / across * (acrossDistance / across)) / (edge * edge);
+      if (squared < 1) depositCell(context, row, column, amount * Math.sqrt(1 - squared));
+    }
+  }
+}
+function depositStroke(context, fromRow, fromColumn, toRow, toColumn, startWidth, endWidth, amount) {
+  const { field } = context;
+  const length2 = Math.hypot(toRow - fromRow, toColumn - fromColumn);
+  const samples = Math.max(2, Math.ceil(length2 * 2.5));
+  for (let sample = 0; sample <= samples; sample++) {
+    const progress = sample / samples;
+    const row = fromRow + (toRow - fromRow) * progress;
+    const column = fromColumn + (toColumn - fromColumn) * progress;
+    const width = startWidth + (endWidth - startWidth) * progress;
+    const reach = Math.ceil(width + 1);
+    for (let cellRow = Math.floor(row - reach); cellRow <= row + reach; cellRow++) {
+      for (let cellColumn = Math.floor(column - reach); cellColumn <= column + reach; cellColumn++) {
+        if (cellRow < 0 || cellColumn < 0 || cellRow >= field.height || cellColumn >= field.width) continue;
+        const distance2 = Math.hypot(cellRow + 0.5 - row, cellColumn + 0.5 - column);
+        if (distance2 >= width) continue;
+        const index = cellRow * field.width + cellColumn;
+        const target = amount * (1 - distance2 / width) * 0.5;
+        if (field.thickness[index] < target) depositCell(context, cellRow, cellColumn, target - field.thickness[index]);
+      }
+    }
+  }
+}
+function depositSplat(context, row, column, size, directionColumn, directionRow, sinAngleIn, amount) {
+  const random = context.random;
+  const spikes = context.profile().spikes;
+  const sinAngle = Math.max(0.17, Math.min(1, sinAngleIn));
+  const stretch = Math.min(5.5, 1 / sinAngle);
+  const along = size * Math.pow(stretch, 0.75);
+  const across = size / Math.pow(stretch, 0.25);
+  const frontRow = row + directionRow * along * 0.25;
+  const frontColumn = column + directionColumn * along * 0.25;
+  depositBlob(context, frontRow, frontColumn, along, across, directionColumn, directionRow, amount, 0.1 + 0.12 * (1 - sinAngle) + (size < 1.4 ? 0 : 0.06));
+  const sideColumn = -directionRow;
+  const sideRow = directionColumn;
+  const spikeCount = Math.round(Math.min(18, (size < 1.2 ? 1 : 4) + size * 1.6 + 5 * (1 - sinAngle)) * spikes);
+  for (let spike = 0; spike < spikeCount; spike++) {
+    const spread = Math.PI * (0.25 + 0.75 * sinAngle * sinAngle);
+    let theta = (random() * 2 - 1) * spread;
+    if (sinAngle > 0.9) theta = random() * 6.283;
+    const cosine = Math.cos(theta);
+    const sine = Math.sin(theta);
+    const dx = cosine * directionColumn + sine * sideColumn;
+    const dy = cosine * directionRow + sine * sideRow;
+    const length2 = size * (0.25 + random() * 0.55) * (1 + 2.6 * (1 - sinAngle) * Math.max(0, cosine)) * (sinAngle > 0.9 ? 0.6 : 1) * (0.5 + 0.5 * spikes);
+    const startRow = frontRow + (along * cosine * directionRow + across * sine * sideRow) * 0.75;
+    const startColumn = frontColumn + (along * cosine * directionColumn + across * sine * sideColumn) * 0.75;
+    const endRow = startRow + dy * length2;
+    const endColumn = startColumn + dx * length2;
+    depositStroke(context, startRow, startColumn, endRow, endColumn, Math.max(0.55, size * 0.22), 0.42, amount * 0.75);
+    if (random() < 0.5) {
+      const gap = 1 + random() * 2.2;
+      depositBlob(context, endRow + dy * gap, endColumn + dx * gap, 0.55 + random() * 0.7, 0.5 + random() * 0.4, dx, dy, amount * 0.55, 0.08);
+    }
+  }
+  const satelliteCount = Math.round((1 + size * 0.9) * (1.4 - sinAngle * 0.6) * (0.5 + 0.5 * spikes));
+  for (let satellite = 0; satellite < satelliteCount; satellite++) {
+    const cone = sinAngle > 0.9 ? Math.PI : 0.18 + 0.6 * sinAngle;
+    const theta = (random() * 2 - 1) * cone;
+    const cosine = Math.cos(theta);
+    const sine = Math.sin(theta);
+    const dx = cosine * directionColumn + sine * sideColumn;
+    const dy = cosine * directionRow + sine * sideRow;
+    const distance2 = along + size * (0.8 + random() * 3.2);
+    const radius = 0.45 + random() * Math.min(1.2, size * 0.22);
+    const satelliteRow = frontRow + dy * distance2;
+    const satelliteColumn = frontColumn + dx * distance2;
+    depositBlob(context, satelliteRow, satelliteColumn, radius * Math.sqrt(stretch), radius, dx, dy, amount * 0.6, 0.08);
+    if (sinAngle < 0.8) depositStroke(context, satelliteRow + dy * radius * stretch * 0.7, satelliteColumn + dx * radius * stretch * 0.7, satelliteRow + dy * radius * stretch * 1.8, satelliteColumn + dx * radius * stretch * 1.8, 0.5, 0.3, amount * 0.35);
+  }
+}
+
+// src/film/drops.ts
+var GRAVITY2 = 9.8;
+var AIR_DRAG = 0.25;
+var MIN_SIZE_CELLS = 0.6;
+function createDropPool(layout, context) {
+  const capacity = layout.rules.dropCapacity;
+  let cursor = 0;
+  const state = {
+    capacity,
+    get launched() {
+      return cursor;
+    },
+    active: new Uint8Array(capacity),
+    position: new Float64Array(capacity * 3),
+    velocity: new Float64Array(capacity * 3),
+    radius: new Float64Array(capacity)
+  };
+  const { active, position, velocity, radius } = state;
+  const cellMillimetres = layout.cellSize * 1e3;
+  const previous = [0, 0, 0];
+  const point = [0, 0, 0];
+  const speed = [0, 0, 0];
+  function land(region, dropRadius) {
+    const profile = context.profile();
+    const impact = layout.impact(region, point, speed);
+    const [alongColumn, alongRow] = impact.along;
+    const travel = Math.hypot(alongColumn, alongRow) || 1e-6;
+    const sinAngle = Math.abs(impact.normalSpeed) / Math.hypot(travel, impact.normalSpeed);
+    const volume = 4 / 3 * Math.PI * dropRadius * dropRadius * dropRadius / (cellMillimetres * cellMillimetres) * (dropRadius > 3 ? 7 : 4) * profile.volume;
+    const totalSpeed = Math.sqrt(speed[0] * speed[0] + speed[1] * speed[1] + speed[2] * speed[2]);
+    const size = Math.max(MIN_SIZE_CELLS, dropRadius * 2 / cellMillimetres * (1 + 0.2 * totalSpeed));
+    const amount = Math.min(profile.maxAmount, Math.max(0.25, volume / (Math.PI * size * size * 1.6 / (sinAngle < 0.3 ? 0.6 : 1))));
+    if (profile.landsAsBlob) {
+      depositBlob(context, impact.row, impact.column, size * 1.3, size * 1.1, alongColumn / travel, alongRow / travel, amount, 0.2);
+      return;
+    }
+    depositSplat(context, impact.row, impact.column, size, alongColumn / travel, alongRow / travel, sinAngle, amount);
+  }
+  return {
+    state,
+    launch(origin, direction, dropRadius) {
+      const slot = cursor++ % capacity;
+      const offset = slot * 3;
+      active[slot] = 1;
+      position[offset] = origin[0];
+      position[offset + 1] = origin[1];
+      position[offset + 2] = origin[2];
+      velocity[offset] = direction[0];
+      velocity[offset + 1] = direction[1];
+      velocity[offset + 2] = direction[2];
+      radius[slot] = dropRadius;
+    },
+    update(dt) {
+      for (let slot = 0; slot < capacity; slot++) {
+        if (!active[slot]) continue;
+        const offset = slot * 3;
+        previous[0] = position[offset];
+        previous[1] = position[offset + 1];
+        previous[2] = position[offset + 2];
+        velocity[offset + 1] -= GRAVITY2 * dt;
+        const drag = 1 - dt * AIR_DRAG;
+        velocity[offset] *= drag;
+        velocity[offset + 1] *= drag;
+        velocity[offset + 2] *= drag;
+        point[0] = position[offset] + velocity[offset] * dt;
+        point[1] = position[offset + 1] + velocity[offset + 1] * dt;
+        point[2] = position[offset + 2] + velocity[offset + 2] * dt;
+        const region = layout.collide(previous, point);
+        position[offset] = point[0];
+        position[offset + 1] = point[1];
+        position[offset + 2] = point[2];
+        if (region >= 0) {
+          if (layout.contains(point)) {
+            speed[0] = velocity[offset];
+            speed[1] = velocity[offset + 1];
+            speed[2] = velocity[offset + 2];
+            land(region, radius[slot]);
+          }
+          active[slot] = 0;
+          continue;
+        }
+        if (layout.escaped(point)) active[slot] = 0;
+      }
+    },
+    clear() {
+      active.fill(0);
+    }
+  };
+}
+
+// src/film/simulate.ts
+var RAIN_SPREAD = 0.5;
+var BOUNDS_MARGIN = 8;
+function createCpuSimulator(field, layout, profileOf, options) {
+  const { width, height, thickness, dryness, dampness } = field;
+  const { bed, pin: pinning, vertical } = layout;
+  const delta = new Float32Array(width * height);
+  const bounds = { firstRow: 0, lastRow: -1, firstColumn: 0, lastColumn: -1 };
+  let accumulated = 0;
+  function refreshBounds() {
+    let firstRow = height;
+    let lastRow = -1;
+    let firstColumn = width;
+    let lastColumn = -1;
+    for (let row = 0; row < height; row++) {
+      const offset = row * width;
+      let isWet = false;
+      for (let column = 0; column < width; column++) {
+        if (thickness[offset + column] > 0) {
+          isWet = true;
+          if (column < firstColumn) firstColumn = column;
+          if (column > lastColumn) lastColumn = column;
+        }
+      }
+      if (isWet) {
+        if (row < firstRow) firstRow = row;
+        lastRow = row;
+      }
+    }
+    if (lastRow < 0) {
+      bounds.firstRow = 0;
+      bounds.lastRow = -1;
+      bounds.firstColumn = 0;
+      bounds.lastColumn = -1;
+      return;
+    }
+    bounds.firstRow = Math.max(0, firstRow - BOUNDS_MARGIN);
+    bounds.lastRow = Math.min(height - 1, lastRow + BOUNDS_MARGIN);
+    bounds.firstColumn = Math.max(0, firstColumn - BOUNDS_MARGIN);
+    bounds.lastColumn = Math.min(width - 1, lastColumn + BOUNDS_MARGIN);
+  }
+  const mobility = (index) => {
+    const dry = dryness[index];
+    return dry < 0.25 ? 1 : dry > 0.6 ? 0 : 1 - (dry - 0.25) / 0.35;
+  };
+  function flowStep() {
+    const { firstRow, lastRow, firstColumn, lastColumn } = bounds;
+    if (lastRow < 0) return;
+    const profile = profileOf();
+    const flow = profile.flow * (1 + RAIN_SPREAD * options.weather().rain);
+    const referenceSquared = profile.referenceThickness * profile.referenceThickness;
+    const slopeCap = profile.slopeCap;
+    const pinLevel = profile.pin;
+    const front = profile.front;
+    for (let row = firstRow; row <= lastRow; row++) {
+      const offset = row * width;
+      for (let column = firstColumn; column <= lastColumn; column++) delta[offset + column] = 0;
+    }
+    for (let row = firstRow; row <= lastRow; row++) {
+      const offset = row * width;
+      for (let column = firstColumn; column <= lastColumn; column++) {
+        const index = offset + column;
+        const own = thickness[index];
+        for (let edge = 0; edge < 2; edge++) {
+          let neighbour;
+          if (edge === 0) {
+            if (column >= lastColumn) continue;
+            neighbour = index + 1;
+          } else {
+            if (row >= lastRow) continue;
+            neighbour = index + width;
+          }
+          const other = thickness[neighbour];
+          if (own < 5e-3 && other < 5e-3) continue;
+          let bedDrop = bed[index] - bed[neighbour];
+          if (bedDrop > slopeCap) bedDrop = slopeCap;
+          else if (bedDrop < -slopeCap) bedDrop = -slopeCap;
+          let head = bedDrop + own - other;
+          let source = index;
+          let destination = neighbour;
+          if (head < 0) {
+            head = -head;
+            source = neighbour;
+            destination = index;
+          }
+          const sourceThickness = thickness[source];
+          const verticalFactor = vertical[source];
+          const pinThreshold = pinLevel * pinning[source] * (verticalFactor < 1 ? 0.5 : 1);
+          if (sourceThickness <= pinThreshold) continue;
+          if (thickness[destination] < 0.03 && sourceThickness < front * pinning[source] * verticalFactor) continue;
+          const mobile = mobility(source);
+          if (mobile <= 0) continue;
+          let moved = flow * mobile * (sourceThickness * sourceThickness / (sourceThickness * sourceThickness + referenceSquared)) * head * (verticalFactor < 1 ? edge === 0 ? 0.22 : 1 : 4);
+          const limit = (sourceThickness - pinThreshold) * 0.24;
+          if (moved > limit) moved = limit;
+          delta[source] -= moved;
+          delta[destination] += moved;
+        }
+      }
+    }
+    for (let row = firstRow; row <= lastRow; row++) {
+      const offset = row * width;
+      for (let column = firstColumn; column <= lastColumn; column++) {
+        const index = offset + column;
+        let next = thickness[index] + delta[index];
+        if (next < 1e-4) next = 0;
+        else dampness[index] = 1;
+        thickness[index] = next;
+      }
+    }
+  }
+  function age(dryingSeconds) {
+    const { firstRow, lastRow, firstColumn, lastColumn } = bounds;
+    if (lastRow < 0) return;
+    const profile = profileOf();
+    const rainScale = 1 - options.weather().rain;
+    const seconds = dryingSeconds * rainScale;
+    for (let row = firstRow; row <= lastRow; row++) {
+      const offset = row * width;
+      for (let column = firstColumn; column <= lastColumn; column++) {
+        const index = offset + column;
+        const own = thickness[index];
+        if (own > 0) {
+          const thin = 1 - Math.min(1, own / 1.6);
+          if (profile.dryTime > 0 && dryness[index] < 1) dryness[index] = Math.min(1, dryness[index] + seconds / profile.dryTime * (0.45 + 1.7 * thin));
+          if (profile.evaporation > 0) {
+            const next = own - profile.evaporation * seconds * (0.5 + 1.5 * thin);
+            thickness[index] = next > 4e-3 ? next : 0;
+          }
+        } else if (dampness[index] > 0) {
+          dampness[index] = Math.max(0, dampness[index] - seconds / (profile.evaporation > 0 ? 25 : 1e9));
+        }
+      }
+    }
+  }
+  return {
+    bounds,
+    refreshBounds,
+    advance({ dt, dryingSeconds }) {
+      accumulated += dt;
+      let steps = 0;
+      refreshBounds();
+      while (accumulated >= 1 / options.stepRate && steps < options.maxSteps) {
+        flowStep();
+        accumulated -= 1 / options.stepRate;
+        steps++;
+      }
+      if (steps === options.maxSteps) accumulated = 0;
+      age(dryingSeconds);
+      return steps;
+    },
+    resetClock() {
+      accumulated = 0;
+    }
+  };
+}
+
+// src/film/sources.ts
+var range = (random, from, to) => from + random() * (to - from);
+function updateDrip(drip, bead, layout, random, launch, dt) {
+  if (!drip) {
+    bead.visible = false;
+    return;
+  }
+  drip.elapsed += dt;
+  const swell = Math.min(1, drip.elapsed / drip.every);
+  const radius = drip.radius * (0.35 + 0.65 * swell);
+  const isWorkshop = layout.rules.dripStyle === "workshop";
+  bead.visible = true;
+  bead.swell = swell;
+  bead.radius = radius;
+  bead.position[0] = drip.position[0];
+  bead.position[1] = drip.position[1] + (isWorkshop ? -radius * 12e-4 * (1 + swell * 0.7) : -radius * 12e-4);
+  bead.position[2] = drip.position[2];
+  if (drip.elapsed < drip.every) return;
+  const origin = [bead.position[0], bead.position[1] + -radius * 1e-3, bead.position[2]];
+  if (isWorkshop) {
+    const sideX2 = range(random, -0.025, 0.025);
+    const sideZ2 = range(random, -0.025, 0.025);
+    launch(origin, [sideX2, -0.2, sideZ2], drip.radius * range(random, 0.85, 1.15));
+    drip.elapsed = 0;
+    drip.every = drip.base * range(random, 0.75, 1.25);
+    return;
+  }
+  const sideX = (random() - 0.5) * 0.05;
+  const sideZ = (random() - 0.5) * 0.05;
+  launch(origin, [sideX, -0.2, sideZ], drip.radius * (0.85 + random() * 0.3));
+  drip.elapsed = 0;
+  drip.every = drip.base * (0.75 + random() * 0.5);
+}
+function updateSources(sources, context, dt) {
+  const random = context.random;
+  for (const source of sources) {
+    source.elapsed += dt;
+    if (source.elapsed < 0 || source.elapsed > source.duration) continue;
+    const pulse = 0.6 + 0.4 * Math.max(0, Math.sin(source.elapsed * 5.2));
+    const amount = source.rate * dt * pulse;
+    for (let part = 0; part < 3; part++) {
+      const angle = random() * 6.28;
+      const distance2 = random() * source.radius;
+      depositCell(context, source.row + Math.sin(angle) * distance2, source.column + Math.cos(angle) * distance2, amount / 3);
+    }
+  }
+}
+function updateDrags(drags, context, layout, launch, dt) {
+  const random = context.random;
+  for (const drag of drags) {
+    if (drag.done) continue;
+    drag.elapsed += dt;
+    const progress = Math.min(1, drag.elapsed / drag.duration);
+    const here = drag.path(progress);
+    const ahead = drag.path(Math.min(1, progress + 0.01));
+    let directionColumn = ahead.column - here.column;
+    let directionRow = ahead.row - here.row;
+    const length2 = Math.hypot(directionColumn, directionRow) || 1;
+    directionColumn /= length2;
+    directionRow /= length2;
+    const sideColumn = -directionRow;
+    const sideRow = directionColumn;
+    const load = Math.pow(1 - progress, 1.3);
+    for (let offset = -drag.width; offset <= drag.width; offset += 0.5) {
+      const across = offset / drag.width;
+      const stripe = drag.stripes[Math.round((offset + drag.width) * 2)];
+      const edge = 1 - across * across;
+      const amount = drag.amount * load * (0.25 + 0.75 * stripe) * edge;
+      if (load < 0.45 && random() > load * 2.2) continue;
+      depositCell(context, Math.round(here.row + sideRow * offset), Math.round(here.column + sideColumn * offset), amount * dt * 30);
+    }
+    if (drag.hand && random() < dt * 14 * load + 0.02) {
+      const world = layout.cellToWorld(here.row, here.column);
+      const origin = [world[0] + (random() - 0.5) * 0.06, drag.hand.height + random() * 0.3, world[2] + (random() - 0.5) * 0.06];
+      const velocity = [directionColumn * drag.hand.speed, 0 * drag.hand.speed, directionRow * drag.hand.speed];
+      velocity[0] += (random() - 0.5) * 0.3;
+      velocity[1] += 0.2;
+      velocity[2] += (random() - 0.5) * 0.3;
+      launch(origin, velocity, 2 + random() * 2.2);
+    }
+    if (progress >= 1) drag.done = true;
+  }
+}
+
+// src/film/film.ts
+var DEFAULT_STEP_RATE = 180;
+var DEFAULT_MAX_STEPS = 6;
+function createFilm(options) {
+  const { layout, random } = options;
+  const cellCount = layout.width * layout.height;
+  const field = {
+    width: layout.width,
+    height: layout.height,
+    thickness: new Float32Array(cellCount),
+    dryness: new Float32Array(cellCount),
+    dampness: new Float32Array(cellCount)
+  };
+  let weatherState = { rain: 0 };
+  let currentProfile = options.profile;
+  const context = { field, random, profile: () => currentProfile };
+  const drops = createDropPool(layout, context);
+  const createSimulator = options.simulator ?? createCpuSimulator;
+  const simulator = createSimulator(field, layout, () => currentProfile, {
+    stepRate: options.stepRate ?? DEFAULT_STEP_RATE,
+    maxSteps: options.maxSteps ?? DEFAULT_MAX_STEPS,
+    weather: () => weatherState
+  });
+  const film = {
+    layout,
+    field,
+    drops: drops.state,
+    bead: { visible: false, position: [0, 0, 0], radius: 0, swell: 0 },
+    simulator,
+    get profile() {
+      return currentProfile;
+    },
+    set profile(profile) {
+      currentProfile = profile;
+    },
+    drip: void 0,
+    sources: [],
+    drags: [],
+    launch: (position, velocity, radius) => drops.launch(position, velocity, radius),
+    splat: (row, column, size, directionColumn, directionRow, sinAngle, amount) => depositSplat(context, row, column, size, directionColumn, directionRow, sinAngle, amount),
+    blob: (row, column, along, across, directionColumn, directionRow, amount, roughness) => depositBlob(context, row, column, along, across, directionColumn, directionRow, amount, roughness),
+    stroke: (fromRow, fromColumn, toRow, toColumn, startWidth, endWidth, amount) => depositStroke(context, fromRow, fromColumn, toRow, toColumn, startWidth, endWidth, amount),
+    deposit: (row, column, amount) => depositCell(context, row, column, amount),
+    update({ dt, dryingSeconds }) {
+      drops.update(dt);
+      updateDrip(film.drip, film.bead, layout, random, drops.launch, dt);
+      updateSources(film.sources, context, dt);
+      updateDrags(film.drags, context, layout, drops.launch, dt);
+      simulator.advance({ dt, dryingSeconds });
+    },
+    setWeather(weather) {
+      weatherState = { rain: Math.min(1, Math.max(0, weather.rain ?? weatherState.rain)) };
+    },
+    weather: () => ({ ...weatherState }),
+    clear() {
+      field.thickness.fill(0);
+      field.dryness.fill(0);
+      field.dampness.fill(0);
+      drops.clear();
+      film.drip = void 0;
+      film.bead.visible = false;
+      film.sources.length = 0;
+      film.drags.length = 0;
+      simulator.refreshBounds();
+    },
+    wetCells: () => wetCellCount(field)
+  };
+  return film;
+}
+
+// src/film/random.ts
+function createFilmLcg(seed) {
+  const lcg = (() => {
+    lcg.seed = lcg.seed * 1664525 + 1013904223 >>> 0;
+    return lcg.seed / 4294967296;
+  });
+  lcg.seed = seed >>> 0;
+  return lcg;
+}
+
+// src/film/noise.ts
+function hashCell(x, y) {
+  let value = x * 374761393 + y * 668265263 | 0;
+  value = (value ^ value >>> 13) * 1274126177 | 0;
+  return ((value ^ value >>> 16) >>> 0) / 4294967296;
+}
+function valueNoise(x, y) {
+  const xi = Math.floor(x);
+  const yi = Math.floor(y);
+  const xf = x - xi;
+  const yf = y - yi;
+  const u = xf * xf * (3 - 2 * xf);
+  const v = yf * yf * (3 - 2 * yf);
+  const a = hashCell(xi, yi);
+  const b = hashCell(xi + 1, yi);
+  const c = hashCell(xi, yi + 1);
+  const d = hashCell(xi + 1, yi + 1);
+  return a + (b - a) * u + (c - a) * v + (a - b - c + d) * u * v;
+}
+
+// src/film/layout.ts
+var REGION_NAMES = ["wall", "sidewalk", "curb", "road"];
+var dot3 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+function impactOf(region, position, velocity, cellSize) {
+  const local = [position[0] - region.origin[0], position[1] - region.origin[1], position[2] - region.origin[2]];
+  return {
+    row: region.firstRow + dot3(local, region.rowAxis) / cellSize,
+    column: dot3(local, region.columnAxis) / cellSize,
+    along: [dot3(velocity, region.columnAxis), dot3(velocity, region.rowAxis)],
+    normalSpeed: -dot3(velocity, region.normal)
+  };
+}
+function cellToWorldOf(regions, cellSize, row, column) {
+  let region = regions[regions.length - 1];
+  for (const candidate of regions) {
+    if (row < candidate.firstRow + candidate.rowCount) {
+      region = candidate;
+      break;
+    }
+  }
+  const across = column * cellSize;
+  const down = (row - region.firstRow) * cellSize;
+  return [
+    region.origin[0] + region.columnAxis[0] * across + region.rowAxis[0] * down,
+    region.origin[1] + region.columnAxis[1] * across + region.rowAxis[1] * down,
+    region.origin[2] + region.columnAxis[2] * across + region.rowAxis[2] * down
+  ];
+}
+function createFoldedLayout(params) {
+  const { columns, cellSize, originX, wallRows, sidewalkRows, curbRows, roadRows, wallTopY, sidewalkY, roadY, wallZ, rules } = params;
+  const curbStep = params.curbStep ?? (sidewalkY - roadY) / curbRows;
+  const height = wallRows + sidewalkRows + curbRows + roadRows;
+  const cellCount = columns * height;
+  const bed = new Float32Array(cellCount);
+  const pin = new Float32Array(cellCount);
+  const vertical = new Float32Array(cellCount);
+  const sidewalkEnd = wallRows + sidewalkRows;
+  const curbEnd = sidewalkEnd + curbRows;
+  const regionOfRow = (row) => row < wallRows ? 0 : row < sidewalkEnd ? 1 : row < curbEnd ? 2 : 3;
+  for (let row = 0; row < height; row++) {
+    for (let column = 0; column < columns; column++) {
+      const index = row * columns + column;
+      const region = regionOfRow(row);
+      const x = originX + (column + 0.5) * cellSize;
+      let bedHeight;
+      let roughness = 0.2;
+      if (region === 0) {
+        bedHeight = (wallTopY - (row + 0.5) * cellSize) * 1e3;
+        roughness = 0.3;
+      } else if (region === 1) {
+        const z = (row - wallRows + 0.5) * cellSize;
+        bedHeight = sidewalkY * 1e3 - z * 6;
+        const jointX = Math.abs(((x - originX) % 0.5 + 0.5) % 0.5 - 0.25);
+        const jointZ = Math.abs((z % 0.5 + 0.5) % 0.5 - 0.25);
+        if (jointX > 0.25 - cellSize * 0.6 || jointZ > 0.25 - cellSize * 0.6) bedHeight -= 0.9;
+        roughness = 0.18;
+      } else if (region === 2) {
+        bedHeight = sidewalkY * 1e3 - (row - sidewalkEnd + 0.5) * curbStep * 1e3;
+      } else {
+        const z = (row - curbEnd + 0.5) * cellSize;
+        bedHeight = roadY * 1e3 + z * 14 - (x - params.roadSlopeAnchorX) * 5;
+        roughness = 0.55;
+      }
+      const noise = valueNoise(column * 0.35, row * 0.35) * 0.6 + valueNoise(column * 1.3, row * 1.3) * 0.4;
+      bed[index] = bedHeight + (noise - 0.5) * roughness * 2;
+      vertical[index] = region === 0 || region === 2 ? 0.95 : 1;
+      pin[index] = 0.62 + 0.76 * (valueNoise(column * 0.21 + 40, row * 0.21) * 0.5 + hashCell(column, row) * 0.5) * (region === 3 ? 1.25 : 1);
+    }
+  }
+  const curbZ = wallZ + sidewalkRows * cellSize;
+  const roadEndZ = curbZ + roadRows * cellSize;
+  const right = [1, 0, 0];
+  const regions = [
+    { id: REGION_NAMES[0], firstRow: 0, rowCount: wallRows, origin: [originX, wallTopY, wallZ], columnAxis: right, rowAxis: [0, -1, 0], normal: [0, 0, 1], isVertical: true },
+    { id: REGION_NAMES[1], firstRow: wallRows, rowCount: sidewalkRows, origin: [originX, sidewalkY, wallZ], columnAxis: right, rowAxis: [0, 0, 1], normal: [0, 1, 0], isVertical: false },
+    { id: REGION_NAMES[2], firstRow: sidewalkEnd, rowCount: curbRows, origin: [originX, sidewalkY, curbZ], columnAxis: right, rowAxis: [0, -1, 0], normal: [0, 0, 1], isVertical: true },
+    { id: REGION_NAMES[3], firstRow: curbEnd, rowCount: roadRows, origin: [originX, roadY, curbZ], columnAxis: right, rowAxis: [0, 0, 1], normal: [0, 1, 0], isVertical: false }
+  ];
+  const maxX = originX + columns * cellSize;
+  return {
+    id: params.id,
+    width: columns,
+    height,
+    cellSize,
+    bed,
+    pin,
+    vertical,
+    regions,
+    rules,
+    cellToWorld: (row, column) => cellToWorldOf(regions, cellSize, row, column),
+    collide(previous, position) {
+      if (position[2] <= wallZ && position[1] > sidewalkY) {
+        position[2] = wallZ;
+        return 0;
+      }
+      if (position[2] < curbZ && (!rules.guardBehindWall || position[2] >= wallZ) && position[1] <= sidewalkY) {
+        position[1] = sidewalkY;
+        return 1;
+      }
+      if (rules.curbCatch && position[2] >= curbZ && previous[2] < curbZ && position[1] < sidewalkY) {
+        position[2] = curbZ;
+        return 2;
+      }
+      if (position[2] >= curbZ && position[1] <= roadY) {
+        position[1] = roadY;
+        return 3;
+      }
+      return -1;
+    },
+    impact: (region, position, velocity) => impactOf(regions[region], position, velocity, cellSize),
+    contains: (position) => position[0] > originX && position[0] < maxX && (!rules.clipRoadEnd || position[2] < roadEndZ),
+    escaped(position) {
+      if (position[1] < -1) return true;
+      const box = rules.escapeBox;
+      return box !== void 0 && (position[0] < box.minX || position[0] > box.maxX || position[2] > box.maxZ);
+    }
+  };
+}
+var PADRAO_CELL = 0.0125;
+var PADRAO_WALL_Z = 0;
+var PADRAO_LAYOUT = createFoldedLayout({
+  id: "padrao",
+  columns: 256,
+  cellSize: PADRAO_CELL,
+  originX: -1.6,
+  wallRows: 144,
+  sidewalkRows: 128,
+  curbRows: 12,
+  roadRows: 112,
+  wallTopY: 1.95,
+  sidewalkY: 0.15,
+  roadY: 0,
+  wallZ: PADRAO_WALL_Z,
+  curbStep: PADRAO_CELL,
+  roadSlopeAnchorX: 0,
+  rules: {
+    dropCapacity: 600,
+    curbCatch: true,
+    guardBehindWall: true,
+    clipRoadEnd: true,
+    escapeBox: { minX: -3, maxX: 3, maxZ: PADRAO_WALL_Z + 128 * PADRAO_CELL + 112 * PADRAO_CELL + 1 },
+    dripStyle: "padrao"
+  }
+});
+var WORKSHOP_CELL = 0.0125;
+var WORKSHOP_LAYOUT = createFoldedLayout({
+  id: "workshop",
+  columns: 160,
+  cellSize: WORKSHOP_CELL,
+  originX: -2.2,
+  wallRows: 160,
+  sidewalkRows: 128,
+  curbRows: 9,
+  roadRows: 151,
+  wallTopY: 2.12,
+  sidewalkY: 0.1235,
+  roadY: 9e-3,
+  wallZ: -4.497,
+  roadSlopeAnchorX: -1.2,
+  rules: { dropCapacity: 400, curbCatch: false, guardBehindWall: false, clipRoadEnd: false, dripStyle: "workshop" }
+});
+
+// src/film/surface-layout.ts
+var DEFAULT_COLUMNS = 160;
+var DEFAULT_ROWS = 160;
+var DEFAULT_CELL = 0.0125;
+var DEFAULT_WALL_ROWS = 48;
+var DEFAULT_CURB_ROWS = 12;
+var RULES = { dropCapacity: 160, curbCatch: false, guardBehindWall: false, clipRoadEnd: false, dripStyle: "padrao" };
+var along3 = (origin, axis, distance2) => add(origin, scale(axis, distance2));
+var reject = (vector, axis) => sub(vector, scale(axis, dot(vector, axis)));
+function layoutFromSurfaces(options) {
+  const columns = options.columns ?? DEFAULT_COLUMNS;
+  const totalRows = options.rows ?? DEFAULT_ROWS;
+  const cell = options.cellSize ?? DEFAULT_CELL;
+  const floorBasis = makeBasis(options.floor.normal, options.floor.tangent);
+  const floorNormal = floorBasis.normal;
+  const projected = sub(options.center, scale(floorNormal, dot(sub(options.center, options.floor.point), floorNormal)));
+  const wallNormal = options.wall ? normalize(reject(options.wall.normal, floorNormal), floorBasis.t2) : void 0;
+  const awayAxis = wallNormal ?? floorBasis.t2;
+  const columnAxis = wallNormal ? normalize(cross(floorNormal, wallNormal), floorBasis.t1) : floorBasis.t1;
+  const wallRows = options.wall ? Math.min(totalRows - 1, options.wallRows ?? DEFAULT_WALL_ROWS) : 0;
+  let fold = projected;
+  if (options.wall && wallNormal) {
+    const toWall = dot(sub(projected, options.wall.point), wallNormal) / (dot(awayAxis, wallNormal) || 1);
+    fold = sub(projected, scale(awayAxis, toWall));
+  } else {
+    fold = along3(projected, awayAxis, -(totalRows * cell) / 2);
+  }
+  const lateral = dot(sub(projected, fold), columnAxis) - columns * cell / 2;
+  const base = along3(fold, columnAxis, lateral);
+  const strips = [];
+  const roughness = 0.18 + 0.4 * options.floor.porosity;
+  if (options.wall && wallNormal) {
+    strips.push({ id: "wall", rows: wallRows, origin: along3(base, floorNormal, wallRows * cell), rowAxis: scale(floorNormal, -1), normal: wallNormal, isVertical: true, roughness: 0.3 });
+  }
+  const lowerRows = totalRows - wallRows;
+  const dropMetres = options.curb ? Math.max(0, dot(sub(options.floor.point, options.curb.point), floorNormal)) : 0;
+  const curbRows = options.curb ? Math.min(options.curbRows ?? DEFAULT_CURB_ROWS, Math.max(1, Math.ceil(dropMetres / cell)), lowerRows - 2) : 0;
+  const floorRows = options.curb ? Math.max(1, Math.floor((lowerRows - curbRows) / 2)) : lowerRows;
+  strips.push({ id: "floor", rows: floorRows, origin: base, rowAxis: awayAxis, normal: floorNormal, isVertical: false, roughness });
+  if (options.curb) {
+    const edge = along3(base, awayAxis, floorRows * cell);
+    strips.push({ id: "curb", rows: curbRows, origin: edge, rowAxis: scale(floorNormal, -1), normal: awayAxis, isVertical: true, roughness: 0.2 });
+    const lowerOrigin = along3(edge, floorNormal, -curbRows * cell);
+    strips.push({ id: "low", rows: lowerRows - floorRows - curbRows, origin: lowerOrigin, rowAxis: awayAxis, normal: floorNormal, isVertical: false, roughness: 0.55 });
+  }
+  const regions = [];
+  let firstRow = 0;
+  for (const strip of strips) {
+    regions.push({ id: strip.id, firstRow, rowCount: strip.rows, origin: strip.origin, columnAxis, rowAxis: strip.rowAxis, normal: strip.normal, isVertical: strip.isVertical });
+    firstRow += strip.rows;
+  }
+  const height = firstRow;
+  const bed = new Float32Array(columns * height);
+  const pin = new Float32Array(columns * height);
+  const vertical = new Float32Array(columns * height);
+  regions.forEach((region, regionIndex) => {
+    const strip = strips[regionIndex];
+    for (let row = 0; row < region.rowCount; row++) {
+      for (let column = 0; column < columns; column++) {
+        const index = (region.firstRow + row) * columns + column;
+        const centre = add(add(region.origin, scale(columnAxis, (column + 0.5) * cell)), scale(region.rowAxis, (row + 0.5) * cell));
+        const noise = valueNoise(column * 0.35, (region.firstRow + row) * 0.35) * 0.6 + valueNoise(column * 1.3, (region.firstRow + row) * 1.3) * 0.4;
+        bed[index] = centre[1] * 1e3 + (noise - 0.5) * strip.roughness * 2;
+        vertical[index] = region.isVertical ? 0.95 : 1;
+        pin[index] = 0.62 + 0.76 * (valueNoise(column * 0.21 + 40, (region.firstRow + row) * 0.21) * 0.5 + valueNoise(column * 0.9, row * 0.9) * 0.5);
+      }
+    }
+  });
+  const lowestY = Math.min(...regions.map((region) => region.origin[1] - (region.rowAxis[1] > 0 ? 0 : region.rowCount * cell * Math.abs(region.rowAxis[1])))) - 1;
+  const width = columns * cell;
+  const cellToWorld = (row, column) => {
+    const region = regions.find((candidate) => row < candidate.firstRow + candidate.rowCount) ?? regions[regions.length - 1];
+    return add(add(region.origin, scale(region.columnAxis, column * cell)), scale(region.rowAxis, (row - region.firstRow) * cell));
+  };
+  return {
+    id: "surfaces",
+    width: columns,
+    height,
+    cellSize: cell,
+    bed,
+    pin,
+    vertical,
+    regions,
+    rules: RULES,
+    cellToWorld,
+    collide(previous, position) {
+      for (let index = 0; index < regions.length; index++) {
+        const region = regions[index];
+        const before = dot(sub(previous, region.origin), region.normal);
+        const after = dot(sub(position, region.origin), region.normal);
+        if (before < 0 || after > 0) continue;
+        const local = sub(position, region.origin);
+        const sideways = dot(local, region.columnAxis);
+        const downward = dot(local, region.rowAxis);
+        if (sideways < 0 || sideways >= width || downward < 0 || downward >= region.rowCount * cell) continue;
+        position[0] -= region.normal[0] * after;
+        position[1] -= region.normal[1] * after;
+        position[2] -= region.normal[2] * after;
+        return index;
+      }
+      return -1;
+    },
+    impact(regionIndex, position, velocity) {
+      const region = regions[regionIndex];
+      const local = sub(position, region.origin);
+      return {
+        row: region.firstRow + dot(local, region.rowAxis) / cell,
+        column: dot(local, region.columnAxis) / cell,
+        along: [dot(velocity, region.columnAxis), dot(velocity, region.rowAxis)],
+        normalSpeed: -dot(velocity, region.normal)
+      };
+    },
+    contains: () => true,
+    escaped: (position) => position[1] < lowestY
+  };
+}
+
+// src/data/film-profiles.json
+var film_profiles_default = [
+  {
+    id: "blood",
+    look: "blood",
+    flow: 0.05,
+    pin: 0.33,
+    front: 0.58,
+    referenceThickness: 0.6,
+    slopeCap: 1.1,
+    dryTime: 600,
+    evaporation: 0,
+    opacityRate: 3.2,
+    reflectance: 0.045,
+    normalScale: 16,
+    thin: 7997966,
+    thick: 2753028,
+    dry: 3874068,
+    dryThin: 6960678,
+    dropColor: 7997965,
+    dropOpacity: 1,
+    volume: 1,
+    spikes: 1,
+    landsAsBlob: false,
+    maxAmount: 2.6,
+    sources: {
+      padrao: "F46",
+      oficina: "W583"
+    }
+  },
+  {
+    id: "old_blood",
+    look: "blood",
+    flow: 0.032,
+    pin: 0.42,
+    front: 0.7,
+    referenceThickness: 0.7,
+    slopeCap: 1,
+    dryTime: 360,
+    evaporation: 0,
+    opacityRate: 3.8,
+    reflectance: 0.03,
+    normalScale: 14,
+    thin: 7085078,
+    thick: 2888717,
+    dry: 2758158,
+    dryThin: 4860444,
+    dropColor: 4854286,
+    dropOpacity: 1,
+    volume: 0.6,
+    spikes: 1,
+    landsAsBlob: false,
+    maxAmount: 2.6,
+    sources: {
+      padrao: "F48"
+    }
+  },
+  {
+    id: "bile",
+    look: "bile",
+    flow: 0.02,
+    pin: 0.8,
+    front: 1.2,
+    referenceThickness: 1.2,
+    slopeCap: 0.9,
+    dryTime: 900,
+    evaporation: 0,
+    opacityRate: 7,
+    reflectance: 0.04,
+    normalScale: 12,
+    thin: 11121724,
+    thick: 7174171,
+    dry: 4080160,
+    dryThin: 5659180,
+    dropColor: 9083434,
+    dropOpacity: 1,
+    volume: 1.3,
+    spikes: 0.3,
+    landsAsBlob: false,
+    maxAmount: 4,
+    sources: {
+      padrao: "F50",
+      oficina: "W584 (spikes 0.3 W578, cap 4 W691)"
+    }
+  },
+  {
+    id: "motor_oil",
+    look: "oil",
+    flow: 0.03,
+    pin: 0.12,
+    front: 0.22,
+    referenceThickness: 0.5,
+    slopeCap: 1,
+    dryTime: 0,
+    evaporation: 0,
+    opacityRate: 4.5,
+    reflectance: 0.06,
+    normalScale: 18,
+    thin: 1381135,
+    thick: 263173,
+    dry: 263173,
+    dryThin: 1381135,
+    dropColor: 657932,
+    dropOpacity: 1,
+    volume: 1,
+    spikes: 1,
+    landsAsBlob: true,
+    maxAmount: 2.6,
+    sources: {
+      padrao: "F52",
+      oficina: "W585 (blob W691)"
+    }
+  },
+  {
+    id: "fuel",
+    look: "fuel",
+    flow: 0.2,
+    pin: 0.035,
+    front: 0.07,
+    referenceThickness: 0.2,
+    slopeCap: 1.2,
+    dryTime: 0,
+    evaporation: 0.02,
+    opacityRate: 0.25,
+    reflectance: 0.04,
+    normalScale: 0,
+    thin: 10129520,
+    thick: 7234630,
+    dry: 0,
+    dryThin: 0,
+    dropColor: 12103824,
+    dropOpacity: 0.45,
+    volume: 1.4,
+    spikes: 1,
+    landsAsBlob: true,
+    maxAmount: 2.6,
+    sources: {
+      padrao: "F54",
+      oficina: "W586 (blob W691)"
+    }
+  }
+];
+
+// src/film/profiles.ts
+var FILM_PROFILES = film_profiles_default;
+function filmProfileOf(id, overrides = {}) {
+  const profile = FILM_PROFILES.find((entry) => entry.id === id);
+  return profile ? { ...profile, ...overrides } : void 0;
+}
 export {
+  FILM_PROFILES,
   ITEM_USES,
   LIQUIDS,
+  PADRAO_LAYOUT,
   SAMPLES as STAIN_SAMPLES,
+  WORKSHOP_LAYOUT,
   ballistic,
+  createCpuSimulator,
+  createFilm,
+  createFilmLcg,
   createFluids,
+  createFoldedLayout,
   createItemUse,
   describeEvent,
+  filmProfileOf,
+  hashCell,
+  layoutFromSurfaces,
   locales,
   resolveStrings,
   sampleStream,
-  stainDirection
+  stainDirection,
+  valueNoise
 };
 //# sourceMappingURL=index.js.map