@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-5325XSCH.js

@@ -0,0 +1,107 @@
+'use strict';
+
+var chunkYXGZQPUD_js = require('./chunk-YXGZQPUD.js');
+
+// src/game/kit/feel/noise.ts
+var HASH30_SCALE = 1862645149230957e-24;
+function hash30(i, channel, seed) {
+  let h = Math.imul((i | 0) ^ seed, 668265261) ^ Math.imul(channel + 1, 374761393);
+  return h ^= h >>> 15, h = Math.imul(h, 668265261), h ^= h >>> 13, h >>> 2;
+}
+
+// src/game/kit/feel/shake.ts
+var SHAKE_X = 0, SHAKE_Y = 1, SHAKE_Z = 2, SHAKE_ROLL = 3, SHAKE_CHANNELS = 4, MAX_PENDING = 8, DEFAULT_MAX_OFFSET = 0.35, DEFAULT_MAX_ROLL = 0.06, DEFAULT_DECAY = 1.6, DEFAULT_FREQUENCY = 22, DEPTH_SCALE = 0.5, S_TRAUMA = 0, S_TIME = 1, S_DT = 2, S_PENDING_COUNT = 3, S_COUNT = 4, ScreenShake = class {
+  constructor(options = {}) {
+    this.offset = new Float32Array(4);
+    this.state = new Float64Array((4));
+    this.amplitude = new Float64Array((4));
+    this.pending = new Float64Array((8));
+    let offset = options.maxOffset ?? (0.35);
+    this.amplitude[(0)] = offset, this.amplitude[(1)] = offset, this.amplitude[(2)] = offset * (0.5), this.amplitude[(3)] = options.maxRoll ?? (0.06), this.decay = options.decayPerSecond ?? (1.6), this.frequency = options.frequency ?? (22), this.seed = options.seed ?? 1;
+  }
+  get trauma() {
+    return this.absorb(), this.state[(0)];
+  }
+  absorb() {
+    let s = this.state, count = s[(3)];
+    if (count === 0) return;
+    let t = s[(0)];
+    for (let i = 0; i < count; i++) t += this.pending[i];
+    s[(0)] = t > 1 ? 1 : t < 0 ? 0 : t, s[(3)] = 0;
+  }
+  add(amount) {
+    let s = this.state, count = s[(3)];
+    count >= (8) || (this.pending[count] = amount, s[(3)] = count + 1);
+  }
+  update(time) {
+    this.state[(2)] = time.values[chunkYXGZQPUD_js.FRAME_SECONDS_SLOT], this.run();
+  }
+  advance(seconds) {
+    this.state[(2)] = seconds, this.run();
+  }
+  reset() {
+    this.state[(3)] = 0, this.state[(0)] = 0, this.offset.fill(0);
+  }
+  run() {
+    let s = this.state, o = this.offset;
+    this.absorb();
+    let trauma = s[(0)];
+    if (trauma <= 0) {
+      o[(0)] = 0, o[(1)] = 0, o[(2)] = 0, o[(3)] = 0;
+      return;
+    }
+    let seconds = s[(2)], t = s[(1)] + seconds * this.frequency;
+    s[(1)] = t;
+    let power = trauma * trauma, seed = this.seed, cell = Math.floor(t), f = t - cell, u = f * f * (3 - 2 * f);
+    for (let channel = 0; channel < (4); channel++) {
+      let a = hash30(cell, channel, seed) * (1862645149230957e-24) - 1, b = hash30(cell + 1, channel, seed) * (1862645149230957e-24) - 1;
+      o[channel] = (a + (b - a) * u) * power * this.amplitude[channel];
+    }
+    let next = trauma - this.decay * seconds;
+    s[(0)] = next > 0 ? next : 0;
+  }
+};
+
+// src/game/kit/feel/hit-stop.ts
+var MIN_SCALE = 0.02, S_REMAINING = 0, S_SCALE = 1, S_PENDING_SECONDS = 2, S_PENDING_SCALE = 3, S_PENDING = 4, S_COUNT2 = 5, HitStop = class {
+  constructor() {
+    this.state = new Float64Array((5));
+  }
+  get active() {
+    return this.absorb(), this.state[(0)] > 0;
+  }
+  get remaining() {
+    return this.absorb(), this.state[(0)];
+  }
+  trigger(seconds, scale = (0.02)) {
+    this.state[(2)] = seconds, this.state[(3)] = scale, this.state[(4)] = 1;
+  }
+  freezeStep(time) {
+    this.absorb();
+    let s = this.state;
+    return s[(0)] <= 0 ? false : (s[(0)] -= time.values[chunkYXGZQPUD_js.FRAME_STEP_SECONDS_SLOT], true);
+  }
+  drive(loop) {
+    this.absorb();
+    let s = this.state, values = loop.time.values, scale = loop.timeScale;
+    if (s[(0)] <= 0) {
+      scale !== 1 && (loop.timeScale = 1);
+      return;
+    }
+    s[(0)] -= values[chunkYXGZQPUD_js.FRAME_SECONDS_SLOT] / (scale > 0 ? scale : 1), loop.timeScale = s[(0)] > 0 ? s[(1)] : 1;
+  }
+  cancel(loop = null) {
+    this.state[(4)] = 0, this.state[(0)] = 0, loop !== null && (loop.timeScale = 1);
+  }
+  absorb() {
+    let s = this.state;
+    s[(4)] !== 0 && (s[(4)] = 0, s[(2)] > s[(0)] && (s[(0)] = s[(2)]), s[(1)] = s[(3)] > (0.02) ? s[(3)] : (0.02));
+  }
+};
+
+exports.HitStop = HitStop;
+exports.SHAKE_ROLL = (3);
+exports.SHAKE_X = (0);
+exports.SHAKE_Y = (1);
+exports.SHAKE_Z = (2);
+exports.ScreenShake = ScreenShake;

