@cimplify/sdk 0.108.0 → 0.110.2

package/dist/worlds-Br2Pb0Cs.d.ts

@@ -0,0 +1,109 @@
+import { C as Ctx, B as CtxRequest } from './local-VZkqsCzR.js';
+import { F as WorldMirror, h as LocalWorld, y as WorldBuilder, B as WorldConnection } from './online-XeymeM9s.js';
+import { G as Game, aS as UiActionId } from './game-fgQy2YIm.js';
+import { G as GameScene } from './fluid-ARr0qUIL.js';
+import { bs as ThirdPersonRig } from './play-BRRlfLhX.js';
+import { h as GenreTemplate } from './template-BkEGVTQj.js';
+
+declare const WORLDS: {
+    readonly plazaHalf: 40;
+    readonly reach: 2.5;
+    readonly nudgeMm: 1000;
+    readonly duplicateOffsetMm: 1500;
+    readonly scaleUpPermille: 1250;
+    readonly scaleDownPermille: 800;
+    readonly selectRadius: 3;
+    readonly maxObjects: 400;
+    readonly palette: readonly [{
+        readonly item: "cimplify/crate";
+        readonly halfExtentsMm: readonly [500, 500, 500];
+        readonly color: 9268835;
+    }, {
+        readonly item: "cimplify/table";
+        readonly halfExtentsMm: readonly [750, 375, 450];
+        readonly color: 12946250;
+    }, {
+        readonly item: "cimplify/block";
+        readonly halfExtentsMm: readonly [1000, 250, 1000];
+        readonly color: 9479342;
+    }, {
+        readonly item: "cimplify/pillar";
+        readonly halfExtentsMm: readonly [250, 1250, 250];
+        readonly color: 14737632;
+    }];
+};
+declare const WORLD_ACTIONS: {
+    readonly build: "world.build";
+    readonly item: "world.item";
+    readonly place: "world.place";
+    readonly selectNear: "world.select_near";
+    readonly selectAdd: "world.select_add";
+    readonly clear: "world.clear";
+    readonly move: "world.move";
+    readonly rotate: "world.rotate";
+    readonly scaleUp: "world.scale_up";
+    readonly scaleDown: "world.scale_down";
+    readonly duplicate: "world.duplicate";
+    readonly remove: "world.delete";
+    readonly undo: "world.undo";
+    readonly redo: "world.redo";
+    readonly grid: "world.grid";
+    readonly surface: "world.surface";
+};
+interface BuildersPlazaOptions {
+    readonly connection?: WorldConnection | null;
+}
+declare class BuildersPlaza implements GameScene<Game> {
+    readonly name = "worlds";
+    rig: ThirdPersonRig | null;
+    readonly mirror: WorldMirror;
+    readonly local: LocalWorld | null;
+    readonly builder: WorldBuilder;
+    readonly connection: WorldConnection | null;
+    buildMode: boolean;
+    snap: number;
+    item: number;
+    built: number;
+    rejected: number;
+    private lastSeenResult;
+    private readonly placeOps;
+    private placeHead;
+    private boxes;
+    private readonly actions;
+    private readonly transform;
+    private readonly rotation;
+    private readonly nearest;
+    private readonly pose;
+    private objectsSlot;
+    private modeSlot;
+    private started;
+    private lastX;
+    private lastZ;
+    constructor(options?: BuildersPlazaOptions);
+    enter(game: Game): void;
+    fixedUpdate(game: Game): void;
+    update(game: Game): void;
+    exit(): void;
+    actionId(index: number): UiActionId;
+    private observeResults;
+    private target;
+    private nearestObject;
+    private handle;
+    private sync;
+    private draw;
+}
+declare const worldsTemplate: GenreTemplate<BuildersPlaza>;
+declare function joinBuildersPlaza(ctx: Ctx, request: CtxRequest<"world.join">): Promise<BuildersPlaza>;
+
+type worlds_BuildersPlaza = BuildersPlaza;
+declare const worlds_BuildersPlaza: typeof BuildersPlaza;
+type worlds_BuildersPlazaOptions = BuildersPlazaOptions;
+declare const worlds_WORLDS: typeof WORLDS;
+declare const worlds_WORLD_ACTIONS: typeof WORLD_ACTIONS;
+declare const worlds_joinBuildersPlaza: typeof joinBuildersPlaza;
+declare const worlds_worldsTemplate: typeof worldsTemplate;
+declare namespace worlds {
+  export { worlds_BuildersPlaza as BuildersPlaza, type worlds_BuildersPlazaOptions as BuildersPlazaOptions, worlds_WORLDS as WORLDS, worlds_WORLD_ACTIONS as WORLD_ACTIONS, worlds_joinBuildersPlaza as joinBuildersPlaza, worlds_worldsTemplate as worldsTemplate };
+}
+
+export { BuildersPlaza as B, WORLDS as W, type BuildersPlazaOptions as a, WORLD_ACTIONS as b, worldsTemplate as c, joinBuildersPlaza as j, worlds as w };

