@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-HSEO6TPU.js

@@ -0,0 +1,247 @@
+'use strict';
+
+var chunkPQTQKNKD_js = require('./chunk-PQTQKNKD.js');
+
+// src/game/kit/identity/fit.ts
+var FIT_ITERATIONS = 12, LANDMARK_NOISE = 0.01, RIDGE = 1e-9, PLANE = 2;
+function fittedTone(skin, stylise) {
+  let tone = chunkPQTQKNKD_js.toneFromColour(skin);
+  return stylise >= 1 ? chunkPQTQKNKD_js.snapTone(tone) : tone;
+}
+var IdentityFitError = class extends Error {
+  constructor(message) {
+    super(message), this.name = "IdentityFitError";
+  }
+};
+function choleskySolve(matrix, n, rhs, out) {
+  let l = matrix;
+  for (let j = 0; j < n; j++) {
+    let d = l[j * n + j];
+    for (let k = 0; k < j; k++) d -= l[j * n + k] * l[j * n + k];
+    if (d <= 0) throw new IdentityFitError("normal equations are not positive definite");
+    let root = Math.sqrt(d);
+    l[j * n + j] = root;
+    for (let i = j + 1; i < n; i++) {
+      let s = l[i * n + j];
+      for (let k = 0; k < j; k++) s -= l[i * n + k] * l[j * n + k];
+      l[i * n + j] = s / root;
+    }
+  }
+  for (let i = 0; i < n; i++) {
+    let s = rhs[i];
+    for (let k = 0; k < i; k++) s -= l[i * n + k] * out[k];
+    out[i] = s / l[i * n + i];
+  }
+  for (let i = n - 1; i >= 0; i--) {
+    let s = out[i];
+    for (let k = i + 1; k < n; k++) s -= l[k * n + i] * out[k];
+    out[i] = s / l[i * n + i];
+  }
+}
+function invert3(m, out) {
+  let [a, b, c, d, e, f, g, h, i] = [m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7], m[8]], A = e * i - f * h, B = -(d * i - f * g), C = d * h - e * g, det = a * A + b * B + c * C;
+  if (det === 0) throw new IdentityFitError("landmark anchors are degenerate");
+  out[0] = A / det, out[1] = -(b * i - c * h) / det, out[2] = (b * f - c * e) / det, out[3] = B / det, out[4] = (a * i - c * g) / det, out[5] = -(a * f - c * d) / det, out[6] = C / det, out[7] = -(a * h - b * g) / det, out[8] = (a * e - b * d) / det;
+}
+var IdentityFitter = class {
+  constructor(base) {
+    this.base = base, this.anchors = base.anchors.names.length;
+    let k = base.components, cage = new Float64Array(base.basis.cage.length), unit = new Float32Array(k), at = new Float64Array(3), all = new Float64Array(this.anchors * k * 3);
+    for (let c = 0; c < k; c++) {
+      unit.fill(0), unit[c] = 1, chunkPQTQKNKD_js.cageDisplacement(base, unit, cage);
+      for (let l = 0; l < this.anchors; l++) {
+        chunkPQTQKNKD_js.blendCage(cage, base.anchors.cageIndex, base.anchors.cageWeight, l, at);
+        for (let a = 0; a < 3; a++) all[(l * k + c) * 3 + a] = at[a];
+      }
+    }
+    let face = base.basis.face, body = base.basis.body;
+    this.faceBasis = new Float64Array(this.anchors * face * 3), this.bodyBasis = new Float64Array(this.anchors * body * 3);
+    for (let l = 0; l < this.anchors; l++)
+      for (let c = 0; c < k; c++)
+        for (let a = 0; a < 3; a++) {
+          let v = all[(l * k + c) * 3 + a];
+          c < face ? this.faceBasis[(l * face + c) * 3 + a] = v : this.bodyBasis[(l * body + c - face) * 3 + a] = v;
+        }
+  }
+  anchorPositions(face, body, out) {
+    let { rest } = this.base.anchors, nf = this.base.basis.face, nb = this.base.basis.body;
+    for (let l = 0; l < this.anchors; l++)
+      for (let a = 0; a < 3; a++) {
+        let v = rest[l * 3 + a];
+        for (let c = 0; c < nf; c++) v += this.faceBasis[(l * nf + c) * 3 + a] * face[c];
+        for (let c = 0; c < nb; c++) v += this.bodyBasis[(l * nb + c) * 3 + a] * body[c];
+        out[l * 3 + a] = v;
+      }
+  }
+  observations(capture) {
+    let { layout } = this.base.anchors, points = new Float64Array(this.anchors * (2));
+    for (let l = 0; l < this.anchors; l++) {
+      let index = layout[l];
+      if ((index + 1) * 3 > capture.landmarks.length) throw new IdentityFitError("capture is missing a landmark the identity base needs");
+      let x = capture.landmarks[index * 3] * capture.aspect, y = capture.landmarks[index * 3 + 1];
+      if (!Number.isFinite(x) || !Number.isFinite(y)) throw new IdentityFitError("capture landmarks must be finite");
+      points[l * (2)] = x, points[l * (2) + 1] = y;
+    }
+    let mx = 0, my = 0;
+    for (let l = 0; l < this.anchors; l++)
+      mx += points[l * (2)], my += points[l * (2) + 1];
+    mx /= this.anchors, my /= this.anchors;
+    let spread = 0;
+    for (let l = 0; l < this.anchors; l++)
+      points[l * (2)] -= mx, points[l * (2) + 1] -= my, spread += points[l * (2)] * points[l * (2)] + points[l * (2) + 1] * points[l * (2) + 1];
+    let radius = Math.sqrt(spread / this.anchors);
+    if (radius === 0) throw new IdentityFitError("capture landmarks collapse to a point");
+    for (let i = 0; i < points.length; i++) points[i] /= radius;
+    return points;
+  }
+  fit(capture, options = {}) {
+    let base = this.base, nf = base.basis.face, n = this.anchors, body = options.body ?? new Float32Array(base.basis.body);
+    if (body.length !== base.basis.body) throw new IdentityFitError("body coefficients do not match the identity base");
+    let p = this.observations(capture), face = new Float64Array(nf), anchors = new Float64Array(n * 3), centred = new Float64Array(n * 3), gram = new Float64Array(9), inverse = new Float64Array(9), rows = new Float64Array((2) * 3), cross = new Float64Array((2) * 3), restOnly = new Float64Array(n * 3), zero = new Float64Array(nf), normal = new Float64Array(nf * nf), rhs = new Float64Array(nf), jacobian = new Float64Array(n * (2) * nf), projected = new Float64Array((2)), scale = 1, prior = (0.01) * (0.01), meanBasis = new Float64Array(nf * 3);
+    for (let c = 0; c < nf; c++)
+      for (let a = 0; a < 3; a++) {
+        let s = 0;
+        for (let l = 0; l < n; l++) s += this.faceBasis[(l * nf + c) * 3 + a];
+        meanBasis[c * 3 + a] = s / n;
+      }
+    for (let iteration = 0; iteration < (12); iteration++) {
+      this.anchorPositions(face, body, anchors), centre(anchors, n, centred), gram.fill(0), cross.fill(0);
+      for (let l = 0; l < n; l++)
+        for (let r = 0; r < 3; r++) {
+          for (let c = 0; c < 3; c++) gram[r * 3 + c] += centred[l * 3 + r] * centred[l * 3 + c];
+          cross[r] += p[l * (2)] * centred[l * 3 + r], cross[3 + r] += p[l * (2) + 1] * centred[l * 3 + r];
+        }
+      for (let r = 0; r < 3; r++) gram[r * 3 + r] += (1e-9);
+      invert3(gram, inverse);
+      for (let row = 0; row < (2); row++)
+        for (let c = 0; c < 3; c++) {
+          let s = 0;
+          for (let k = 0; k < 3; k++) s += cross[row * 3 + k] * inverse[k * 3 + c];
+          rows[row * 3 + c] = s;
+        }
+      scale = orthonormalise(rows), this.anchorPositions(zero, body, restOnly), centre(restOnly, n, restOnly);
+      for (let l = 0; l < n; l++)
+        for (let row = 0; row < (2); row++)
+          for (let c = 0; c < nf; c++) {
+            let s = 0;
+            for (let a = 0; a < 3; a++) s += rows[row * 3 + a] * (this.faceBasis[(l * nf + c) * 3 + a] - meanBasis[c * 3 + a]);
+            jacobian[(l * (2) + row) * nf + c] = scale * s;
+          }
+      normal.fill(0), rhs.fill(0);
+      for (let i = 0; i < n * (2); i++) {
+        let l = i >> 1, row = i & 1, model = 0;
+        for (let a = 0; a < 3; a++) model += rows[row * 3 + a] * restOnly[l * 3 + a];
+        let residual2 = p[i] - scale * model;
+        for (let c = 0; c < nf; c++) {
+          let j = jacobian[i * nf + c];
+          rhs[c] += j * residual2;
+          for (let d = 0; d <= c; d++) normal[c * nf + d] += j * jacobian[i * nf + d];
+        }
+      }
+      for (let c = 0; c < nf; c++) {
+        normal[c * nf + c] += prior;
+        for (let d = 0; d < c; d++) normal[d * nf + c] = normal[c * nf + d];
+      }
+      choleskySolve(normal, nf, rhs, face);
+    }
+    this.anchorPositions(face, body, anchors), centre(anchors, n, centred);
+    let error = 0, residual = options.residual ? new Float32Array(n * 3) : null;
+    for (let l = 0; l < n; l++) {
+      for (let row = 0; row < (2); row++) {
+        let s = 0;
+        for (let a = 0; a < 3; a++) s += rows[row * 3 + a] * centred[l * 3 + a];
+        projected[row] = p[l * (2) + row] - scale * s, error += projected[row] * projected[row];
+      }
+      if (residual !== null)
+        for (let a = 0; a < 3; a++) residual[l * 3 + a] = (rows[a] * projected[0] + rows[3 + a] * projected[1]) / scale;
+    }
+    let stylise = options.stylise ?? 1, colours = chunkPQTQKNKD_js.styliseColours(capture.colours, base.palettes, stylise), tone = options.continuousTone === true && capture.colours !== null ? fittedTone(capture.colours.skin, stylise) : null;
+    return { params: chunkPQTQKNKD_js.quantiseIdentity({
+      basis: base.id,
+      face: Float32Array.from(face),
+      body: Float32Array.from(body),
+      skin: colours.skin,
+      tone,
+      condition: "plain",
+      conditionAmount: 0,
+      conditionSeed: 0,
+      hair: colours.hair,
+      hairTip: colours.hair,
+      eye: colours.eye,
+      hairStyle: options.hairStyle ?? 0,
+      hairBlock: chunkPQTQKNKD_js.NEUTRAL_HAIR,
+      brows: options.brows ?? 0,
+      facialHair: options.facialHair ?? 0,
+      stylise,
+      height: chunkPQTQKNKD_js.NEUTRAL_LEVEL,
+      assistive: [],
+      fromPhoto: true,
+      residual
+    }), error: Math.sqrt(error / (n * (2))), camera: { scale, rows, translation: [0, 0] } };
+  }
+};
+function centre(points, n, out) {
+  for (let a = 0; a < 3; a++) {
+    let s = 0;
+    for (let l = 0; l < n; l++) s += points[l * 3 + a];
+    let mean = s / n;
+    for (let l = 0; l < n; l++) out[l * 3 + a] = points[l * 3 + a] - mean;
+  }
+}
+function orthonormalise(rows) {
+  let a = Math.sqrt(rows[0] * rows[0] + rows[1] * rows[1] + rows[2] * rows[2]), b = Math.sqrt(rows[3] * rows[3] + rows[4] * rows[4] + rows[5] * rows[5]);
+  if (a === 0 || b === 0) throw new IdentityFitError("camera is degenerate");
+  for (let i = 0; i < 3; i++) rows[i] /= a;
+  let dot = 0;
+  for (let i = 0; i < 3; i++) dot += rows[i] * rows[3 + i];
+  for (let i = 0; i < 3; i++) rows[3 + i] -= dot * rows[i];
+  let c = Math.sqrt(rows[3] * rows[3] + rows[4] * rows[4] + rows[5] * rows[5]);
+  for (let i = 0; i < 3; i++) rows[3 + i] /= c;
+  return (a + b) / 2;
+}
+function anchorWeightSum(base, anchor) {
+  let s = 0;
+  for (let k = 0; k < 4; k++) {
+    let w = base.anchors.cageWeight[anchor * 4 + k] / 65535;
+    s += w * w;
+  }
+  return s;
+}
+
+// src/game/kit/identity/policy.ts
+function refuse(refusal) {
+  return { allowed: false, refusal, minStylise: 1, residual: false, shareable: false };
+}
+function identityCapturePolicy(context) {
+  if (!context.consented) return refuse("consent_required");
+  if (context.ageRange === "under_16") return refuse("age_restricted");
+  if (context.ageRange === "undeclared") return refuse("age_undeclared");
+  if (context.subject !== "self") return refuse("self_only");
+  if (context.source !== "camera") return refuse("live_camera_only");
+  if (context.faces !== 1) return refuse("one_face_only");
+  if (Math.abs(context.yaw) > 0.35 || Math.abs(context.pitch) > 0.35) return refuse("face_turned");
+  if (context.faceWidth < 0.18) return refuse("face_too_small");
+  let adult = context.ageRange === "adult";
+  return { allowed: true, refusal: null, minStylise: adult ? 0 : 1, residual: adult, shareable: adult };
+}
+
+// src/game/kit/identity/from-capture.ts
+function identityFromCapture(base, capture, context, options = {}) {
+  let policy = identityCapturePolicy(context);
+  if (!policy.allowed) return { policy, fit: null };
+  let fitter = base instanceof IdentityFitter ? base : new IdentityFitter(base), stylise = Math.max(policy.minStylise, Math.min(1, options.stylise ?? 1));
+  if (!Number.isFinite(stylise)) throw new IdentityFitError("stylise must be finite");
+  return {
+    policy,
+    fit: fitter.fit(capture, {
+      ...options,
+      stylise,
+      residual: policy.residual && options.residual === true
+    })
+  };
+}
+
+exports.IdentityFitter = IdentityFitter;
+exports.anchorWeightSum = anchorWeightSum;
+exports.identityCapturePolicy = identityCapturePolicy;
+exports.identityFromCapture = identityFromCapture;