package/dist/chunk-5AD5X6AV.js

@@ -0,0 +1,13 @@
+'use strict';
+
+// src/game/terrain/voxels.ts
+var ENGINE_VOXEL_FACET_EXPORT_NAMES = [
+  "engine_voxel_snapshot",
+  "engine_voxel_branch",
+  "engine_voxel_release",
+  "engine_voxel_export",
+  "engine_voxel_import",
+  "engine_voxel_root"
+];
+
+exports.ENGINE_VOXEL_FACET_EXPORT_NAMES = ENGINE_VOXEL_FACET_EXPORT_NAMES;

package/dist/chunk-5BYDGGWO.mjs

@@ -0,0 +1,197 @@
+import { GPU_PASS_NAMES } from './chunk-TL2SVO4P.mjs';
+import { ENGINE_HEAP_CEILING_BYTES } from './chunk-JURRXY2J.mjs';
+import { GameError } from './chunk-XJIHN3BY.mjs';
+
+// src/game/prefetch/layer.ts
+var DEFAULT_PREFETCH_CELL = 32, FLOW_WORDS = 2, FLOW_BACKLOG = 0, FLOW_DELIVERED = 1, MAX_PREFETCH_LEVELS = 16, MAX_PREFETCH_ENTRIES = 1 << 24, MAX_GRID_CELLS = 1 << 20, MAX_ENTRY_BYTES = 1073741823;
+function distanceOf(value) {
+  return typeof value == "number" ? () => value : value;
+}
+var PrefetchLayer = class {
+  constructor(desc) {
+    this.place = new Float64Array(8);
+    this.placed = false;
+    let items = desc.items, n = items.length;
+    this.name = desc.name ?? "layer", this.count = n, this.x = new Float64Array(n), this.y = new Float64Array(n), this.z = new Float64Array(n), this.radius = new Float64Array(n), this.entryStart = new Int32Array(n + 1);
+    let entries = 0, maxRadius = 0, minX = 1 / 0, minZ = 1 / 0, maxX = -1 / 0, maxZ = -1 / 0;
+    for (let i = 0; i < n; i++) {
+      let item = items[i], levels = item.levels.length;
+      if (levels === 0 || levels > (16)) throw new GameError("invalid_argument", `prefetch item ${i} needs 1 to ${(16)} levels`);
+      this.x[i] = item.center[0], this.y[i] = item.center[1], this.z[i] = item.center[2];
+      let r = Math.max(0, item.radius ?? 0);
+      this.radius[i] = r, r > maxRadius && (maxRadius = r), item.center[0] < minX && (minX = item.center[0]), item.center[2] < minZ && (minZ = item.center[2]), item.center[0] > maxX && (maxX = item.center[0]), item.center[2] > maxZ && (maxZ = item.center[2]), this.entryStart[i] = entries, entries += levels;
+    }
+    if (entries > MAX_PREFETCH_ENTRIES) throw new GameError("invalid_argument", `a prefetch layer holds at most ${MAX_PREFETCH_ENTRIES} levels`);
+    this.entryStart[n] = entries, this.entries = entries, this.entryItem = new Int32Array(entries), this.entryLevel = new Uint8Array(entries), this.entryWithin = new Float64Array(entries), this.entryBytes = new Int32Array(entries);
+    let paths = [];
+    for (let i = 0; i < n; i++) {
+      let item = items[i];
+      for (let l = 0; l < item.levels.length; l++) {
+        let e = this.entryStart[i] + l, level = item.levels[l];
+        this.entryItem[e] = i, this.entryLevel[e] = l, this.entryWithin[e] = level.within ?? 1 / 0, this.entryBytes[e] = Math.min((1073741823), Math.max(0, Math.round(level.bytes ?? (l === 0 ? item.bytes ?? 0 : 0)))), paths.push(level.path);
+      }
+    }
+    this.paths = paths, this.maxRadius = maxRadius;
+    let cell = desc.cellSize ?? (32);
+    if (!(cell > 0)) throw new GameError("invalid_argument", "a prefetch layer cell size must be above zero");
+    for (n === 0 && (minX = 0, minZ = 0, maxX = 0, maxZ = 0); Math.floor((maxX - minX) / cell + 1) * Math.floor((maxZ - minZ) / cell + 1) > MAX_GRID_CELLS; ) cell *= 2;
+    this.cellSize = cell, this.originX = minX, this.originZ = minZ, this.cols = Math.floor((maxX - minX) / cell) + 1, this.rows = Math.floor((maxZ - minZ) / cell) + 1;
+    let cells = this.cols * this.rows;
+    this.cellStart = new Int32Array(cells + 1), this.cellItems = new Int32Array(n);
+    let cellOf = new Int32Array(n);
+    for (let i = 0; i < n; i++) {
+      let c = this.cellIndex(this.x[i], this.z[i]);
+      cellOf[i] = c, this.cellStart[c + 1]++;
+    }
+    for (let c = 0; c < cells; c++) this.cellStart[c + 1] += this.cellStart[c];
+    let fill = this.cellStart.slice(0, cells);
+    for (let i = 0; i < n; i++) this.cellItems[fill[cellOf[i]]++] = i;
+    this.loadRadius = distanceOf(desc.radius), this.needRadius = distanceOf(desc.need ?? desc.radius), this.held = desc.held ?? null, this.busy = desc.busy ?? null, this.flow = desc.flow !== void 0 && desc.flow.length >= (2) ? desc.flow : null, this.place[6] = 1, this.place[7] = 1;
+  }
+  cellIndex(x, z) {
+    let col = Math.min(this.cols - 1, Math.max(0, Math.floor((x - this.originX) / this.cellSize)));
+    return Math.min(this.rows - 1, Math.max(0, Math.floor((z - this.originZ) / this.cellSize))) * this.cols + col;
+  }
+  get scale() {
+    return this.place[7];
+  }
+  setPlacement(transform) {
+    let p = this.place;
+    if (transform === null) {
+      p.fill(0), p[6] = 1, p[7] = 1, this.placed = false;
+      return;
+    }
+    let length = Math.hypot(transform[3], transform[4], transform[5], transform[6]) || 1;
+    p[0] = transform[0], p[1] = transform[1], p[2] = transform[2], p[3] = transform[3] / length, p[4] = transform[4] / length, p[5] = transform[5] / length, p[6] = transform[6] / length, p[7] = transform[7] > 0 ? transform[7] : 1, this.placed = true;
+  }
+  toLocal(position, out, offset, point) {
+    let x = position[0], y = position[1], z = position[2];
+    if (!this.placed) {
+      out[offset] = x, out[offset + 1] = y, out[offset + 2] = z;
+      return;
+    }
+    let p = this.place;
+    point && (x -= p[0], y -= p[1], z -= p[2]);
+    let qx = -p[3], qy = -p[4], qz = -p[5], qw = p[6], tx = 2 * (qy * z - qz * y), ty = 2 * (qz * x - qx * z), tz = 2 * (qx * y - qy * x), inv = 1 / p[7];
+    out[offset] = (x + qw * tx + (qy * tz - qz * ty)) * inv, out[offset + 1] = (y + qw * ty + (qz * tx - qx * tz)) * inv, out[offset + 2] = (z + qw * tz + (qx * ty - qy * tx)) * inv;
+  }
+};
+
+// src/interactives/meters/calibration.ts
+var UNCALIBRATED_SCALE = 1;
+function median(values) {
+  if (values.length === 0) return 1;
+  values.sort((a, b) => a - b);
+  let mid = values.length >> 1;
+  return values.length % 2 === 1 ? values[mid] : (values[mid - 1] + values[mid]) / 2;
+}
+function ratios(runs, measured, predicted) {
+  let out = [];
+  for (let run of runs) {
+    let p = predicted(run), m = measured(run);
+    p > 0 && m > 0 && Number.isFinite(p) && Number.isFinite(m) && out.push(m / p);
+  }
+  return out;
+}
+function fitCalibration(device, tier, runs) {
+  let mine = runs.filter((run) => run.device === device && run.tier === tier);
+  return {
+    device,
+    tier,
+    frameScale: median(
+      ratios(
+        mine,
+        (r) => r.measuredFrameMs,
+        (r) => r.predictedFrameMs
+      )
+    ),
+    gpuScale: median(
+      ratios(
+        mine,
+        (r) => r.measuredGpuMs,
+        (r) => r.predictedGpuMs
+      )
+    ),
+    memoryScale: median(
+      ratios(
+        mine,
+        (r) => r.measuredMemoryBytes,
+        (r) => r.predictedMemoryBytes
+      )
+    ),
+    openScale: median(
+      ratios(
+        mine,
+        (r) => r.measuredOpenSeconds,
+        (r) => r.predictedOpenSeconds
+      )
+    ),
+    runs: mine.length
+  };
+}
+function isCalibrated(calibration) {
+  return calibration !== null && calibration.runs > 0;
+}
+function calibrationFor(calibrations, tier) {
+  let best = null;
+  for (let calibration of calibrations)
+    calibration.tier !== tier || calibration.runs === 0 || (best === null || calibration.runs > best.runs) && (best = calibration);
+  return best;
+}
+
+// src/interactives/meters/tier-budgets.json
+var tier_budgets_default = {
+  low: { download_bytes: 67108864, first_play_bytes: 8388608, stream_bytes_per_second: 187500, stream_latency_ms: 150 },
+  mid: { download_bytes: 268435456, first_play_bytes: 25165824, stream_bytes_per_second: 75e4, stream_latency_ms: 80 },
+  high: { download_bytes: 1073741824, first_play_bytes: 67108864, stream_bytes_per_second: 3125e3, stream_latency_ms: 40 }
+};
+
+// src/interactives/meters/budgets.ts
+var METER_TIERS = ["low", "mid", "high"], REQUEST_CONCURRENCY = 4;
+function budgetOf(tier) {
+  let row = tier_budgets_default[tier];
+  return {
+    downloadBytes: row.download_bytes,
+    firstPlayBytes: row.first_play_bytes,
+    link: { bytesPerSecond: row.stream_bytes_per_second, latencyMs: row.stream_latency_ms, concurrency: (4) }
+  };
+}
+var DELIVERY_BUDGETS = {
+  low: budgetOf("low"),
+  mid: budgetOf("mid"),
+  high: budgetOf("high")
+}, THREE_G_LINK = DELIVERY_BUDGETS.low.link, INSTANT_OPEN_SECONDS = 2, SLOW_OPEN_SECONDS = 5, TARGET_HZ = 60, SMOOTH_SHARE = 0.95, STUTTER_SHARE = 0.8, MEMORY_CEILING_BYTES = ENGINE_HEAP_CEILING_BYTES, TIGHT_MEMORY_SHARE = 0.8, WARM_BUSY_SHARE = 0.6, HOT_BUSY_SHARE = 0.85, WARM_PRESSURE = 1, HOT_PRESSURE = 2;
+
+// src/interactives/meters/causes.ts
+var MOST_SHARE = 0.5, SOME_SHARE = 0.2, MAX_CAUSES = 3, PASS_LABELS = {
+  cull: "Working out what is on screen",
+  particles: "Particles and effects",
+  shadow: "Shadows",
+  main: "Drawing the scene",
+  overlay: "On-screen interface",
+  post: "Screen effects such as glow and blur",
+  targets: "Mirrors, cameras and screens",
+  gi: "Bounced light",
+  rt: "Reflections",
+  volumetrics: "Fog, smoke and weather"
+};
+function amountOf(share) {
+  return share >= (0.5) ? "most" : share >= (0.2) ? "some" : "a_little";
+}
+function rankCauses(entries, limit = (3)) {
+  let total = 0;
+  for (let entry of entries) entry.cost > 0 && (total += entry.cost);
+  return total <= 0 ? [] : entries.filter((entry) => entry.cost > 0).map((entry) => ({
+    label: entry.label,
+    share: entry.cost / total,
+    amount: amountOf(entry.cost / total)
+  })).sort((a, b) => b.share - a.share || a.label.localeCompare(b.label)).slice(0, limit);
+}
+function passCauses(passNs, limit = (3)) {
+  let entries = [];
+  for (let i = 0; i < GPU_PASS_NAMES.length && i < passNs.length; i++)
+    entries.push({ label: PASS_LABELS[GPU_PASS_NAMES[i]], cost: passNs[i] });
+  return rankCauses(entries, limit);
+}
+
+export { DEFAULT_PREFETCH_CELL, DELIVERY_BUDGETS, FLOW_BACKLOG, FLOW_DELIVERED, FLOW_WORDS, HOT_BUSY_SHARE, HOT_PRESSURE, INSTANT_OPEN_SECONDS, MAX_CAUSES, MAX_PREFETCH_LEVELS, MEMORY_CEILING_BYTES, METER_TIERS, MOST_SHARE, PASS_LABELS, PrefetchLayer, REQUEST_CONCURRENCY, SLOW_OPEN_SECONDS, SMOOTH_SHARE, SOME_SHARE, STUTTER_SHARE, TARGET_HZ, THREE_G_LINK, TIGHT_MEMORY_SHARE, UNCALIBRATED_SCALE, WARM_BUSY_SHARE, WARM_PRESSURE, amountOf, calibrationFor, fitCalibration, isCalibrated, passCauses, rankCauses };

