@origingame/engine 0.2.0 → 0.4.0

package/src/generated/abi.ts

@@ -29,7 +29,7 @@ export interface HostAbi<A, V> {
   og_engine_take_log(engine: number): string;
   /** Write some fields of a resource as JSON: the runtime's path for a write a publish build refuses (logged once per system). A Result. */
   og_engine_write_resource(world: number, resource: string, value: string): string;
-  /** A resource's packed layout, how the runtime reads and writes its fields as bytes: a Result of `{ epoch, size, fields: [{ name, kind, offset, size, readonly, capacity, variants }] }` (`kind`: f32, f64, u32, i32, bool, Vector2, Vector3, Quaternion, Color, Matrix4, handle, str, enum). Refused for og.Time, og.Rng and og.Input, whose handles are computed, and for what is not a registered resource. */
+  /** A resource's packed layout, how the runtime reads and writes its fields as bytes: a Result of `{ epoch, size, fields: [{ name, kind, offset, size, readonly, capacity, variants, element }] }` (`kind`: f32, f64, u32, i32, bool, Vector2, Vector3, Quaternion, Color, Matrix4, handle, str, enum, or list: `element` one of f32, f64, u32, i32, handle and `capacity` its elements, a count lane first, each lane the element's size). Refused for og.Time, og.Rng and og.Input, whose handles are computed, and for what is not a registered resource. */
   og_engine_resource_layout(world: number, resource: string): string;
   /** A resource's packed bytes, then the layout epoch as a little-endian u32 (it moves when any layout is declared again: a new engine, a reload). Empty when refused (undeclared in the running system, not a resource): the runtime then asks og_world_resource for the reason. */
   og_engine_read_resource(world: number, resource: string): Uint8Array;
@@ -41,6 +41,12 @@ export interface HostAbi<A, V> {
   og_platform_answer(engine: number, request: number, answer: string): boolean;
   /** Say what answers this engine's platform calls: JSON `{ host, capabilities }` (`player`, `local` or `none`; the methods it answers), as og.platform.info reports. */
   og_platform_set_host(engine: number, info: string): void;
+  /** The room ops (IDL `platform` rooms, og.net's lockstep) made since the last call, oldest first, as JSON `[op]`: `{ op: "create", name, capacity }`, `{ op: "join", room, name }`, `{ op: "leave" }`, `{ op: "send", to?, channel?, data? | bytes? }` (bytes base64; a channel starting `og.` is the engine's own). The host carries each in order (docs/design.md §2.8). */
+  og_room_take(engine: number): string;
+  /** One room event from the host, JSON: `{ type: "joined", room, peer, peers: [{ peer, name }] }`, `{ type: "peer_joined", peer, name }`, `{ type: "peer_left", peer }`, `{ type: "message", from, channel?, data? | bytes? }`, `{ type: "left", reason }` or `{ type: "error", op, code, message }`. Lockstep's messages act between ticks at once; the game's events are sent at the start of the next tick. False for a malformed event. */
+  og_room_deliver(engine: number, event: string): boolean;
+  /** Say what carries this engine's rooms: JSON `{ host, join? }` (`relay`, `player` or `none`), as og.platform.roomInfo reports; with `none` roomCreate and roomJoin are refused. `join` is the room a Play link named (`?room=<id>`): the engine joins it once, itself, and og.RoomJoined answers. */
+  og_room_set_host(engine: number, info: string): void;
   /** `defineComponent` */
   og_reflect_define_component(name: string, fields: string): string;
   /** `defineResource` */
@@ -221,12 +227,70 @@ export interface HostAbi<A, V> {
   og_render_set_shader_param(world: number, material: number, name: string, value: string): string;
   /** `og.render.applyLook` */
   og_render_apply_look(world: number, look: number): string;
+  /** `og.render.applyQuality` */
+  og_render_apply_quality(world: number, preset: string): string;
   /** `og.render.look` */
   og_render_look(world: number): string;
   /** `og.render.capabilities` */
   og_render_capabilities(world: number): string;
   /** `og.render.text` */
   og_render_text(world: number, desc: string | undefined): string;
+  /** `og.render.bufferGeometry` */
+  og_render_buffer_geometry(world: number, desc: string | undefined): string;
+  /** `og.render.updateGeometry` */
+  og_render_update_geometry(world: number, geometry: number, desc: string | undefined): string;
+  /** `og.render.geometryInfo` */
+  og_render_geometry_info(world: number, geometry: number): string;
+  /** `og.render.cylinderGeometry` */
+  og_render_cylinder_geometry(world: number, desc: string | undefined): string;
+  /** `og.render.coneGeometry` */
+  og_render_cone_geometry(world: number, desc: string | undefined): string;
+  /** `og.render.capsuleGeometry` */
+  og_render_capsule_geometry(world: number, desc: string | undefined): string;
+  /** `og.render.torusGeometry` */
+  og_render_torus_geometry(world: number, desc: string | undefined): string;
+  /** `og.render.ringGeometry` */
+  og_render_ring_geometry(world: number, desc: string | undefined): string;
+  /** `og.render.circleGeometry` */
+  og_render_circle_geometry(world: number, desc: string | undefined): string;
+  /** `og.render.tubeGeometry` */
+  og_render_tube_geometry(world: number, desc: string | undefined): string;
+  /** `og.render.shapeGeometry` */
+  og_render_shape_geometry(world: number, desc: string | undefined): string;
+  /** `og.render.extrudeGeometry` */
+  og_render_extrude_geometry(world: number, desc: string | undefined): string;
+  /** `og.render.latheGeometry` */
+  og_render_lathe_geometry(world: number, desc: string | undefined): string;
+  /** `og.render.polyhedronGeometry` */
+  og_render_polyhedron_geometry(world: number, desc: string | undefined): string;
+  /** `og.render.icosahedronGeometry` */
+  og_render_icosahedron_geometry(world: number, desc: string | undefined): string;
+  /** `og.render.dodecahedronGeometry` */
+  og_render_dodecahedron_geometry(world: number, desc: string | undefined): string;
+  /** `og.render.octahedronGeometry` */
+  og_render_octahedron_geometry(world: number, desc: string | undefined): string;
+  /** `og.render.tetrahedronGeometry` */
+  og_render_tetrahedron_geometry(world: number, desc: string | undefined): string;
+  /** `og.render.sweepGeometry` */
+  og_render_sweep_geometry(world: number, desc: string | undefined): string;
+  /** `og.render.csgGeometry` */
+  og_render_csg_geometry(world: number, desc: string | undefined): string;
+  /** `og.render.mergeGeometries` */
+  og_render_merge_geometries(world: number, desc: string | undefined): string;
+  /** `og.render.lines` */
+  og_render_lines(world: number, desc: string | undefined): string;
+  /** `og.render.points` */
+  og_render_points(world: number, desc: string | undefined): string;
+  /** `og.render.raycast` */
+  og_render_raycast(world: number, ray: string, desc: string | undefined): string;
+  /** `og.render.renderTarget` */
+  og_render_render_target(world: number, desc: string | undefined): string;
+  /** `og.render.setPostParam` */
+  og_render_set_post_param(world: number, post: number, name: string, value: string): string;
+  /** `og.render.postErrors` */
+  og_render_post_errors(world: number): string;
+  /** `og.render.bakedLighting` */
+  og_render_baked_lighting(world: number): string;
   /** `og.load.bundle` */
   og_load_bundle(world: number, path: string): string;
   /** `og.load.bundleInfo` */
@@ -251,12 +315,14 @@ export interface HostAbi<A, V> {
   og_load_emitter(world: number, path: string): string;
   /** `og.load.shader` */
   og_load_shader(world: number, path: string): string;
+  /** `og.load.post` */
+  og_load_post(world: number, path: string): string;
   /** `og.load.texture` */
   og_load_texture(world: number, path: string): string;
   /** `og.load.textureArray` */
   og_load_texture_array(world: number, path: string): string;
-  /** `og.load.skin` */
-  og_load_skin(world: number, path: string): string;
+  /** `og.load.style` */
+  og_load_style(world: number, path: string): string;
   /** `og.load.look` */
   og_load_look(world: number, path: string): string;
   /** `og.load.lookInfo` */
@@ -279,6 +345,14 @@ export interface HostAbi<A, V> {
   og_load_flipbook(world: number, path: string): string;
   /** `og.load.tilemap` */
   og_load_tilemap(world: number, path: string): string;
+  /** `og.load.video` */
+  og_load_video(world: number, path: string): string;
+  /** `og.load.videoInfo` */
+  og_load_video_info(world: number, video: number): string;
+  /** `og.load.timeline` */
+  og_load_timeline(world: number, path: string): string;
+  /** `og.load.rig2d` */
+  og_load_rig2d(world: number, path: string): string;
   /** `og.physics.raycast` */
   og_physics_raycast(world: number, desc: string | undefined): string;
   /** `og.physics.shapeCast` */
@@ -323,6 +397,10 @@ export interface HostAbi<A, V> {
   og_anim_humanoid(world: number, desc: string | undefined): string;
   /** `og.anim.retarget` */
   og_anim_retarget(world: number, desc: string | undefined): string;
+  /** `og.anim.rig2dInfo` */
+  og_anim_rig2d_info(world: number, rig: number): string;
+  /** `og.anim.skeleton2dBoxes` */
+  og_anim_skeleton2d_boxes(world: number, entity: number): string;
   /** `og.tween.to` */
   og_tween_to(world: number, desc: string | undefined): string;
   /** `og.tween.sequence` */
@@ -421,6 +499,20 @@ export interface HostAbi<A, V> {
   og_platform_info(world: number): string;
   /** `og.platform.now` */
   og_platform_now(world: number): number;
+  /** `og.platform.roomCreate` */
+  og_platform_room_create(world: number, desc: string | undefined): string;
+  /** `og.platform.roomJoin` */
+  og_platform_room_join(world: number, room: string): string;
+  /** `og.platform.roomLeave` */
+  og_platform_room_leave(world: number): string;
+  /** `og.platform.roomSend` */
+  og_platform_room_send(world: number, data: string, to: number | undefined): string;
+  /** `og.platform.roomPeers` */
+  og_platform_room_peers(world: number): string;
+  /** `og.platform.roomInfo` */
+  og_platform_room_info(world: number): string;
+  /** `og.platform.roomMessage` */
+  og_platform_room_message(world: number, message: number): string;
   /** `og.i18n.load` */
   og_i18n_load(world: number, path: string): string;
   /** `og.i18n.setLocale` */
@@ -629,6 +721,14 @@ export interface HostAbi<A, V> {
   og_engine_probe_listen(engine_probe: number, seconds: number | undefined): string;
   /** `EngineProbe.memory` */
   og_engine_probe_memory(engine_probe: number): string;
+  /** `EngineProbe.describe` */
+  og_engine_probe_describe(engine_probe: number): string;
+  /** `EngineProbe.expect` */
+  og_engine_probe_expect(engine_probe: number, what: string): string;
+  /** `EngineProbe.expectations` */
+  og_engine_probe_expectations(engine_probe: number): string;
+  /** `EngineProbe.saveScene` */
+  og_engine_probe_save_scene(engine_probe: number, write: boolean | undefined, spawned: boolean | undefined): string;
   /** `og.terrain.load` */
   og_terrain_load(world: number, path: string): string;
   /** `og.terrain.sample` */
@@ -651,6 +751,54 @@ export interface HostAbi<A, V> {
   og_stream_budget(world: number): string;
   /** `og.stream.setBudget` */
   og_stream_set_budget(world: number, bytes: number): string;
+  /** `og.debug.line` */
+  og_debug_line(world: number, from: string, to: string, desc: string | undefined): void;
+  /** `og.debug.box` */
+  og_debug_box(world: number, center: string, size: string, desc: string | undefined): void;
+  /** `og.debug.sphere` */
+  og_debug_sphere(world: number, center: string, radius: number, desc: string | undefined): void;
+  /** `og.debug.arrow` */
+  og_debug_arrow(world: number, from: string, to: string, desc: string | undefined): void;
+  /** `og.debug.axes` */
+  og_debug_axes(world: number, position: string, size: number, desc: string | undefined): void;
+  /** `og.debug.text` */
+  og_debug_text(world: number, position: string, text: string, desc: string | undefined): void;
+  /** `og.debug.clear` */
+  og_debug_clear(world: number): void;
+  /** `og.debug.setView` */
+  og_debug_set_view(world: number, view: string): void;
+  /** `og.debug.view` */
+  og_debug_view(world: number): string;
+  /** `og.debug.setEnabled` */
+  og_debug_set_enabled(world: number, enabled: boolean): void;
+  /** `og.debug.enabled` */
+  og_debug_enabled(world: number): boolean;
+  /** `og.path.create` */
+  og_path_create(world: number, desc: string | undefined): string;
+  /** `og.path.find` */
+  og_path_find(world: number, name: string): string;
+  /** `og.path.sample` */
+  og_path_sample(world: number, path: number, t: number): string;
+  /** `og.path.length` */
+  og_path_length(world: number, path: number): string;
+  /** `og.path.nearest` */
+  og_path_nearest(world: number, path: number, point: string): string;
+  /** `og.timeline.info` */
+  og_timeline_info(world: number, asset: number): string;
+  /** `og.timeline.play` */
+  og_timeline_play(world: number, entity: number): string;
+  /** `og.timeline.pause` */
+  og_timeline_pause(world: number, entity: number): string;
+  /** `og.timeline.seek` */
+  og_timeline_seek(world: number, entity: number, time: number): string;
+  /** `og.timeline.stop` */
+  og_timeline_stop(world: number, entity: number): string;
+  /** `og.net.submit` */
+  og_net_submit(world: number, input: string | undefined): string;
+  /** `og.net.status` */
+  og_net_status(world: number): string;
+  /** `og.net.hash` */
+  og_net_hash(world: number): string;
 }
 
 /** Every binding symbol, in binding-table order, then the lifecycle members. */
@@ -745,9 +893,38 @@ export const SYMBOLS: readonly string[] = [
   "og_render_set_material_shader",
   "og_render_set_shader_param",
   "og_render_apply_look",
+  "og_render_apply_quality",
   "og_render_look",
   "og_render_capabilities",
   "og_render_text",
+  "og_render_buffer_geometry",
+  "og_render_update_geometry",
+  "og_render_geometry_info",
+  "og_render_cylinder_geometry",
+  "og_render_cone_geometry",
+  "og_render_capsule_geometry",
+  "og_render_torus_geometry",
+  "og_render_ring_geometry",
+  "og_render_circle_geometry",
+  "og_render_tube_geometry",
+  "og_render_shape_geometry",
+  "og_render_extrude_geometry",
+  "og_render_lathe_geometry",
+  "og_render_polyhedron_geometry",
+  "og_render_icosahedron_geometry",
+  "og_render_dodecahedron_geometry",
+  "og_render_octahedron_geometry",
+  "og_render_tetrahedron_geometry",
+  "og_render_sweep_geometry",
+  "og_render_csg_geometry",
+  "og_render_merge_geometries",
+  "og_render_lines",
+  "og_render_points",
+  "og_render_raycast",
+  "og_render_render_target",
+  "og_render_set_post_param",
+  "og_render_post_errors",
+  "og_render_baked_lighting",
   "og_load_bundle",
   "og_load_bundle_info",
   "og_load_default_bundle",
@@ -760,9 +937,10 @@ export const SYMBOLS: readonly string[] = [
   "og_load_environment",
   "og_load_emitter",
   "og_load_shader",
+  "og_load_post",
   "og_load_texture",
   "og_load_texture_array",
-  "og_load_skin",
+  "og_load_style",
   "og_load_look",
   "og_load_look_info",
   "og_load_palette",
@@ -774,6 +952,10 @@ export const SYMBOLS: readonly string[] = [
   "og_load_rig",
   "og_load_flipbook",
   "og_load_tilemap",
+  "og_load_video",
+  "og_load_video_info",
+  "og_load_timeline",
+  "og_load_rig2d",
   "og_physics_raycast",
   "og_physics_shape_cast",
   "og_physics_overlap",
@@ -796,6 +978,8 @@ export const SYMBOLS: readonly string[] = [
   "og_anim_graph",
   "og_anim_humanoid",
   "og_anim_retarget",
+  "og_anim_rig2d_info",
+  "og_anim_skeleton2d_boxes",
   "og_tween_to",
   "og_tween_sequence",
   "og_tween_parallel",
@@ -845,6 +1029,13 @@ export const SYMBOLS: readonly string[] = [
   "og_platform_result",
   "og_platform_info",
   "og_platform_now",
+  "og_platform_room_create",
+  "og_platform_room_join",
+  "og_platform_room_leave",
+  "og_platform_room_send",
+  "og_platform_room_peers",
+  "og_platform_room_info",
+  "og_platform_room_message",
   "og_i18n_load",
   "og_i18n_set_locale",
   "og_i18n_locale",
@@ -949,6 +1140,10 @@ export const SYMBOLS: readonly string[] = [
   "og_engine_probe_commands",
   "og_engine_probe_listen",
   "og_engine_probe_memory",
+  "og_engine_probe_describe",
+  "og_engine_probe_expect",
+  "og_engine_probe_expectations",
+  "og_engine_probe_save_scene",
   "og_terrain_load",
   "og_terrain_sample",
   "og_terrain_bounds",
@@ -960,6 +1155,30 @@ export const SYMBOLS: readonly string[] = [
   "og_stream_release",
   "og_stream_budget",
   "og_stream_set_budget",
+  "og_debug_line",
+  "og_debug_box",
+  "og_debug_sphere",
+  "og_debug_arrow",
+  "og_debug_axes",
+  "og_debug_text",
+  "og_debug_clear",
+  "og_debug_set_view",
+  "og_debug_view",
+  "og_debug_set_enabled",
+  "og_debug_enabled",
+  "og_path_create",
+  "og_path_find",
+  "og_path_sample",
+  "og_path_length",
+  "og_path_nearest",
+  "og_timeline_info",
+  "og_timeline_play",
+  "og_timeline_pause",
+  "og_timeline_seek",
+  "og_timeline_stop",
+  "og_net_submit",
+  "og_net_status",
+  "og_net_hash",
   "og_host_set_dispatcher",
   "og_engine_create",
   "og_engine_destroy",
@@ -977,4 +1196,7 @@ export const SYMBOLS: readonly string[] = [
   "og_platform_take",
   "og_platform_answer",
   "og_platform_set_host",
+  "og_room_take",
+  "og_room_deliver",
+  "og_room_set_host",
 ];

package/src/geom.ts

@@ -0,0 +1,260 @@
+// Procedural modelling (IDL `shapes` and the og-geom members of `render`):
+// og.Shape and og.Path2, three.js's Shape and Path with its methods and its
+// curve formulas, and the render calls that take them. A shape never
+// crosses the wire: it is flattened to points here (three.js's
+// extractPoints(curveSegments)), so og-geom triangulates the same points
+// three.js would.
+//
+// Determinism: the points may end up in world state through the geometry
+// made from them, so the arcs read sincos (basic arithmetic, the camera
+// systems' series), never Math.sin or Math.cos.
+
+import type * as Api from "@origingame/engine";
+import type { HostAbi } from "./generated/abi.ts";
+import { boundHost } from "./runtime.ts";
+import { sincos } from "./systems/cameras.ts";
+
+type V2 = { x: number; y: number };
+type W = { readonly id: number };
+
+const TAU = 2 * 3.141592653589793;
+const EPSILON = 2.220446049250313e-16;
+const v2 = (x: number, y: number): V2 => ({ x, y });
+const equals = (a: V2, b: V2) => a.x === b.x && a.y === b.y;
+
+// three.js's Interpolations.
+function catmullRom(t: number, p0: number, p1: number, p2: number, p3: number): number {
+  const v0 = (p2 - p0) * 0.5;
+  const v1 = (p3 - p1) * 0.5;
+  const t2 = t * t;
+  const t3 = t * t2;
+  return (2 * p1 - 2 * p2 + v0 + v1) * t3 + (-3 * p1 + 3 * p2 - 2 * v0 - v1) * t2 + v0 * t + p1;
+}
+function quadratic(t: number, p0: number, p1: number, p2: number): number {
+  const k = 1 - t;
+  return k * k * p0 + 2 * (1 - t) * t * p1 + t * t * p2;
+}
+function cubic(t: number, p0: number, p1: number, p2: number, p3: number): number {
+  const k = 1 - t;
+  return k * k * k * p0 + 3 * k * k * t * p1 + 3 * (1 - t) * t * t * p2 + t * t * t * p3;
+}
+
+/** One of three.js's 2D curves, by its getPoint(t) and how finely CurvePath.getPoints divides it. */
+interface Curve {
+  point(t: number): V2;
+  resolution(divisions: number): number;
+}
+
+const line = (a: V2, b: V2): Curve => ({
+  // three.js LineCurve.getPoint: the end exactly at 1.
+  point: (t) => (t === 1 ? v2(b.x, b.y) : v2((b.x - a.x) * t + a.x, (b.y - a.y) * t + a.y)),
+  resolution: () => 1,
+});
+
+const quadraticCurve = (a: V2, c: V2, b: V2): Curve => ({
+  point: (t) => v2(quadratic(t, a.x, c.x, b.x), quadratic(t, a.y, c.y, b.y)),
+  resolution: (d) => d,
+});
+
+const cubicCurve = (a: V2, c1: V2, c2: V2, b: V2): Curve => ({
+  point: (t) => v2(cubic(t, a.x, c1.x, c2.x, b.x), cubic(t, a.y, c1.y, c2.y, b.y)),
+  resolution: (d) => d,
+});
+
+function splineCurve(points: readonly V2[]): Curve {
+  return {
+    point: (t) => {
+      const p = (points.length - 1) * t;
+      const i = Math.floor(p);
+      const w = p - i;
+      const p0 = points[i === 0 ? i : i - 1]!;
+      const p1 = points[i]!;
+      const p2 = points[i > points.length - 2 ? points.length - 1 : i + 1]!;
+      const p3 = points[i > points.length - 3 ? points.length - 1 : i + 2]!;
+      return v2(catmullRom(w, p0.x, p1.x, p2.x, p3.x), catmullRom(w, p0.y, p1.y, p2.y, p3.y));
+    },
+    resolution: (d) => d * points.length,
+  };
+}
+
+function ellipseCurve(x: number, y: number, rx: number, ry: number, start: number, end: number, clockwise: boolean, rotation: number): Curve {
+  return {
+    point: (t) => {
+      let delta = end - start;
+      const same = Math.abs(delta) < EPSILON;
+      while (delta < 0) delta += TAU;
+      while (delta > TAU) delta -= TAU;
+      if (delta < EPSILON) delta = same ? 0 : TAU;
+      if (clockwise && !same) delta = delta === TAU ? -TAU : delta - TAU;
+      const [s, c] = sincos(start + t * delta);
+      let px = x + rx * c;
+      let py = y + ry * s;
+      if (rotation !== 0) {
+        const [rs, rc] = sincos(rotation);
+        const tx = px - x;
+        const ty = py - y;
+        px = tx * rc - ty * rs + x;
+        py = tx * rs + ty * rc + y;
+      }
+      return v2(px, py);
+    },
+    resolution: (d) => d * 2,
+  };
+}
+
+const point = (p: Api.Vector2): V2 => v2(p.x, p.y);
+
+/** three.js's Path: curves from a current point. */
+export class Path2 {
+  #curves: Curve[] = [];
+  #current: V2 = v2(0, 0);
+
+  constructor(points?: readonly Api.Vector2[] | null) {
+    if (points) this.setFromPoints(points);
+  }
+
+  setFromPoints(points: readonly Api.Vector2[]): this {
+    if (points.length === 0) return this;
+    this.moveTo(points[0]!.x, points[0]!.y);
+    for (let i = 1; i < points.length; i++) this.lineTo(points[i]!.x, points[i]!.y);
+    return this;
+  }
+
+  moveTo(x: number, y: number): this {
+    this.#current = v2(x, y);
+    return this;
+  }
+
+  lineTo(x: number, y: number): this {
+    this.#curves.push(line(this.#current, v2(x, y)));
+    this.#current = v2(x, y);
+    return this;
+  }
+
+  quadraticCurveTo(cpX: number, cpY: number, x: number, y: number): this {
+    this.#curves.push(quadraticCurve(this.#current, v2(cpX, cpY), v2(x, y)));
+    this.#current = v2(x, y);
+    return this;
+  }
+
+  bezierCurveTo(cp1X: number, cp1Y: number, cp2X: number, cp2Y: number, x: number, y: number): this {
+    this.#curves.push(cubicCurve(this.#current, v2(cp1X, cp1Y), v2(cp2X, cp2Y), v2(x, y)));
+    this.#current = v2(x, y);
+    return this;
+  }
+
+  splineThru(points: readonly Api.Vector2[]): this {
+    if (points.length === 0) return this;
+    this.#curves.push(splineCurve([this.#current, ...points.map(point)]));
+    this.#current = point(points[points.length - 1]!);
+    return this;
+  }
+
+  arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, clockwise = false): this {
+    return this.absarc(x + this.#current.x, y + this.#current.y, radius, startAngle, endAngle, clockwise);
+  }
+
+  absarc(x: number, y: number, radius: number, startAngle: number, endAngle: number, clockwise = false): this {
+    return this.absellipse(x, y, radius, radius, startAngle, endAngle, clockwise);
+  }
+
+  ellipse(x: number, y: number, xRadius: number, yRadius: number, startAngle: number, endAngle: number, clockwise = false, rotation = 0): this {
+    return this.absellipse(x + this.#current.x, y + this.#current.y, xRadius, yRadius, startAngle, endAngle, clockwise, rotation);
+  }
+
+  absellipse(x: number, y: number, xRadius: number, yRadius: number, startAngle: number, endAngle: number, clockwise = false, rotation = 0): this {
+    const curve = ellipseCurve(x, y, xRadius, yRadius, startAngle, endAngle, clockwise, rotation);
+    if (this.#curves.length > 0) {
+      // A previous curve: join it with a line when the arc starts elsewhere.
+      const first = curve.point(0);
+      if (!equals(first, this.#current)) this.lineTo(first.x, first.y);
+    }
+    this.#curves.push(curve);
+    this.#current = curve.point(1);
+    return this;
+  }
+
+  closePath(): this {
+    if (this.#curves.length === 0) return this;
+    const start = this.#curves[0]!.point(0);
+    const end = this.#curves[this.#curves.length - 1]!.point(1);
+    if (!equals(start, end)) this.#curves.push(line(end, start));
+    return this;
+  }
+
+  getPoints(divisions = 12): Api.Vector2[] {
+    const out: V2[] = [];
+    let last: V2 | undefined;
+    for (const curve of this.#curves) {
+      const resolution = curve.resolution(divisions);
+      for (let d = 0; d <= resolution; d++) {
+        const p = curve.point(d / resolution);
+        if (last && equals(last, p)) continue;
+        out.push(p);
+        last = p;
+      }
+    }
+    return out;
+  }
+}
+
+/** three.js's Shape: a path with holes. */
+export class Shape extends Path2 {
+  readonly holes: Path2[] = [];
+
+  extractPoints(divisions = 12): Api.ShapePoints {
+    return { shape: this.getPoints(divisions), holes: this.holes.map((h) => h.getPoints(divisions)) };
+  }
+}
+
+// ── the render calls ────────────────────────────────────────────────────────
+
+function abi(): HostAbi<Uint32Array, unknown> {
+  const h = boundHost();
+  if (!h) throw new Error("no engine host is loaded: start the game through @origingame/engine's web or node loader");
+  return h.abi;
+}
+
+const parse = <T>(text: string): T => JSON.parse(text) as T;
+const json = (value: unknown): string | undefined => (value === undefined ? undefined : JSON.stringify(value));
+
+type Desc = Record<string, unknown>;
+
+/** A shape as it crosses: its points and its holes' points. */
+function flat(s: Path2, divisions: number): Api.ShapePoints {
+  return s instanceof Shape ? s.extractPoints(divisions) : { shape: s.getPoints(divisions), holes: [] };
+}
+
+/** `shapes` (a Shape, a list of them, or the outline's points) as points. */
+function shapes(desc: unknown): string | undefined {
+  if (desc === undefined || desc === null || typeof desc !== "object") return json(desc);
+  const d: Desc = { ...(desc as Desc) };
+  const divisions = typeof d.curveSegments === "number" ? d.curveSegments : 12;
+  const v = d.shapes;
+  if (v instanceof Path2) d.shapes = [flat(v, divisions)];
+  else if (Array.isArray(v) && v.length > 0 && v[0] instanceof Path2) d.shapes = (v as Path2[]).map((s) => flat(s, divisions));
+  return JSON.stringify(d);
+}
+
+/** A sweep's `section`: a Shape or Path2 flattened, its holes dropped. */
+function section(desc: unknown): string | undefined {
+  if (desc === undefined || desc === null || typeof desc !== "object") return json(desc);
+  const d: Desc = { ...(desc as Desc) };
+  const divisions = typeof d.curveSegments === "number" ? d.curveSegments : 12;
+  if (d.section instanceof Path2) d.section = d.section.getPoints(divisions);
+  return JSON.stringify(d);
+}
+
+export const geomRender = Object.freeze({
+  shapeGeometry: (world: W, desc?: unknown) => parse(abi().og_render_shape_geometry(world.id, shapes(desc))),
+  extrudeGeometry: (world: W, desc?: unknown) => parse(abi().og_render_extrude_geometry(world.id, shapes(desc))),
+  latheGeometry: (world: W, desc?: unknown) => parse(abi().og_render_lathe_geometry(world.id, json(desc))),
+  polyhedronGeometry: (world: W, desc?: unknown) => parse(abi().og_render_polyhedron_geometry(world.id, json(desc))),
+  icosahedronGeometry: (world: W, desc?: unknown) => parse(abi().og_render_icosahedron_geometry(world.id, json(desc))),
+  dodecahedronGeometry: (world: W, desc?: unknown) => parse(abi().og_render_dodecahedron_geometry(world.id, json(desc))),
+  octahedronGeometry: (world: W, desc?: unknown) => parse(abi().og_render_octahedron_geometry(world.id, json(desc))),
+  tetrahedronGeometry: (world: W, desc?: unknown) => parse(abi().og_render_tetrahedron_geometry(world.id, json(desc))),
+  sweepGeometry: (world: W, desc?: unknown) => parse(abi().og_render_sweep_geometry(world.id, section(desc))),
+  csgGeometry: (world: W, desc?: unknown) => parse(abi().og_render_csg_geometry(world.id, json(desc))),
+  mergeGeometries: (world: W, desc?: unknown) => parse(abi().og_render_merge_geometries(world.id, json(desc))),
+});