package/dist/worlds-D5ydYr7d.d.mts

@@ -0,0 +1,109 @@
+import { C as Ctx, B as CtxRequest } from './local-D8_I6UeL.mjs';
+import { F as WorldMirror, h as LocalWorld, y as WorldBuilder, B as WorldConnection } from './online-d7W_Al9a.mjs';
+import { G as Game, aS as UiActionId } from './game-Bx8onkhX.mjs';
+import { G as GameScene } from './fluid-DLlEj2cs.mjs';
+import { bs as ThirdPersonRig } from './play-ClrMd_e8.mjs';
+import { h as GenreTemplate } from './template-AhCdB1kW.mjs';
+
+declare const WORLDS: {
+    readonly plazaHalf: 40;
+    readonly reach: 2.5;
+    readonly nudgeMm: 1000;
+    readonly duplicateOffsetMm: 1500;
+    readonly scaleUpPermille: 1250;
+    readonly scaleDownPermille: 800;
+    readonly selectRadius: 3;
+    readonly maxObjects: 400;
+    readonly palette: readonly [{
+        readonly item: "cimplify/crate";
+        readonly halfExtentsMm: readonly [500, 500, 500];
+        readonly color: 9268835;
+    }, {
+        readonly item: "cimplify/table";
+        readonly halfExtentsMm: readonly [750, 375, 450];
+        readonly color: 12946250;
+    }, {
+        readonly item: "cimplify/block";
+        readonly halfExtentsMm: readonly [1000, 250, 1000];
+        readonly color: 9479342;
+    }, {
+        readonly item: "cimplify/pillar";
+        readonly halfExtentsMm: readonly [250, 1250, 250];
+        readonly color: 14737632;
+    }];
+};
+declare const WORLD_ACTIONS: {
+    readonly build: "world.build";
+    readonly item: "world.item";
+    readonly place: "world.place";
+    readonly selectNear: "world.select_near";
+    readonly selectAdd: "world.select_add";
+    readonly clear: "world.clear";
+    readonly move: "world.move";
+    readonly rotate: "world.rotate";
+    readonly scaleUp: "world.scale_up";
+    readonly scaleDown: "world.scale_down";
+    readonly duplicate: "world.duplicate";
+    readonly remove: "world.delete";
+    readonly undo: "world.undo";
+    readonly redo: "world.redo";
+    readonly grid: "world.grid";
+    readonly surface: "world.surface";
+};
+interface BuildersPlazaOptions {
+    readonly connection?: WorldConnection | null;
+}
+declare class BuildersPlaza implements GameScene<Game> {
+    readonly name = "worlds";
+    rig: ThirdPersonRig | null;
+    readonly mirror: WorldMirror;
+    readonly local: LocalWorld | null;
+    readonly builder: WorldBuilder;
+    readonly connection: WorldConnection | null;
+    buildMode: boolean;
+    snap: number;
+    item: number;
+    built: number;
+    rejected: number;
+    private lastSeenResult;
+    private readonly placeOps;
+    private placeHead;
+    private boxes;
+    private readonly actions;
+    private readonly transform;
+    private readonly rotation;
+    private readonly nearest;
+    private readonly pose;
+    private objectsSlot;
+    private modeSlot;
+    private started;
+    private lastX;
+    private lastZ;
+    constructor(options?: BuildersPlazaOptions);
+    enter(game: Game): void;
+    fixedUpdate(game: Game): void;
+    update(game: Game): void;
+    exit(): void;
+    actionId(index: number): UiActionId;
+    private observeResults;
+    private target;
+    private nearestObject;
+    private handle;
+    private sync;
+    private draw;
+}
+declare const worldsTemplate: GenreTemplate<BuildersPlaza>;
+declare function joinBuildersPlaza(ctx: Ctx, request: CtxRequest<"world.join">): Promise<BuildersPlaza>;
+
+type worlds_BuildersPlaza = BuildersPlaza;
+declare const worlds_BuildersPlaza: typeof BuildersPlaza;
+type worlds_BuildersPlazaOptions = BuildersPlazaOptions;
+declare const worlds_WORLDS: typeof WORLDS;
+declare const worlds_WORLD_ACTIONS: typeof WORLD_ACTIONS;
+declare const worlds_joinBuildersPlaza: typeof joinBuildersPlaza;
+declare const worlds_worldsTemplate: typeof worldsTemplate;
+declare namespace worlds {
+  export { worlds_BuildersPlaza as BuildersPlaza, type worlds_BuildersPlazaOptions as BuildersPlazaOptions, worlds_WORLDS as WORLDS, worlds_WORLD_ACTIONS as WORLD_ACTIONS, worlds_joinBuildersPlaza as joinBuildersPlaza, worlds_worldsTemplate as worldsTemplate };
+}
+
+export { BuildersPlaza as B, WORLDS as W, type BuildersPlazaOptions as a, WORLD_ACTIONS as b, worldsTemplate as c, joinBuildersPlaza as j, worlds as w };