package/dist/chunk-5C3C7VDM.mjs

@@ -0,0 +1,55 @@
+import { CAMERA_LAYOUT, FACE_LAYOUT } from './chunk-SPCRQ6NO.mjs';
+
+// src/interactives/runtime/camera-wire.ts
+var CAMERA_TAG_BYTES = 1, CAMERA_WORD_BYTES = 4, CAMERA_ID_AT = (1), CAMERA_SECOND_AT = CAMERA_ID_AT + (4), CAMERA_HANDLE_BYTES = (1) + (4), CAMERA_PAIR_BYTES = CAMERA_HANDLE_BYTES + (4), CAMERA_COLOURED_BYTES = CAMERA_HANDLE_BYTES + (4) * 3, CAMERA_IDENTITY_CODE_AT = CAMERA_HANDLE_BYTES, CAMERA_IDENTIFIED_BYTES = CAMERA_IDENTITY_CODE_AT + 1, IDENTITY_CAPTURED = 0, IDENTITY_CODES = CAMERA_LAYOUT.identity_codes;
+function identityCodeByte(code) {
+  return IDENTITY_CODES.indexOf(code) + 1;
+}
+var NO_CAMERA = 0, NO_FACE_COLOUR = -1, CameraOpenPurpose = { track: 0, view: 1 }, CAMERA_PURPOSE_AT = CAMERA_HANDLE_BYTES, CAMERA_OPEN_BYTES = CAMERA_HANDLE_BYTES + 1, CameraViewFlag = { shown: 1, mirror: 2, over: 4 }, CAMERA_PLACE_X_AT = CAMERA_HANDLE_BYTES, CAMERA_PLACE_FLAGS_AT = CAMERA_PLACE_X_AT + (4) * 4, CAMERA_PLACE_BYTES = CAMERA_PLACE_FLAGS_AT + 1, FACE_FRAME = {
+  sequence: 0,
+  faces: 1,
+  measured: 2,
+  header_words: 3,
+  expression_floats: FACE_LAYOUT.expressions.length,
+  arkit_floats: FACE_LAYOUT.arkit.length,
+  pose_floats: FACE_LAYOUT.head_pose.length
+}, FACE_FLOATS = FACE_FRAME.expression_floats + FACE_FRAME.arkit_floats + FACE_FRAME.pose_floats, FACE_ARKIT_AT = FACE_FRAME.expression_floats, FACE_POSE_AT = FACE_ARKIT_AT + FACE_FRAME.arkit_floats, FACE_FRAME_BYTES = (FACE_FRAME.header_words + FACE_FLOATS) * (4), FACE_PAYLOAD_OFFSET = FACE_FRAME.faces * (4), FACE_PAYLOAD_BYTES = FACE_FRAME_BYTES - FACE_PAYLOAD_OFFSET, FACE_FLOATS_AT = (FACE_FRAME.header_words - FACE_FRAME.faces) * (4), CAMERA_FACE_BYTES = CAMERA_HANDLE_BYTES + FACE_PAYLOAD_BYTES, CameraRefusal = {
+  noGrant: "no_face_tracking_grant",
+  noPreview: "no_preview_grant",
+  denied: "camera_denied",
+  unavailable: "camera_unavailable",
+  busy: "camera_busy",
+  notOpen: "stream_not_open",
+  badPlacement: "camera_bad_placement"
+}; ({
+  mirror: CAMERA_LAYOUT.view_default_mirror,
+  layer: CAMERA_LAYOUT.view_default_layer
+});
+function readSigned(bytes, at) {
+  return bytes[at] | bytes[at + 1] << 8 | bytes[at + 2] << 16 | bytes[at + 3] << 24;
+}
+function readWord(bytes, at) {
+  return readSigned(bytes, at) >>> 0;
+}
+function writeWord(bytes, at, value) {
+  bytes[at] = value & 255, bytes[at + 1] = value >>> 8 & 255, bytes[at + 2] = value >>> 16 & 255, bytes[at + 3] = value >>> 24 & 255;
+}
+var floatScratch = new Float32Array(1), floatBytes = new Uint8Array(floatScratch.buffer);
+function readFloat(bytes, at) {
+  return floatBytes[0] = bytes[at], floatBytes[1] = bytes[at + 1], floatBytes[2] = bytes[at + 2], floatBytes[3] = bytes[at + 3], floatScratch[0];
+}
+
+// src/interactives/runtime/jsc-camera.ts
+({
+  expression_floats: FACE_LAYOUT.expressions.length,
+  pose_floats: FACE_LAYOUT.head_pose.length
+});
+var IdentityCaptureError = class extends Error {
+  constructor(code) {
+    super(`the identity capture ended: ${code}`);
+    this.code = code;
+    this.name = "IdentityCaptureError";
+  }
+};
+
+export { CAMERA_COLOURED_BYTES, CAMERA_FACE_BYTES, CAMERA_HANDLE_BYTES, CAMERA_IDENTIFIED_BYTES, CAMERA_IDENTITY_CODE_AT, CAMERA_ID_AT, CAMERA_OPEN_BYTES, CAMERA_PAIR_BYTES, CAMERA_PLACE_BYTES, CAMERA_PLACE_FLAGS_AT, CAMERA_PLACE_X_AT, CAMERA_PURPOSE_AT, CAMERA_SECOND_AT, CAMERA_WORD_BYTES, CameraOpenPurpose, CameraRefusal, CameraViewFlag, FACE_ARKIT_AT, FACE_FLOATS, FACE_FLOATS_AT, FACE_FRAME, FACE_PAYLOAD_BYTES, FACE_POSE_AT, IDENTITY_CAPTURED, IdentityCaptureError, NO_CAMERA, NO_FACE_COLOUR, identityCodeByte, readFloat, readWord, writeWord };