package/dist/chunk-I5FOHCLH.js

@@ -0,0 +1,132 @@
+'use strict';
+
+// src/interactives/engine-variants.ts
+var GATED_ENGINE_FEATURES = ["physics", "models", "images"], TEXT_DICTIONARIES_ASSET = "runtime/text-dictionaries.bin", TEXT_DICTIONARIES_FILE = "text-dictionaries.bin", ENGINE_CORE_GL_UNIT = "@cimplify/engine-core-gl", GL_CORE_GROUP = "gpu:webgl2", GL_CORE_PATH = "runtime/engine-core-gl.wasm";
+var WASM_EXTENSION = /\.wasm$/, BASE_ENGINE_VARIANT = { name: "base", features: [], file: "engine_wasm.base.wasm" }, PHYSICS_ENGINE_VARIANT = { name: "physics", features: ["physics"], file: "engine_wasm.physics.wasm" }, CONTENT_ENGINE_VARIANT = { name: "content", features: ["models", "images"], file: "engine_wasm.content.wasm" }, FULL_ENGINE_VARIANT = { name: "full", features: ["physics", "models", "images"], file: "engine_wasm.wasm" }, THREADED_ENGINE_VARIANT = { name: "threads", features: ["physics", "models", "images"], file: "engine_wasm.threads.wasm", threaded: true }, ENGINE_VARIANTS = [BASE_ENGINE_VARIANT, PHYSICS_ENGINE_VARIANT, CONTENT_ENGINE_VARIANT, FULL_ENGINE_VARIANT], THREADED_ENGINE_VARIANTS = [
+  { name: "threads-base", features: [], file: "engine_wasm.threads.base.wasm", threaded: true },
+  { name: "threads-physics", features: ["physics"], file: "engine_wasm.threads.physics.wasm", threaded: true },
+  { name: "threads-content", features: ["models", "images"], file: "engine_wasm.threads.content.wasm", threaded: true },
+  THREADED_ENGINE_VARIANT
+], SCRIPTS_ENGINE_VARIANT = { name: "scripts", features: ["physics", "models", "images"], file: "engine_wasm.scripts.wasm", scripts: true }, SCRIPTS_ENGINE_VARIANTS = [
+  { name: "base-scripts", features: [], file: "engine_wasm.base.scripts.wasm", scripts: true },
+  { name: "physics-scripts", features: ["physics"], file: "engine_wasm.physics.scripts.wasm", scripts: true },
+  { name: "content-scripts", features: ["models", "images"], file: "engine_wasm.content.scripts.wasm", scripts: true },
+  SCRIPTS_ENGINE_VARIANT
+], SCRIPTS_SHADERS_ENGINE_VARIANT = {
+  name: "scripts-shaders",
+  features: ["physics", "models", "images"],
+  file: "engine_wasm.scripts.shaders.wasm",
+  scripts: true,
+  shaders: true
+}, SCRIPTS_SHADERS_ENGINE_VARIANTS = [
+  { name: "base-scripts-shaders", features: [], file: "engine_wasm.base.scripts.shaders.wasm", scripts: true, shaders: true },
+  { name: "physics-scripts-shaders", features: ["physics"], file: "engine_wasm.physics.scripts.shaders.wasm", scripts: true, shaders: true },
+  { name: "content-scripts-shaders", features: ["models", "images"], file: "engine_wasm.content.scripts.shaders.wasm", scripts: true, shaders: true },
+  SCRIPTS_SHADERS_ENGINE_VARIANT
+];
+function glOf(variant) {
+  return { ...variant, name: `${variant.name}-gl`, file: variant.file.replace(WASM_EXTENSION, ".gl.wasm"), gl: true };
+}
+var GL_ENGINE_VARIANTS = [...ENGINE_VARIANTS, ...SCRIPTS_ENGINE_VARIANTS, ...SCRIPTS_SHADERS_ENGINE_VARIANTS].map(glOf);
+function isGlVariant(variant) {
+  return variant.gl === true;
+}
+function glVariantOf(variant) {
+  return isGlVariant(variant) ? variant : GL_ENGINE_VARIANTS.find((candidate) => candidate.file === glOf(variant).file) ?? null;
+}
+function webGpuVariantOf(variant) {
+  if (!isGlVariant(variant)) return variant;
+  let file = variant.file.replace(".gl.wasm", ".wasm");
+  return [...ENGINE_VARIANTS, ...SCRIPTS_ENGINE_VARIANTS, ...SCRIPTS_SHADERS_ENGINE_VARIANTS].find((candidate) => candidate.file === file) ?? FULL_ENGINE_VARIANT;
+}
+function gated(feature) {
+  return GATED_ENGINE_FEATURES.indexOf(feature) >= 0;
+}
+function sameFeatures(a, b) {
+  return a.features.length === b.features.length && a.features.every((feature) => b.features.indexOf(feature) >= 0);
+}
+var ENGINE_FEATURE_CARGO = {
+  physics: ["physics"],
+  models: ["models", "images"],
+  images: ["images"],
+  destruction_1: ["physics"],
+  rollback_1: ["physics"],
+  soft_body_1: ["physics"],
+  cloth_1: ["physics"],
+  joints_6dof_1: ["physics"],
+  ragdoll_1: ["physics"],
+  shapes_compound_1: ["physics"],
+  rigid_coupling_1: ["physics"],
+  destruction_2: ["physics"],
+  ragdoll_policy_1: ["physics"],
+  asset_reload_1: ["models", "images"],
+  chemistry_1: ["chemistry"],
+  reactive_fluid_1: ["reactive", "chemistry"],
+  genesis_1: ["genesis"],
+  transforms_1: ["transforms"],
+  scenery_1: ["scenery"]
+};
+function coreVariantFor(features) {
+  let cargo = features.flatMap((feature) => ENGINE_FEATURE_CARGO[feature] ?? []);
+  if (cargo.some((feature) => !gated(feature))) return FULL_ENGINE_VARIANT;
+  let needed = cargo.filter(gated);
+  for (let variant of ENGINE_VARIANTS) if (needed.every((feature) => variant.features.indexOf(feature) >= 0)) return variant;
+  return FULL_ENGINE_VARIANT;
+}
+function engineVariantFor(features, scripts = false, shaders = false) {
+  let core = coreVariantFor(features);
+  return scripts ? shaders ? scriptsShadersVariantOf(core) : scriptsVariantOf(core) : core;
+}
+function scriptsVariantOf(core) {
+  if (core === FULL_ENGINE_VARIANT) return SCRIPTS_ENGINE_VARIANT;
+  for (let variant of SCRIPTS_ENGINE_VARIANTS) if (sameFeatures(variant, core)) return variant;
+  return SCRIPTS_ENGINE_VARIANT;
+}
+function scriptsShadersVariantOf(core) {
+  if (core === FULL_ENGINE_VARIANT) return SCRIPTS_SHADERS_ENGINE_VARIANT;
+  for (let variant of SCRIPTS_SHADERS_ENGINE_VARIANTS) if (sameFeatures(variant, core)) return variant;
+  return SCRIPTS_SHADERS_ENGINE_VARIANT;
+}
+function isScriptsVariant(variant) {
+  return variant.scripts === true;
+}
+function isShadersVariant(variant) {
+  return variant.shaders === true;
+}
+function threadedVariantOf(core) {
+  for (let variant of THREADED_ENGINE_VARIANTS) if (sameFeatures(variant, core)) return variant;
+  return THREADED_ENGINE_VARIANT;
+}
+function isThreadedVariant(variant) {
+  return variant.threaded === true;
+}
+
+exports.BASE_ENGINE_VARIANT = BASE_ENGINE_VARIANT;
+exports.CONTENT_ENGINE_VARIANT = CONTENT_ENGINE_VARIANT;
+exports.ENGINE_CORE_GL_UNIT = ENGINE_CORE_GL_UNIT;
+exports.ENGINE_FEATURE_CARGO = ENGINE_FEATURE_CARGO;
+exports.ENGINE_VARIANTS = ENGINE_VARIANTS;
+exports.FULL_ENGINE_VARIANT = FULL_ENGINE_VARIANT;
+exports.GATED_ENGINE_FEATURES = GATED_ENGINE_FEATURES;
+exports.GL_CORE_GROUP = GL_CORE_GROUP;
+exports.GL_CORE_PATH = GL_CORE_PATH;
+exports.GL_ENGINE_VARIANTS = GL_ENGINE_VARIANTS;
+exports.PHYSICS_ENGINE_VARIANT = PHYSICS_ENGINE_VARIANT;
+exports.SCRIPTS_ENGINE_VARIANT = SCRIPTS_ENGINE_VARIANT;
+exports.SCRIPTS_ENGINE_VARIANTS = SCRIPTS_ENGINE_VARIANTS;
+exports.SCRIPTS_SHADERS_ENGINE_VARIANT = SCRIPTS_SHADERS_ENGINE_VARIANT;
+exports.SCRIPTS_SHADERS_ENGINE_VARIANTS = SCRIPTS_SHADERS_ENGINE_VARIANTS;
+exports.TEXT_DICTIONARIES_ASSET = TEXT_DICTIONARIES_ASSET;
+exports.TEXT_DICTIONARIES_FILE = TEXT_DICTIONARIES_FILE;
+exports.THREADED_ENGINE_VARIANT = THREADED_ENGINE_VARIANT;
+exports.THREADED_ENGINE_VARIANTS = THREADED_ENGINE_VARIANTS;
+exports.engineVariantFor = engineVariantFor;
+exports.glVariantOf = glVariantOf;
+exports.isGlVariant = isGlVariant;
+exports.isScriptsVariant = isScriptsVariant;
+exports.isShadersVariant = isShadersVariant;
+exports.isThreadedVariant = isThreadedVariant;
+exports.scriptsShadersVariantOf = scriptsShadersVariantOf;
+exports.scriptsVariantOf = scriptsVariantOf;
+exports.threadedVariantOf = threadedVariantOf;
+exports.webGpuVariantOf = webGpuVariantOf;