package/engines/c/cimplify.h

@@ -0,0 +1,108 @@
+#ifndef CIMPLIFY_H
+#define CIMPLIFY_H
+
+#include <stdint.h>
+
+#define CIMPLIFY_ABI 1
+
+#ifdef __EMSCRIPTEN__
+#define CIMPLIFY_IMPORT(name)
+#else
+#define CIMPLIFY_IMPORT(name) __attribute__((import_module("cimplify"), import_name(#name)))
+#endif
+#define CIMPLIFY_EXPORT(name) __attribute__((used, visibility("default"), export_name(#name)))
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+  CIMPLIFY_CTX = 0,
+  CIMPLIFY_PENDING = 0,
+  CIMPLIFY_OK = 1,
+  CIMPLIFY_ERROR = 2,
+  CIMPLIFY_EVENT = 3,
+  CIMPLIFY_UNKNOWN = -1,
+  CIMPLIFY_SHORT = -2,
+  CIMPLIFY_LOG_DEBUG = 0,
+  CIMPLIFY_LOG_WARN = 1,
+  CIMPLIFY_LOG_ERROR = 2,
+  CIMPLIFY_VISIBLE = 1,
+  CIMPLIFY_HIDDEN = 2,
+  CIMPLIFY_SUSPEND = 3,
+  CIMPLIFY_RESUME = 4,
+  CIMPLIFY_DISPOSE = 6,
+  CIMPLIFY_KEY_WORDS = 8
+};
+
+typedef struct cimplify_input {
+  int32_t width;
+  int32_t height;
+  int32_t pointer_x;
+  int32_t pointer_y;
+  int32_t pointer_down;
+  int32_t pointer_presses;
+  int32_t pointer_releases;
+  int32_t reserved;
+  uint32_t keys_down[CIMPLIFY_KEY_WORDS];
+  uint32_t keys_pressed[CIMPLIFY_KEY_WORDS];
+} cimplify_input;
+
+CIMPLIFY_IMPORT(request) int32_t cimplify_request(int32_t target, const char *path, int32_t path_length, const char *args, int32_t args_length);
+CIMPLIFY_IMPORT(listen) int32_t cimplify_listen(int32_t target, const char *path, int32_t path_length, const char *args, int32_t args_length);
+CIMPLIFY_IMPORT(pack) int32_t cimplify_pack(const char *name, int32_t name_length);
+CIMPLIFY_IMPORT(status) int32_t cimplify_status(int32_t id);
+CIMPLIFY_IMPORT(size) int32_t cimplify_size(int32_t id);
+CIMPLIFY_IMPORT(take) int32_t cimplify_take(int32_t id, void *out, int32_t capacity);
+CIMPLIFY_IMPORT(release) void cimplify_release(int32_t id);
+CIMPLIFY_IMPORT(present) void cimplify_present(const void *rgba, int32_t width, int32_t height);
+CIMPLIFY_IMPORT(log) void cimplify_log(int32_t level, const char *text, int32_t length);
+
+const cimplify_input *cimplify_input_state(void);
+
+static inline int32_t cimplify_key_down(const cimplify_input *input, uint32_t key_code) {
+  return (int32_t)((input->keys_down[(key_code & 255u) >> 5] >> (key_code & 31u)) & 1u);
+}
+
+static inline int32_t cimplify_key_pressed(const cimplify_input *input, uint32_t key_code) {
+  return (int32_t)((input->keys_pressed[(key_code & 255u) >> 5] >> (key_code & 31u)) & 1u);
+}
+
+static inline int32_t cimplify_length(const char *text) {
+  int32_t length = 0;
+  while (text[length] != 0) length++;
+  return length;
+}
+
+static inline int32_t cimplify_call(const char *path, const char *args_json) {
+  return cimplify_request(CIMPLIFY_CTX, path, cimplify_length(path), args_json, cimplify_length(args_json));
+}
+
+CIMPLIFY_EXPORT(cimplify_start) void cimplify_start(void);
+CIMPLIFY_EXPORT(cimplify_frame) void cimplify_frame(int32_t delta_micros);
+CIMPLIFY_EXPORT(cimplify_abi_version) int32_t cimplify_abi_version(void);
+CIMPLIFY_EXPORT(cimplify_input_block) cimplify_input *cimplify_input_block(void);
+
+#ifdef CIMPLIFY_IMPLEMENTATION
+
+static cimplify_input cimplify_input_storage;
+
+int32_t cimplify_abi_version(void) {
+  return CIMPLIFY_ABI;
+}
+
+cimplify_input *cimplify_input_block(void) {
+  return &cimplify_input_storage;
+}
+
+const cimplify_input *cimplify_input_state(void) {
+  return &cimplify_input_storage;
+}
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/engines/c/cimplify.lib.js

