@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-Y3XWP5XW.mjs

@@ -0,0 +1,298 @@
+// src/interactives/engines/config.ts
+var GODOT_RUNTIME_PREFIX = "@cimplify/godot/", GODOT_CONTEXT = {
+  alpha: false,
+  depth: true,
+  stencil: false,
+  antialias: false,
+  premultipliedAlpha: true,
+  preserveDrawingBuffer: false,
+  powerPreference: "default",
+  failIfMajorPerformanceCaveat: false
+}, GODOT_SURFACE = { api: "webgl2", transparent: false, pixel_ratio_cap: 3, offscreen: false }, GLUE_EXPORT = "__cimplify_engine", ENGINE_CANVAS_ID = "canvas", ENGINE_ATTRIBUTE = "data-cimplify-engine", ENGINE_FRAME_ATTRIBUTE = "data-cimplify-frame";
+function markEngineCanvas(canvas) {
+  canvas.id = ENGINE_CANVAS_ID, canvas.setAttribute(ENGINE_ATTRIBUTE, "");
+}
+function markFirstEngineFrame(canvas) {
+  canvas.hasAttribute(ENGINE_FRAME_ATTRIBUTE) || canvas.setAttribute(ENGINE_FRAME_ATTRIBUTE, "");
+}
+function variantFor(variants, isolated2) {
+  return isolated2 && variants.isolated !== null ? variants.isolated : variants.single;
+}
+
+// src/interactives/engines/glue.ts
+var SCRIPT_TYPE = "text/javascript";
+function loadGlue(document, source, exportName) {
+  let script = new Blob([source], { type: SCRIPT_TYPE }), url = URL.createObjectURL(script), scope = globalThis;
+  return new Promise((resolve, reject) => {
+    let element = document.createElement("script");
+    element.src = url, element.onload = () => {
+      let factory = scope[exportName];
+      Reflect.deleteProperty(scope, exportName), element.remove(), URL.revokeObjectURL(url), typeof factory != "function" ? reject(new Error(`the engine glue did not define ${exportName}`)) : resolve({ factory, script });
+    }, element.onerror = () => {
+      element.remove(), URL.revokeObjectURL(url), reject(new Error("the engine glue did not load"));
+    }, document.head.appendChild(element);
+  });
+}
+
+// src/interactives/engines/memory.ts
+var decoder = new TextDecoder(), MemoryView = class {
+  constructor(memory) {
+    this.memory = memory;
+    this.view = new Uint8Array(memory.buffer), this.shared = typeof SharedArrayBuffer == "function" && memory.buffer instanceof SharedArrayBuffer;
+  }
+  bytes() {
+    let buffer = this.memory.buffer;
+    return this.view.buffer !== buffer && (this.view = new Uint8Array(buffer)), this.view;
+  }
+  text(pointer, length) {
+    let bytes = this.bytes();
+    return decoder.decode(this.shared ? bytes.slice(pointer, pointer + length) : bytes.subarray(pointer, pointer + length));
+  }
+  int32(pointer) {
+    return new Int32Array(this.memory.buffer, pointer);
+  }
+};
+function memoryOf(...sources) {
+  for (let source of sources)
+    if (source !== void 0)
+      for (let value of Object.values(source)) {
+        if (value instanceof WebAssembly.Memory) return value;
+        if (typeof value == "object" && value !== null && !(value instanceof WebAssembly.Global) && !(value instanceof WebAssembly.Table)) {
+          for (let inner of Object.values(value)) if (inner instanceof WebAssembly.Memory) return inner;
+        }
+      }
+  return null;
+}
+
+// src/interactives/engines/parts.ts
+async function filled(assets, binary) {
+  let out = new Uint8Array(binary.bytes), at = 0;
+  for (let part of binary.parts) {
+    let bytes = await assets.take(part);
+    if (at + bytes.length > out.length) throw new Error("a binary is larger than its declared size");
+    out.set(bytes, at), at += bytes.length;
+  }
+  if (at !== out.length) throw new Error("a binary is smaller than its declared size");
+  return out;
+}
+function compileParts(assets, binary) {
+  let known = assets.module(binary.parts);
+  if (known !== null) return known;
+  let joined = binary.sha256 === void 0 ? null : assets.joined?.(binary.sha256, binary.parts) ?? null;
+  return joined === null ? compileBinary(assets, binary) : joined.catch(() => compileBinary(assets, binary));
+}
+function compileBinary(assets, binary) {
+  return joinParts(assets, binary).then((bytes) => WebAssembly.compile(bytes));
+}
+async function joinParts(assets, binary) {
+  return binary.parts.length === 1 ? assets.take(binary.parts[0]) : filled(assets, binary);
+}
+
+// src/interactives/engines/bridge.ts
+var CallStatus = { pending: 0, ready: 1, failed: 2, event: 3, unknown: -1 }, SHORT_BUFFER = -2, LogLevel = { warn: 1, error: 2 }, encoder = new TextEncoder(), WasmBridge = class {
+  constructor(host) {
+    this.host = host;
+    this.slots = /* @__PURE__ */ new Map();
+    this.memory = null;
+    this.presenter = null;
+    this.imports = {
+      request: (target, path, pathLength, args, argsLength) => {
+        let memory = this.view(), { id, slot } = this.open(false);
+        return this.host.dispatcher.call(target, memory.text(path, pathLength), memory.text(args, argsLength)).then((settlement) => this.settle(slot, settlement)), id;
+      },
+      listen: (target, path, pathLength, args, argsLength) => {
+        let memory = this.view(), { id, slot } = this.open(true), events = slot.events, settlement = this.host.dispatcher.listen(id, target, memory.text(path, pathLength), memory.text(args, argsLength), (json) => {
+          events.push(encoder.encode(json)), slot.status = CallStatus.event;
+        });
+        return settlement.ok || this.settle(slot, settlement), id;
+      },
+      pack: (name, nameLength) => {
+        let { id, slot } = this.open(false);
+        return this.host.pack(this.view().text(name, nameLength)).then(
+          (bytes) => {
+            slot.payload = bytes, slot.status = CallStatus.ready;
+          },
+          (error) => this.settle(slot, { ok: false, json: JSON.stringify({ code: "pack", message: error instanceof Error ? error.message : String(error) }) })
+        ), id;
+      },
+      status: (id) => this.slots.get(id)?.status ?? CallStatus.unknown,
+      size: (id) => {
+        let slot = this.slots.get(id);
+        return slot === void 0 ? CallStatus.unknown : (slot.events !== null && slot.payload === null ? slot.events[0] : slot.payload)?.length ?? 0;
+      },
+      take: (id, out, capacity) => {
+        let slot = this.slots.get(id);
+        if (slot === void 0) return CallStatus.unknown;
+        let fromEvents = slot.events !== null && slot.payload === null, next = fromEvents ? slot.events[0] : slot.payload;
+        if (next == null) return 0;
+        if (next.length > capacity) return (-2);
+        if (this.view().bytes().set(next, out), fromEvents) {
+          let events = slot.events;
+          events.shift(), events.length === 0 && (slot.status = CallStatus.pending);
+        } else slot.events === null ? this.slots.delete(id) : slot.payload = null;
+        return next.length;
+      },
+      release: (id) => {
+        this.slots.delete(id), this.host.dispatcher.release(id);
+      },
+      present: (rgba, width, height) => {
+        this.presenter?.present(this.view(), rgba, width, height);
+      },
+      log: (level, text, length) => {
+        this.host.log(level, this.view().text(text, length));
+      }
+    };
+  }
+  attach(memory, presenter) {
+    this.memory = memory, this.presenter = presenter;
+  }
+  view() {
+    let memory = this.memory;
+    if (memory === null) throw new Error("the game called ctx before its memory was attached");
+    return memory;
+  }
+  settle(slot, settlement) {
+    slot.payload = encoder.encode(settlement.json), slot.status = settlement.ok ? CallStatus.ready : CallStatus.failed;
+  }
+  open(events) {
+    let id = this.host.dispatcher.allocate(), slot = { status: CallStatus.pending, payload: null, events: events ? [] : null };
+    return this.slots.set(id, slot), { id, slot };
+  }
+  releaseAll() {
+    this.slots.clear(), this.host.dispatcher.releaseAll();
+  }
+};
+
+// src/interactives/engines/dispatch.ts
+var HANDLE_FIELD = "ctx_handle";
+var FORBIDDEN_SEGMENTS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor", "then"]), DispatchError = class extends Error {
+  constructor(message) {
+    super(message), this.name = "DispatchError";
+  }
+};
+function isObject(value) {
+  return typeof value == "object" && value !== null || typeof value == "function";
+}
+function hasMethods(value) {
+  if (typeof value != "object" || value === null || Array.isArray(value) || ArrayBuffer.isView(value)) return false;
+  for (let key in value) if (typeof value[key] == "function") return true;
+  let proto = Object.getPrototypeOf(value);
+  if (proto === Object.prototype || proto === null) return false;
+  for (let key of Object.getOwnPropertyNames(proto))
+    if (key !== "constructor" && typeof value[key] == "function") return true;
+  return false;
+}
+function describe(error) {
+  if (error instanceof Error) return JSON.stringify({ code: error.name, message: error.message });
+  try {
+    return JSON.stringify(error ?? null);
+  } catch {
+    return JSON.stringify({ code: "unserializable", message: String(error) });
+  }
+}
+function parseArgs(json) {
+  if (json.length === 0) return [];
+  let parsed = JSON.parse(json);
+  if (!Array.isArray(parsed)) throw new DispatchError("arguments are a JSON array");
+  return parsed;
+}
+var CtxDispatcher = class {
+  constructor(ctx) {
+    this.targets = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Map();
+    this.next = 1;
+    this.targets.set(0, ctx);
+  }
+  allocate() {
+    let id = this.next;
+    return this.next = this.next + 1 | 0 || 1, id;
+  }
+  resolve(target, path) {
+    let owner = this.targets.get(target);
+    if (owner === void 0) throw new DispatchError(`handle ${target} is not open`);
+    let segments = path.split(".");
+    for (let i = 0; i < segments.length; i++) {
+      let segment = segments[i];
+      if (segment.length === 0 || segment.startsWith("_") || FORBIDDEN_SEGMENTS.has(segment) || !(segment in owner))
+        throw new DispatchError(`ctx has no ${path}`);
+      let value = owner[segment];
+      if (value === Object.prototype[segment]) throw new DispatchError(`ctx has no ${path}`);
+      if (i === segments.length - 1) {
+        if (typeof value != "function") throw new DispatchError(`${path} is not callable`);
+        return { owner, method: value };
+      }
+      if (!isObject(value)) throw new DispatchError(`ctx has no ${path}`);
+      owner = value;
+    }
+    throw new DispatchError(`ctx has no ${path}`);
+  }
+  encode(value) {
+    if (!hasMethods(value)) return JSON.stringify(value ?? null);
+    let handle = this.allocate();
+    this.targets.set(handle, value);
+    let data = {};
+    for (let key of Object.keys(value)) {
+      let field = value[key];
+      typeof field != "function" && (data[key] = field);
+    }
+    return data[HANDLE_FIELD] = handle, JSON.stringify(data);
+  }
+  async call(target, path, argsJson) {
+    try {
+      let { owner, method } = this.resolve(target, path), result = await method.apply(owner, parseArgs(argsJson));
+      return { ok: !0, json: this.encode(result) };
+    } catch (error) {
+      return { ok: false, json: describe(error) };
+    }
+  }
+  listen(id, target, path, argsJson, sink) {
+    try {
+      let { owner, method } = this.resolve(target, path), stop = method.apply(owner, [...parseArgs(argsJson), (event) => sink(JSON.stringify(event ?? null))]);
+      return typeof stop == "function" && this.listeners.set(id, stop), { ok: !0, json: JSON.stringify({ listen: id }) };
+    } catch (error) {
+      return { ok: false, json: describe(error) };
+    }
+  }
+  release(id) {
+    if (id === 0) return;
+    this.targets.delete(id);
+    let stop = this.listeners.get(id);
+    stop !== void 0 && (this.listeners.delete(id), stop());
+  }
+  releaseAll() {
+    for (let stop of this.listeners.values()) stop();
+    this.listeners.clear();
+    for (let id of this.targets.keys()) id !== 0 && this.targets.delete(id);
+  }
+};
+
+// src/interactives/engines/session.ts
+function engineHost(ctx, packs) {
+  let taken = /* @__PURE__ */ new Map();
+  return {
+    dispatcher: new CtxDispatcher(ctx),
+    pack(name) {
+      let binary = Object.prototype.hasOwnProperty.call(packs, name) ? packs[name] : void 0;
+      if (binary === void 0) return Promise.reject(new Error(`the package has no pack named ${name}`));
+      let pending = taken.get(name);
+      return pending === void 0 && (pending = joinParts(ctx.assets, binary), taken.set(name, pending)), pending;
+    },
+    log(level, text) {
+      level === LogLevel.error ? console.error(text) : level === LogLevel.warn ? console.warn(text) : console.debug(text);
+    }
+  };
+}
+function isolated() {
+  return globalThis.crossOriginIsolated === true;
+}
+function backingSize(surface, canvas, width, height) {
+  canvas.width = Math.max(1, Math.round(width * surface.pixel_ratio)), canvas.height = Math.max(1, Math.round(height * surface.pixel_ratio));
+}
+function bindLifecycle(ctx, running, dispose) {
+  let pause = () => running.stop(), resume = () => running.start();
+  ctx.lifecycle.on("hidden", pause), ctx.lifecycle.on("suspend", pause), ctx.lifecycle.on("visible", resume), ctx.lifecycle.on("resume", resume), ctx.on_dispose(() => {
+    running.stop(), dispose();
+  });
+}
+
+export { GLUE_EXPORT, GODOT_CONTEXT, GODOT_RUNTIME_PREFIX, GODOT_SURFACE, MemoryView, WasmBridge, backingSize, bindLifecycle, compileParts, engineHost, isolated, joinParts, loadGlue, markEngineCanvas, markFirstEngineFrame, memoryOf, variantFor };