package/dist/chunk-IDLW4NWA.mjs

@@ -0,0 +1,85 @@
+import { GameError } from './chunk-XJIHN3BY.mjs';
+
+// src/game/loop.ts
+var FRAME_STEP_SECONDS_SLOT = 0, FRAME_SECONDS_SLOT = 1, FRAME_ALPHA_SLOT = 2, SLOT_ACCUMULATOR_MS = 3, SLOT_LAST_MS = 4, SLOT_DROPPED_MS = 5, TIME_SCALE_SLOT = 6, FRAME_TICK_SLOT = 7, FRAME_NOW_MS_SLOT = 8, SLOT_TICK = (7), SLOT_COUNT = 9, NO_FRAME_YET = -1, MAX_WHOLE_STEPS = 2147483647, FrameTime = class {
+  constructor() {
+    this.values = new Float64Array((9));
+  }
+  get stepSeconds() {
+    return this.values[(0)];
+  }
+  get frameSeconds() {
+    return this.values[(1)];
+  }
+  get alpha() {
+    return this.values[(2)];
+  }
+  get tick() {
+    return this.values[SLOT_TICK];
+  }
+}, FixedStepLoop = class {
+  constructor(options = {}) {
+    this.time = new FrameTime();
+    this.views = [this.time.values.subarray(SLOT_TICK, SLOT_TICK + 1)];
+    let hz = options.fixedHz ?? 60;
+    if (!(hz > 0)) throw new GameError("invalid_argument", "fixedHz must be positive");
+    this.stepMs = 1e3 / hz, this.maxSubsteps = options.maxSubsteps ?? 5, this.maxFrameDeltaMs = options.maxFrameDeltaMs ?? 250;
+    let v = this.time.values;
+    v[(0)] = 1 / hz, v[(6)] = 1, v[(4)] = (-1);
+  }
+  rollbackViews() {
+    return this.views;
+  }
+  get stepSeconds() {
+    return this.time.values[(0)];
+  }
+  get alpha() {
+    return this.time.values[(2)];
+  }
+  get tick() {
+    return this.time.values[SLOT_TICK];
+  }
+  get frameDeltaSeconds() {
+    return this.time.values[(1)];
+  }
+  get droppedTimeMs() {
+    return this.time.values[(5)];
+  }
+  get timeScale() {
+    return this.time.values[(6)];
+  }
+  set timeScale(scale) {
+    this.time.values[(6)] = scale;
+  }
+  begin(nowMs) {
+    return this.time.values[(8)] = nowMs, this.beginAtClock();
+  }
+  beginAtClock() {
+    let v = this.time.values, last = v[(4)], delta = v[(8)] - last;
+    v[(4)] = v[(8)], (last < 0 || delta < 0) && (delta = 0), delta > this.maxFrameDeltaMs && (v[(5)] += delta - this.maxFrameDeltaMs, delta = this.maxFrameDeltaMs), delta *= v[(6)], v[(1)] = delta / 1e3;
+    let accumulator = v[(3)] + delta, whole = accumulator / this.stepMs, steps = whole < (2147483647) ? whole | 0 : (2147483647);
+    if (steps > this.maxSubsteps) {
+      let dropped = (steps - this.maxSubsteps) * this.stepMs;
+      v[(5)] += dropped, accumulator -= dropped, steps = this.maxSubsteps;
+    }
+    return accumulator -= steps * this.stepMs, v[(3)] = accumulator, v[(2)] = accumulator / this.stepMs, steps;
+  }
+  /** Keeps the clock at this frame without stepping, so a held game resumes without catching up the time it was held. */
+  hold() {
+    let v = this.time.values;
+    v[(4)] = v[(8)], v[(3)] = 0, v[(1)] = 0;
+  }
+  completeStep() {
+    this.time.values[SLOT_TICK]++;
+  }
+  settle(steps) {
+    let v = this.time.values;
+    v[(2)] = 1, v[(1)] = steps * v[(0)];
+  }
+  reset() {
+    let v = this.time.values;
+    v[(3)] = 0, v[(4)] = (-1), v[(2)] = 0, v[SLOT_TICK] = 0, v[(5)] = 0;
+  }
+};
+
+export { FRAME_ALPHA_SLOT, FRAME_NOW_MS_SLOT, FRAME_SECONDS_SLOT, FRAME_STEP_SECONDS_SLOT, FRAME_TICK_SLOT, FixedStepLoop, FrameTime, TIME_SCALE_SLOT };