@@ -0,0 +1,11 @@
+addToLibrary({
+  cimplify_request: (target, path, pathLength, args, argsLength) => Module.cimplify.request(target, path, pathLength, args, argsLength),
+  cimplify_listen: (target, path, pathLength, args, argsLength) => Module.cimplify.listen(target, path, pathLength, args, argsLength),
+  cimplify_pack: (name, nameLength) => Module.cimplify.pack(name, nameLength),
+  cimplify_status: (id) => Module.cimplify.status(id),
+  cimplify_size: (id) => Module.cimplify.size(id),
+  cimplify_take: (id, out, capacity) => Module.cimplify.take(id, out, capacity),
+  cimplify_release: (id) => Module.cimplify.release(id),
+  cimplify_present: (rgba, width, height) => Module.cimplify.present(rgba, width, height),
+  cimplify_log: (level, text, length) => Module.cimplify.log(level, text, length),
+});

package/engines/godot/addons/cimplify/cimplify.gd

@@ -0,0 +1,97 @@
+extends Node
+
+signal settled(id: int, status: int, payload: String)
+signal event(id: int, payload: String)
+signal lifecycle(state: String)
+
+const CTX := 0
+const OK := 1
+const FAILED := 2
+const EVENT := 3
+const INTERFACE := "cimplify"
+const LIFECYCLE_STATES: Array[String] = ["visible", "hidden", "suspend", "resume", "dispose"]
+const PAUSING_STATES: Array[String] = ["hidden", "suspend"]
+const RESUMING_STATES: Array[String] = ["visible", "resume"]
+
+var _bridge: JavaScriptObject
+var _callback: JavaScriptObject
+var _lifecycle_listens: Dictionary = {}
+
+
+func _ready() -> void:
+	process_mode = Node.PROCESS_MODE_ALWAYS
+	if not OS.has_feature("web"):
+		return
+	_bridge = JavaScriptBridge.get_interface(INTERFACE)
+	if _bridge == null:
+		return
+	_callback = JavaScriptBridge.create_callback(_on_settled)
+	for state in LIFECYCLE_STATES:
+		var id := int(_bridge.listen(CTX, "lifecycle.on", JSON.stringify([state]), _callback))
+		_lifecycle_listens[id] = state
+
+
+func available() -> bool:
+	return _bridge != null
+
+
+func call_ctx(path: String, args: Array = [], target: int = CTX) -> Dictionary:
+	if _bridge == null:
+		return {"ok": false, "error": {"code": "unavailable", "message": "ctx is reached only inside the Cimplify canvas host"}}
+	var id := int(_bridge.request(target, path, JSON.stringify(args), _callback))
+	while true:
+		var result: Array = await settled
+		if int(result[0]) != id:
+			continue
+		var value: Variant = JSON.parse_string(String(result[2]))
+		if int(result[1]) == OK:
+			return {"ok": true, "value": value}
+		return {"ok": false, "error": value}
+	return {}
+
+
+func listen(path: String, args: Array = [], target: int = CTX) -> int:
+	if _bridge == null:
+		return -1
+	return int(_bridge.listen(target, path, JSON.stringify(args), _callback))
+
+
+func release(id: int) -> void:
+	if _bridge != null:
+		_bridge.release(id)
+
+
+func load_pack(name: String) -> bool:
+	if _bridge == null:
+		return false
+	var id := int(_bridge.pack(name, _callback))
+	while true:
+		var result: Array = await settled
+		if int(result[0]) != id:
+			continue
+		if int(result[1]) != OK:
+			return false
+		return ProjectSettings.load_resource_pack(String(result[2]))
+	return false
+
+
+func _on_settled(args: Array) -> void:
+	var id := int(args[0])
+	var status := int(args[1])
+	var payload := String(args[2])
+	if _lifecycle_listens.has(id):
+		if status == EVENT:
+			_on_lifecycle(_lifecycle_listens[id])
+		return
+	if status == EVENT:
+		event.emit(id, payload)
+	else:
+		settled.emit(id, status, payload)
+
+
+func _on_lifecycle(state: String) -> void:
+	if PAUSING_STATES.has(state):
+		get_tree().paused = true
+	elif RESUMING_STATES.has(state):
+		get_tree().paused = false
+	lifecycle.emit(state)