package/dist/chunk-Y4K22JL6.js

@@ -0,0 +1,228 @@
+'use strict';
+
+var chunk2V7IL4HC_js = require('./chunk-2V7IL4HC.js');
+
+// src/game/render/primitives.ts
+var UINT16_INDEX_LIMIT = 65536, BOX_FACES = 6, QUAD_VERTICES = 4, QUAD_INDICES = 6, TRIANGLE_INDICES = 3, FACE_AXES = new Int8Array([
+  2,
+  1,
+  0,
+  -1,
+  -1,
+  1,
+  1,
+  0,
+  0,
+  2,
+  1,
+  0,
+  1,
+  -1,
+  -1,
+  -1,
+  0,
+  0,
+  0,
+  2,
+  1,
+  1,
+  1,
+  1,
+  0,
+  1,
+  0,
+  0,
+  2,
+  1,
+  1,
+  -1,
+  -1,
+  0,
+  -1,
+  0,
+  0,
+  1,
+  2,
+  1,
+  -1,
+  1,
+  0,
+  0,
+  1,
+  0,
+  1,
+  2,
+  -1,
+  -1,
+  -1,
+  0,
+  0,
+  -1
+]), FACE_STRIDE = 9;
+function allocatePrimitive(size) {
+  return {
+    positions: new Float32Array(size.vertices * 3),
+    normals: new Float32Array(size.vertices * 3),
+    uvs: new Float32Array(size.vertices * 2),
+    indices: size.vertices > (65536) ? new Uint32Array(size.indices) : new Uint16Array(size.indices)
+  };
+}
+function primitiveDesc(buffers) {
+  return {
+    attributes: {
+      position: { data: buffers.positions, itemSize: 3 },
+      normal: { data: buffers.normals, itemSize: 3 },
+      uv: { data: buffers.uvs, itemSize: 2 }
+    },
+    index: buffers.indices
+  };
+}
+var PrimitiveWriter = class {
+  constructor() {
+    this.buffers = null;
+    this.vertex = 0;
+    this.index = 0;
+  }
+  begin(buffers, vertices, indices) {
+    if (buffers.positions.length < vertices * 3 || buffers.normals.length < vertices * 3 || buffers.uvs.length < vertices * 2 || buffers.indices.length < indices)
+      throw new chunk2V7IL4HC_js.GameError("invalid_argument", "primitive buffers are smaller than the primitive");
+    this.buffers = buffers, this.vertex = 0, this.index = 0;
+  }
+  get vertexCount() {
+    return this.vertex;
+  }
+  push(px, py, pz, nx, ny, nz, u, v) {
+    let b = this.buffers, o = this.vertex * 3;
+    b.positions[o] = px, b.positions[o + 1] = py, b.positions[o + 2] = pz, b.normals[o] = nx, b.normals[o + 1] = ny, b.normals[o + 2] = nz;
+    let t = this.vertex * 2;
+    b.uvs[t] = u, b.uvs[t + 1] = v, this.vertex++;
+  }
+  triangle(a, b, c) {
+    let indices = this.buffers.indices;
+    indices[this.index++] = a, indices[this.index++] = b, indices[this.index++] = c;
+  }
+  end() {
+    this.buffers = null;
+  }
+}, writer = new PrimitiveWriter();
+function boxSize() {
+  return { vertices: (6) * (4), indices: (6) * (6) };
+}
+function writeBox(out, width, height, depth) {
+  writer.begin(out, (6) * (4), (6) * (6));
+  let hx = width / 2, hy = height / 2, hz = depth / 2;
+  for (let f = 0; f < (6); f++) {
+    let o = f * (9), u = FACE_AXES[o], v = FACE_AXES[o + 1], base = writer.vertexCount;
+    for (let iy = 0; iy < 2; iy++)
+      for (let ix = 0; ix < 2; ix++) {
+        let cu = (ix * 2 - 1) * FACE_AXES[o + 3], cv = (iy * 2 - 1) * FACE_AXES[o + 4], cw = FACE_AXES[o + 5], x = (u === 0 ? cu : v === 0 ? cv : cw) * hx, y = (u === 1 ? cu : v === 1 ? cv : cw) * hy, z = (u === 2 ? cu : v === 2 ? cv : cw) * hz;
+        writer.push(x, y, z, FACE_AXES[o + 6], FACE_AXES[o + 7], FACE_AXES[o + 8], ix, 1 - iy);
+      }
+    writer.triangle(base, base + 2, base + 1), writer.triangle(base + 2, base + 3, base + 1);
+  }
+  writer.end();
+}
+function planeSize() {
+  return { vertices: (4), indices: (6) };
+}
+function writePlane(out, width, height) {
+  writer.begin(out, (4), (6));
+  let hw = width / 2, hh = height / 2;
+  writer.push(-hw, hh, 0, 0, 0, 1, 0, 1), writer.push(hw, hh, 0, 0, 0, 1, 1, 1), writer.push(-hw, -hh, 0, 0, 0, 1, 0, 0), writer.push(hw, -hh, 0, 0, 0, 1, 1, 0), writer.triangle(0, 2, 1), writer.triangle(2, 3, 1), writer.end();
+}
+function sphereSize(widthSegments, heightSegments) {
+  return {
+    vertices: (widthSegments + 1) * (heightSegments + 1),
+    indices: widthSegments * (heightSegments - 1) * (6)
+  };
+}
+function writeSphere(out, radius, widthSegments, heightSegments) {
+  writer.begin(
+    out,
+    (widthSegments + 1) * (heightSegments + 1),
+    widthSegments * (heightSegments - 1) * (6)
+  );
+  for (let y = 0; y <= heightSegments; y++) {
+    let v = y / heightSegments, theta = v * Math.PI, sinTheta = Math.sin(theta), cosTheta = Math.cos(theta);
+    for (let x = 0; x <= widthSegments; x++) {
+      let u = x / widthSegments, phi = u * Math.PI * 2, nx = -Math.cos(phi) * sinTheta, nz = Math.sin(phi) * sinTheta;
+      writer.push(nx * radius, cosTheta * radius, nz * radius, nx, cosTheta, nz, u, 1 - v);
+    }
+  }
+  let row = widthSegments + 1;
+  for (let y = 0; y < heightSegments; y++)
+    for (let x = 0; x < widthSegments; x++) {
+      let a = y * row + x + 1, b = y * row + x, c = (y + 1) * row + x, d = (y + 1) * row + x + 1;
+      y !== 0 && writer.triangle(a, b, d), y !== heightSegments - 1 && writer.triangle(b, c, d);
+    }
+  writer.end();
+}
+function cylinderSize(radialSegments) {
+  let side = (radialSegments + 1) * 2, cap = radialSegments + 2;
+  return {
+    vertices: side + cap * 2,
+    indices: radialSegments * (6) + radialSegments * (3) * 2
+  };
+}
+function writeCylinder(out, radiusTop, radiusBottom, height, radialSegments) {
+  writer.begin(
+    out,
+    (radialSegments + 1) * 2 + (radialSegments + 2) * 2,
+    radialSegments * (6) + radialSegments * (3) * 2
+  );
+  let half = height / 2, slope = (radiusBottom - radiusTop) / height;
+  for (let y = 0; y <= 1; y++) {
+    let radius = y === 0 ? radiusTop : radiusBottom;
+    for (let x = 0; x <= radialSegments; x++) {
+      let u = x / radialSegments, theta = u * Math.PI * 2, sin = Math.sin(theta), cos = Math.cos(theta), len = Math.hypot(sin, slope, cos);
+      writer.push(radius * sin, y === 0 ? half : -half, radius * cos, sin / len, slope / len, cos / len, u, 1 - y);
+    }
+  }
+  let row = radialSegments + 1;
+  for (let x = 0; x < radialSegments; x++)
+    writer.triangle(x, x + row, x + 1), writer.triangle(x + row, x + row + 1, x + 1);
+  for (let cap = 0; cap < 2; cap++) {
+    let top = cap === 0, radius = top ? radiusTop : radiusBottom, y = top ? half : -half, ny = top ? 1 : -1, center = writer.vertexCount;
+    writer.push(0, y, 0, 0, ny, 0, 0.5, 0.5);
+    for (let x = 0; x <= radialSegments; x++) {
+      let theta = x / radialSegments * Math.PI * 2, sin = Math.sin(theta), cos = Math.cos(theta);
+      writer.push(radius * sin, y, radius * cos, 0, ny, 0, sin * 0.5 + 0.5, cos * 0.5 + 0.5);
+    }
+    for (let x = 0; x < radialSegments; x++) {
+      let a = center + 1 + x;
+      top ? writer.triangle(a, a + 1, center) : writer.triangle(a + 1, a, center);
+    }
+  }
+  writer.end();
+}
+function boxGeometry(width = 1, height = 1, depth = 1) {
+  let buffers = allocatePrimitive(boxSize());
+  return writeBox(buffers, width, height, depth), primitiveDesc(buffers);
+}
+function planeGeometry(width = 1, height = 1) {
+  let buffers = allocatePrimitive(planeSize());
+  return writePlane(buffers, width, height), primitiveDesc(buffers);
+}
+function sphereGeometry(radius = 0.5, widthSegments = 24, heightSegments = Math.max(2, Math.floor(24 / 2))) {
+  let buffers = allocatePrimitive(sphereSize(widthSegments, heightSegments));
+  return writeSphere(buffers, radius, widthSegments, heightSegments), primitiveDesc(buffers);
+}
+function cylinderGeometry(radiusTop = 0.5, radiusBottom = 0.5, height = 1, radialSegments = 24) {
+  let buffers = allocatePrimitive(cylinderSize(radialSegments));
+  return writeCylinder(buffers, radiusTop, radiusBottom, height, radialSegments), primitiveDesc(buffers);
+}
+
+exports.allocatePrimitive = allocatePrimitive;
+exports.boxGeometry = boxGeometry;
+exports.boxSize = boxSize;
+exports.cylinderGeometry = cylinderGeometry;
+exports.cylinderSize = cylinderSize;
+exports.planeGeometry = planeGeometry;
+exports.planeSize = planeSize;
+exports.primitiveDesc = primitiveDesc;
+exports.sphereGeometry = sphereGeometry;
+exports.sphereSize = sphereSize;
+exports.writeBox = writeBox;
+exports.writeCylinder = writeCylinder;
+exports.writePlane = writePlane;
+exports.writeSphere = writeSphere;