package/dist/chunk-IIDZ5WUX.js

@@ -0,0 +1,61 @@
+'use strict';
+
+var chunk2V7IL4HC_js = require('./chunk-2V7IL4HC.js');
+
+// src/game/render/types.ts
+function createPickHit() {
+  return {
+    node: 0,
+    instance: 0,
+    triangle: 0,
+    distance: 0,
+    point: new Float32Array(3),
+    barycentric: new Float32Array(2),
+    uv: new Float32Array(2)
+  };
+}
+var UNTINTED = { tintable: false, mask: void 0 };
+function materialTint(desc) {
+  if (!("tintable" in desc || "tintMask" in desc)) return UNTINTED;
+  let mask = desc.tintMask;
+  if (mask === void 0 && desc.tintable !== true) return UNTINTED;
+  if (mask !== void 0 && desc.kind === "physical" && ((desc.transmission ?? 0) > 0 || desc.transmissionMap !== void 0))
+    throw new chunk2V7IL4HC_js.GameError("invalid_argument", "a tint mask shares the transmission texture slot; drop transmission or the tint mask");
+  return { tintable: true, mask };
+}
+var SH_COEFFICIENT_FLOATS = 27, GPU_PASS_NAMES = [
+  "cull",
+  "particles",
+  "shadow",
+  "main",
+  "overlay",
+  "post",
+  "targets",
+  "gi",
+  "rt",
+  "volumetrics"
+];
+function createGpuStats() {
+  return {
+    gpuLastNs: 0,
+    gpuP50Ns: 0,
+    gpuP95Ns: 0,
+    gpuBytes: 0,
+    thermalTier: 0,
+    particlesAlive: 0,
+    rawDispatches: 0,
+    rawGpuNs: 0,
+    rawDisabled: 0,
+    transparentSorted: 0,
+    textGlyphs: 0,
+    drawCalls: 0,
+    triangles: 0,
+    passNs: new Float64Array(GPU_PASS_NAMES.length)
+  };
+}
+
+exports.GPU_PASS_NAMES = GPU_PASS_NAMES;
+exports.SH_COEFFICIENT_FLOATS = (27);
+exports.createGpuStats = createGpuStats;
+exports.createPickHit = createPickHit;
+exports.materialTint = materialTint;