package/engines/rust/interactives-ctx/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "interactives-ctx"
+version = "0.1.0"
+edition = "2024"
+license = "MIT"
+description = "The ctx binding for Cimplify Interactives games compiled to WebAssembly"
+
+[lib]
+path = "src/lib.rs"

package/engines/rust/interactives-ctx/src/lib.rs

@@ -0,0 +1,189 @@
+#![no_std]
+
+use core::cell::UnsafeCell;
+
+pub const ABI: i32 = 1;
+pub const KEY_WORDS: usize = 8;
+
+mod sys {
+    #[link(wasm_import_module = "cimplify")]
+    unsafe extern "C" {
+        pub fn request(target: i32, path: *const u8, path_length: i32, args: *const u8, args_length: i32) -> i32;
+        pub fn listen(target: i32, path: *const u8, path_length: i32, args: *const u8, args_length: i32) -> i32;
+        pub fn pack(name: *const u8, name_length: i32) -> i32;
+        pub fn status(id: i32) -> i32;
+        pub fn size(id: i32) -> i32;
+        pub fn take(id: i32, out: *mut u8, capacity: i32) -> i32;
+        pub fn release(id: i32);
+        pub fn present(rgba: *const u8, width: i32, height: i32);
+        pub fn log(level: i32, text: *const u8, length: i32);
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub struct Target(i32);
+
+pub const CTX: Target = Target(0);
+
+impl Target {
+    pub const fn handle(id: i32) -> Self {
+        Self(id)
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Status {
+    Pending,
+    Ready,
+    Failed,
+    Event,
+    Unknown,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub struct Short {
+    pub needed: usize,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub struct Call(i32);
+
+const STATUS_PENDING: i32 = 0;
+const STATUS_READY: i32 = 1;
+const STATUS_FAILED: i32 = 2;
+const STATUS_EVENT: i32 = 3;
+
+impl Call {
+    pub fn status(self) -> Status {
+        match unsafe { sys::status(self.0) } {
+            STATUS_PENDING => Status::Pending,
+            STATUS_READY => Status::Ready,
+            STATUS_FAILED => Status::Failed,
+            STATUS_EVENT => Status::Event,
+            _ => Status::Unknown,
+        }
+    }
+
+    pub fn size(self) -> usize {
+        unsafe { sys::size(self.0) }.max(0) as usize
+    }
+
+    pub fn take(self, out: &mut [u8]) -> Result<usize, Short> {
+        let written = unsafe { sys::take(self.0, out.as_mut_ptr(), out.len() as i32) };
+        if written < 0 {
+            return Err(Short { needed: self.size() });
+        }
+        Ok(written as usize)
+    }
+
+    pub fn release(self) {
+        unsafe { sys::release(self.0) }
+    }
+}
+
+pub fn request(target: Target, path: &str, args_json: &str) -> Call {
+    Call(unsafe { sys::request(target.0, path.as_ptr(), path.len() as i32, args_json.as_ptr(), args_json.len() as i32) })
+}
+
+pub fn listen(target: Target, path: &str, args_json: &str) -> Call {
+    Call(unsafe { sys::listen(target.0, path.as_ptr(), path.len() as i32, args_json.as_ptr(), args_json.len() as i32) })
+}
+
+pub fn pack(name: &str) -> Call {
+    Call(unsafe { sys::pack(name.as_ptr(), name.len() as i32) })
+}
+
+pub fn present(rgba: &[u8], width: u32, height: u32) {
+    if rgba.len() < width as usize * height as usize * 4 {
+        return;
+    }
+    unsafe { sys::present(rgba.as_ptr(), width as i32, height as i32) }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Level {
+    Debug = 0,
+    Warn = 1,
+    Error = 2,
+}
+
+pub fn log(level: Level, text: &str) {
+    unsafe { sys::log(level as i32, text.as_ptr(), text.len() as i32) }
+}
+
+#[repr(C)]
+pub struct Input {
+    pub width: i32,
+    pub height: i32,
+    pub pointer_x: i32,
+    pub pointer_y: i32,
+    pub pointer_down: i32,
+    pub pointer_presses: i32,
+    pub pointer_releases: i32,
+    reserved: i32,
+    pub keys_down: [u32; KEY_WORDS],
+    pub keys_pressed: [u32; KEY_WORDS],
+}
+
+impl Input {
+    const EMPTY: Self = Self {
+        width: 0,
+        height: 0,
+        pointer_x: 0,
+        pointer_y: 0,
+        pointer_down: 0,
+        pointer_presses: 0,
+        pointer_releases: 0,
+        reserved: 0,
+        keys_down: [0; KEY_WORDS],
+        keys_pressed: [0; KEY_WORDS],
+    };
+
+    pub fn key_down(&self, key_code: u32) -> bool {
+        bit(&self.keys_down, key_code)
+    }
+
+    pub fn key_pressed(&self, key_code: u32) -> bool {
+        bit(&self.keys_pressed, key_code)
+    }
+}
+
+fn bit(words: &[u32; KEY_WORDS], key_code: u32) -> bool {
+    let code = key_code & 255;
+    (words[(code >> 5) as usize] >> (code & 31)) & 1 == 1
+}
+
+struct InputCell(UnsafeCell<Input>);
+
+unsafe impl Sync for InputCell {}
+
+static INPUT: InputCell = InputCell(UnsafeCell::new(Input::EMPTY));
+
+pub fn input() -> &'static Input {
+    unsafe { &*INPUT.0.get() }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn cimplify_input_block() -> *mut Input {
+    INPUT.0.get()
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn cimplify_abi_version() -> i32 {
+    ABI
+}
+
+#[macro_export]
+macro_rules! game {
+    ($start:path, $frame:path) => {
+        #[unsafe(no_mangle)]
+        pub extern "C" fn cimplify_start() {
+            $start()
+        }
+
+        #[unsafe(no_mangle)]
+        pub extern "C" fn cimplify_frame(delta_micros: i32) {
+            $frame(delta_micros)
+        }
+    };
+}