@adatechnology/game-fluids 0.1.8 → 0.2.1

package/dist/index.global.js

@@ -23,17 +23,28 @@ var GameFluids = (() => {
   // src/index.ts
   var index_exports = {};
   __export(index_exports, {
+    FILM_PROFILES: () => FILM_PROFILES,
     ITEM_USES: () => ITEM_USES,
     LIQUIDS: () => LIQUIDS,
+    PADRAO_LAYOUT: () => PADRAO_LAYOUT,
     STAIN_SAMPLES: () => SAMPLES,
+    WORKSHOP_LAYOUT: () => WORKSHOP_LAYOUT,
     ballistic: () => ballistic,
+    createCpuSimulator: () => createCpuSimulator,
+    createFilm: () => createFilm,
+    createFilmLcg: () => createFilmLcg,
     createFluids: () => createFluids,
+    createFoldedLayout: () => createFoldedLayout,
     createItemUse: () => createItemUse,
     describeEvent: () => describeEvent,
+    filmProfileOf: () => filmProfileOf,
+    hashCell: () => hashCell,
+    layoutFromSurfaces: () => layoutFromSurfaces,
     locales: () => locales,
     resolveStrings: () => resolveStrings,
     sampleStream: () => sampleStream,
-    stainDirection: () => stainDirection
+    stainDirection: () => stainDirection,
+    valueNoise: () => valueNoise
   });
 
   // src/data/liquids.json
@@ -45,7 +56,7 @@ var GameFluids = (() => {
       stainColor: 7309206,
       viscosity: 1,
       density: 1e3,
-      dryTime: 600,
+      dryTime: 180,
       gloss: 0.9,
       drink: {
         thirst: 100,
@@ -223,9 +234,9 @@ var GameFluids = (() => {
       stainColor: 7232298,
       viscosity: 0.6,
       density: 740,
-      dryTime: 120,
+      dryTime: 60,
       gloss: 0.95,
-      leavesMark: true,
+      leavesMark: false,
       flammable: true,
       drink: {
         thirst: 0,
@@ -306,10 +317,10 @@ var GameFluids = (() => {
       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: {
@@ -322,6 +333,46 @@ var GameFluids = (() => {
         "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,
@@ -564,6 +615,8 @@ var GameFluids = (() => {
         motor_oil: "motor oil",
         cooking_oil: "cooking oil",
         blood: "blood",
+        old_blood: "old blood",
+        bile: "bile",
         sap: "sap",
         acid: "acid",
         paint: "paint",
@@ -604,6 +657,8 @@ var GameFluids = (() => {
         motor_oil: "\xF3leo de motor",
         cooking_oil: "\xF3leo de cozinha",
         blood: "sangue",
+        old_blood: "sangue antigo",
+        bile: "bile",
         sap: "seiva",
         acid: "\xE1cido",
         paint: "tinta",
@@ -1115,7 +1170,7 @@ var GameFluids = (() => {
       }
       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);
@@ -1123,6 +1178,7 @@ var GameFluids = (() => {
         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();
@@ -1130,6 +1186,7 @@ var GameFluids = (() => {
       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) });
@@ -1322,7 +1379,8 @@ var GameFluids = (() => {
       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,
@@ -1507,14 +1565,14 @@ var GameFluids = (() => {
         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()]) {
@@ -2202,6 +2260,974 @@ var GameFluids = (() => {
     };
     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;
+  }
   return __toCommonJS(index_exports);
 })();
 //# sourceMappingURL=index.global.js.map