@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-VVE3Y76O.js

@@ -0,0 +1,230 @@
+'use strict';
+
+var chunkIIDZ5WUX_js = require('./chunk-IIDZ5WUX.js');
+var chunkO2ICABUD_js = require('./chunk-O2ICABUD.js');
+var chunk2V7IL4HC_js = require('./chunk-2V7IL4HC.js');
+
+// 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 chunk2V7IL4HC_js.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 chunk2V7IL4HC_js.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 chunk2V7IL4HC_js.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 = chunkO2ICABUD_js.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 < chunkIIDZ5WUX_js.GPU_PASS_NAMES.length && i < passNs.length; i++)
+    entries.push({ label: PASS_LABELS[chunkIIDZ5WUX_js.GPU_PASS_NAMES[i]], cost: passNs[i] });
+  return rankCauses(entries, limit);
+}
+
+exports.DEFAULT_PREFETCH_CELL = (32);
+exports.DELIVERY_BUDGETS = DELIVERY_BUDGETS;
+exports.FLOW_BACKLOG = (0);
+exports.FLOW_DELIVERED = (1);
+exports.FLOW_WORDS = (2);
+exports.HOT_BUSY_SHARE = (0.85);
+exports.HOT_PRESSURE = (2);
+exports.INSTANT_OPEN_SECONDS = (2);
+exports.MAX_CAUSES = (3);
+exports.MAX_PREFETCH_LEVELS = (16);
+exports.MEMORY_CEILING_BYTES = MEMORY_CEILING_BYTES;
+exports.METER_TIERS = METER_TIERS;
+exports.MOST_SHARE = (0.5);
+exports.PASS_LABELS = PASS_LABELS;
+exports.PrefetchLayer = PrefetchLayer;
+exports.REQUEST_CONCURRENCY = (4);
+exports.SLOW_OPEN_SECONDS = (5);
+exports.SMOOTH_SHARE = (0.95);
+exports.SOME_SHARE = (0.2);
+exports.STUTTER_SHARE = (0.8);
+exports.TARGET_HZ = (60);
+exports.THREE_G_LINK = THREE_G_LINK;
+exports.TIGHT_MEMORY_SHARE = (0.8);
+exports.UNCALIBRATED_SCALE = (1);
+exports.WARM_BUSY_SHARE = (0.6);
+exports.WARM_PRESSURE = (1);
+exports.amountOf = amountOf;
+exports.calibrationFor = calibrationFor;
+exports.fitCalibration = fitCalibration;
+exports.isCalibrated = isCalibrated;
+exports.passCauses = passCauses;
+exports.rankCauses = rankCauses;