@nayan-ui/engine 0.0.0-stage → 1.0.0-beta.4

package/lib/module/native/BrowserEngine.js

@@ -0,0 +1,568 @@
+"use strict";
+
+/** Raw C exports are shared with the mobile JSI bridge. All pointers stay private here. */
+
+const lengths = {
+  matrices: c => c * 64,
+  colors: c => c * 16,
+  regions: c => c * 16,
+  ranges: () => 4096 * 16,
+  done: c => (c * 5 + 64) * 4,
+  events: () => 4096 * 16,
+  scratch: () => 64,
+  scoreboard_state: () => 64
+};
+/** Mirrors whose native memory is exactly as long as the mirror, so a renderer can read it in place. */
+const drawable = new Set(['matrices', 'colors', 'regions', 'ranges']);
+const MATRIX_BYTES = 64;
+const VEC4_BYTES = 16;
+/** Doubles per `setTransforms` record (TRANSFORM_STRIDE). */
+const TRANSFORM_DOUBLES = 16;
+/** Scoreboard slot JS may clear after reading (see engine_world_scoreboard_state). */
+const SCORE_FLAGS = 4;
+export function createBrowserEngine(core) {
+  const worlds = new Map();
+  // Mirrors handed to JS, so render calls given a world's own buffers read its memory in place.
+  const mirrors = new WeakMap();
+  let nextWorld = 1;
+  const slots = [];
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+
+  // Exports are resolved once (lazily, so a core missing an optional export fails only when it is used).
+  const resolved = Object.create(null);
+  const ex = name => {
+    const cached = resolved[name];
+    if (cached) return cached;
+    const found = core[`engine_${name}`];
+    if (typeof found !== 'function') throw new Error(`Engine WASM is missing engine_${name}`);
+    resolved[name] = found;
+    return found;
+  };
+  const fn = (name, ...args) => Number(ex(name)(...args));
+
+  // Views into WASM memory, re-created only after memory.grow replaces (detaches) the buffer.
+  let heap = null;
+  let heapU8 = new Uint8Array(0);
+  let heapF64 = new Float64Array(0);
+  const memory = () => {
+    const current = core.memory.buffer;
+    if (current !== heap) {
+      heap = current;
+      heapU8 = new Uint8Array(current);
+      heapF64 = new Float64Array(current, 0, current.byteLength >> 3);
+    }
+    return current;
+  };
+  const u8 = () => {
+    memory();
+    return heapU8;
+  };
+  const f64 = () => {
+    memory();
+    return heapF64;
+  };
+  const buf = value => {
+    if (!(value instanceof ArrayBuffer)) throw new Error('Engine: expected an ArrayBuffer');
+    return value;
+  };
+  const bytes = value => new Uint8Array(buf(value));
+  const copy = (pointer, length) => u8().slice(pointer, pointer + length).buffer;
+
+  // Reused aligned scratch allocations, one per argument position.
+  const slot = (index, size) => {
+    let s = slots[index];
+    if (!s || s.size < size) {
+      if (s) {
+        slots[index] = undefined;
+        fn('web_free', s.pointer, s.size);
+      }
+      const reserved = Math.max(64, size);
+      s = {
+        pointer: fn('web_alloc', reserved),
+        size: reserved
+      };
+      slots[index] = s;
+    }
+    return s.pointer;
+  };
+  /** Copies `value` into scratch slot `index` (allocating first, since growth detaches views). */
+  const put = (index, value) => {
+    const pointer = slot(index, value.byteLength);
+    u8().set(value, pointer);
+    return pointer;
+  };
+  /** A zero-filled scratch slot for a native function to write into. */
+  const zeroed = (index, size) => {
+    const pointer = slot(index, size);
+    u8().fill(0, pointer, pointer + size);
+    return pointer;
+  };
+  const inputs = values => values.map((value, i) => put(i, value));
+  const data = (...values) => inputs(values.map(bytes));
+  const w = id => {
+    const world = worlds.get(id);
+    if (!world) throw new Error('World: unknown or disposed world');
+    return world;
+  };
+  const ptr = id => w(id).pointer;
+  const native = (world, name) => Number(ex(`world_${name}`)(world.pointer));
+  /** Copies up to `length` bytes of a world output into its mirror (if JS asked for that mirror). */
+  const sync = (world, name, length) => {
+    const view = world.views.get(name);
+    if (!view) return;
+    const n = Math.min(length, view.byteLength);
+    if (n <= 0) return;
+    const pointer = native(world, name);
+    view.set(u8().subarray(pointer, pointer + n));
+  };
+  const buffer = (id, name) => {
+    const world = w(id);
+    let b = world.buffers.get(name);
+    if (!b) {
+      b = new ArrayBuffer(lengths[name](world.capacity));
+      world.buffers.set(name, b);
+      world.views.set(name, new Uint8Array(b));
+      if (name === 'scoreboard_state') world.score = new Float64Array(b);
+      mirrors.set(b, {
+        world,
+        name
+      });
+      // done/events have valid lengths smaller than their reserved storage.
+      sync(world, name, name === 'done' ? fn('world_done_len', world.pointer) * 4 : name === 'events' ? fn('world_event_len', world.pointer) * 4 : b.byteLength);
+    }
+    return b;
+  };
+  const scoreIn = world => {
+    if (!world.score) return;
+    const pointer = native(world, 'scoreboard_state');
+    f64()[(pointer >> 3) + SCORE_FLAGS] = world.score[SCORE_FLAGS];
+  };
+  /**
+   * A render input: a live world's own output buffer is read in place (the mirror holds the same
+   * data, copied after the last update), anything else is copied into scratch slot `index`.
+   */
+  const source = (index, value) => {
+    const b = buf(value);
+    const mirror = mirrors.get(b);
+    if (mirror && drawable.has(mirror.name) && worlds.get(mirror.world.id) === mirror.world) return native(mirror.world, mirror.name);
+    return put(index, new Uint8Array(b));
+  };
+  const scalar = (name, id, ...args) => Number(ex(name)(ptr(id), ...args));
+  const hit = (id, name, ...args) => {
+    const world = w(id);
+    const result = Number(ex(name)(world.pointer, ...args));
+    sync(world, 'scratch', 64);
+    return result === 0xffffffff || result === -1 ? -1 : result;
+  };
+  const query = (id, name, ...args) => {
+    const world = w(id);
+    const result = Number(ex(name)(world.pointer, ...args));
+    sync(world, 'scratch', 64);
+    return result !== 0;
+  };
+  const string = (name, args = []) => {
+    const length = fn(name, ...args, 0, 0);
+    const p = zeroed(0, length + 1);
+    fn(name, ...args, p, length + 1);
+    return decoder.decode(u8().subarray(p, p + length));
+  };
+  const cString = pointer => {
+    const b = u8();
+    let end = pointer;
+    while (end < b.length && b[end] !== 0) end++;
+    return decoder.decode(b.subarray(pointer, end));
+  };
+  const geometry = handle => {
+    try {
+      const error = cString(fn('geometry_error', handle));
+      if (error) throw new Error(`Engine geometry: ${error}`);
+      const pointer = fn('geometry_data', handle);
+      const size = fn('geometry_size', handle);
+      if (size < 8) throw new Error('Engine geometry: invalid result');
+      const header = new Uint32Array(memory(), pointer, 2);
+      const vertexBytes = header[0] * 44;
+      const indexBytes = header[1] * 4;
+      if (size !== 8 + vertexBytes + indexBytes) throw new Error('Engine geometry: invalid buffers');
+      return {
+        vertices: copy(pointer + 8, vertexBytes),
+        indices: copy(pointer + 8 + vertexBytes, indexBytes)
+      };
+    } finally {
+      fn('geometry_free', handle);
+    }
+  };
+  const meshCopy = (mesh, kind) => {
+    const count = fn(`render_mesh_${kind === 'vertices' ? 'vertex' : 'index'}_count`, mesh);
+    const size = count * (kind === 'vertices' ? 44 : 4);
+    const p = zeroed(0, size);
+    fn(`render_mesh_${kind}`, mesh, p, size / 4);
+    return copy(p, size);
+  };
+  const dimensions = (name, id, count, float) => {
+    const p = zeroed(0, count * 4);
+    fn(name, id, p);
+    return Array.from(float ? new Float32Array(memory(), p, count) : new Uint32Array(memory(), p, count));
+  };
+  /** A promise for work that runs right here (its errors reject it). */
+  const settle = work => new Promise(resolve => resolve(work()));
+  const engine = {
+    createWorld(capacity) {
+      if (!Number.isInteger(capacity) || capacity < 1 || capacity > 1_000_000) throw new Error('World: capacity must be an integer in 1..1000000');
+      const id = nextWorld++;
+      worlds.set(id, {
+        id,
+        pointer: fn('world_new', capacity),
+        capacity,
+        buffers: new Map(),
+        views: new Map(),
+        score: null
+      });
+      return id;
+    },
+    destroyWorld(id) {
+      fn('world_free', ptr(id));
+      worlds.delete(id);
+    },
+    spawnDesc(id, desc) {
+      const b = bytes(desc);
+      const p = put(0, b);
+      return hit(id, 'world_spawn_desc', p, b.byteLength / 8);
+    },
+    setDesc(id, entity, desc) {
+      const b = bytes(desc);
+      const p = put(0, b);
+      return scalar('world_set_desc', id, entity, p, b.byteLength / 8) !== 0;
+    },
+    setTransforms(id, transforms, count) {
+      const b = buf(transforms);
+      // The batch's storage only grows: copy just the queued records.
+      const used = count > 0 ? Math.min(b.byteLength, Math.trunc(count) * TRANSFORM_DOUBLES * 8) : b.byteLength;
+      const p = put(0, new Uint8Array(b, 0, used));
+      return scalar('world_set_transforms', id, p, used / 8, count);
+    },
+    despawn(id, entity) {
+      return scalar('world_despawn', id, entity) !== 0;
+    },
+    impulse(id, entity, x, y, z) {
+      scalar('world_apply_impulse', id, entity, x, y, z);
+    },
+    setGravity(id, x, y, z) {
+      scalar('world_set_gravity', id, x, y, z);
+    },
+    setBounds(id, a, b, c, d) {
+      scalar('world_set_bounds', id, a, b, c, d);
+    },
+    setListener(id, entity) {
+      scalar('world_set_listener', id, entity);
+    },
+    raycast(id, ...args) {
+      return hit(id, 'world_raycast', ...args);
+    },
+    pick(id, ...args) {
+      return hit(id, 'world_pick', ...args);
+    },
+    pickScreen(id, x, y) {
+      return hit(id, 'world_pick_screen', x, y);
+    },
+    setView(id, matrix, width, height) {
+      const p = put(0, bytes(matrix));
+      scalar('world_set_view', id, p, width, height);
+    },
+    screenRay(id, x, y) {
+      return query(id, 'world_screen_ray', x, y);
+    },
+    screenToWorld(id, ...args) {
+      return query(id, 'world_screen_to_world', ...args);
+    },
+    toScreen(id, x, y, z) {
+      return query(id, 'world_to_screen', x, y, z);
+    },
+    readPosition(id, entity, rendered) {
+      return query(id, 'world_read_position', entity, +rendered);
+    },
+    readVelocity(id, entity) {
+      return query(id, 'world_read_velocity', entity);
+    },
+    animate(id, value) {
+      const b = bytes(value);
+      const p = put(0, b);
+      return scalar('world_animate', id, p, b.byteLength / 8);
+    },
+    stopAnimation(id, entity) {
+      return scalar('world_stop_animation', id, entity) !== 0;
+    },
+    burst(id, value) {
+      const b = bytes(value);
+      const p = put(0, b);
+      return scalar('world_burst', id, p, b.byteLength / 8);
+    },
+    update(id, dt) {
+      const world = w(id);
+      scoreIn(world);
+      ex('world_update')(world.pointer, dt);
+      // Only the first `count` instances are valid after an update (ranges never reach past them),
+      // so the per-instance mirrors copy just those rather than the whole capacity.
+      const count = Number(ex('world_count')(world.pointer));
+      sync(world, 'matrices', count * MATRIX_BYTES);
+      sync(world, 'colors', count * VEC4_BYTES);
+      sync(world, 'regions', count * VEC4_BYTES);
+      sync(world, 'ranges', Infinity);
+      sync(world, 'scoreboard_state', Infinity);
+    },
+    after(id, seconds) {
+      return scalar('world_after', id, seconds);
+    },
+    cancelTimers(id) {
+      return scalar('world_cancel_timers', id);
+    },
+    scoreboard(id, op, a, b) {
+      const world = w(id);
+      scoreIn(world);
+      const result = Number(ex('world_scoreboard')(world.pointer, op, a, b));
+      sync(world, 'scoreboard_state', Infinity);
+      return result;
+    },
+    getScoreboard: id => buffer(id, 'scoreboard_state'),
+    count: id => scalar('world_count', id),
+    getMatrices: id => buffer(id, 'matrices'),
+    getColors: id => buffer(id, 'colors'),
+    getRegions: id => buffer(id, 'regions'),
+    getRanges: id => buffer(id, 'ranges'),
+    getDone: id => buffer(id, 'done'),
+    doneLength(id) {
+      const world = w(id);
+      const length = fn('world_done_len', world.pointer);
+      sync(world, 'done', length * 4);
+      return length;
+    },
+    getEvents: id => buffer(id, 'events'),
+    eventLength(id) {
+      const world = w(id);
+      const length = fn('world_event_len', world.pointer);
+      sync(world, 'events', length * 4);
+      return length;
+    },
+    getScratch: id => buffer(id, 'scratch'),
+    modelRig: mesh => string('model_rig', [mesh]),
+    playClip(id, entity, name, loop, speed, fade, time) {
+      const b = encoder.encode(name);
+      const p = put(0, b);
+      return scalar('world_play_clip', id, entity, p, b.length, +loop, speed, fade, time) !== 0;
+    },
+    stopClip(id, entity, reset) {
+      return scalar('world_stop_clip', id, entity, +reset) !== 0;
+    },
+    skinPoints(id, entity, vertices, output, after) {
+      const count = bytes(vertices).byteLength / 4;
+      if (bytes(output).byteLength < count * 12) throw new Error('skinPoints: output needs three floats per vertex');
+      const [v, o] = data(vertices, output);
+      const ok = scalar('world_skin_points', id, entity, v, count, o, after) !== 0;
+      if (ok) bytes(output).set(u8().subarray(o, o + output.byteLength));
+      return ok;
+    },
+    cacheRead(key) {
+      const text = encoder.encode(key);
+      const p = put(0, text);
+      const record = fn('cache_read', p, text.length);
+      if (!record) return new ArrayBuffer(0);
+      try {
+        return copy(fn('cache_data', record), fn('cache_size', record));
+      } finally {
+        fn('cache_free', record);
+      }
+    },
+    cacheWrite(key, value) {
+      const text = encoder.encode(key);
+      const [p, data] = inputs([text, bytes(value)]);
+      return fn('cache_write', p, text.length, data, bytes(value).length) !== 0;
+    },
+    cacheRemove(key) {
+      const text = encoder.encode(key);
+      const p = put(0, text);
+      return fn('cache_remove', p, text.length) !== 0;
+    },
+    cacheClear: () => fn('cache_clear') !== 0,
+    shapePrepare(vertices, indices, options) {
+      const text = encoder.encode(options);
+      const [v, i, o] = inputs([bytes(vertices), bytes(indices), text]);
+      return fn('shape_prepare', v, bytes(vertices).length / 4, i, bytes(indices).length / 4, o, text.length);
+    },
+    solidPrepare(recipe, options) {
+      const r = encoder.encode(recipe),
+        o = encoder.encode(options);
+      const [a, b] = inputs([r, o]);
+      return fn('solid_prepare', a, r.length, b, o.length);
+    },
+    modelLoad(value, center, fit) {
+      const [p] = data(value);
+      return fn('model_load', p, bytes(value).length, +center, fit);
+    },
+    modelVertices: mesh => copy(fn('model_vertices', mesh), fn('model_vertex_count', mesh) * 44),
+    modelIndices: mesh => copy(fn('model_indices', mesh), fn('model_index_count', mesh) * 4),
+    modelSize: mesh => {
+      const [x, y, z] = dimensions('model_size', mesh, 3, true);
+      return [x, y, z];
+    },
+    // The browser core is single-threaded: the "background" loads settle at once with the same work.
+    modelLoadAsync(value, center, fit) {
+      return settle(() => engine.modelLoad(value, center, fit));
+    },
+    textureLoadAsync(value) {
+      return settle(() => engine.textureLoad(value));
+    },
+    fontLoadAsync(value, depth, chars, weight) {
+      return settle(() => engine.fontLoad(value, depth, chars, weight));
+    },
+    audioLoadAsync(value) {
+      return settle(() => engine.audioLoad(value));
+    },
+    // An older core without it uploads through JS instead (see registerCoreMesh).
+    renderModel: (mesh, texture, shine) => typeof core.engine_render_model === 'function' && fn('render_model', mesh, texture, shine) !== 0,
+    modelTexture: mesh => fn('model_texture', mesh),
+    meshAlias: mesh => fn('mesh_alias', mesh),
+    meshCreate(vertices, indices) {
+      const [v, i] = data(vertices, indices);
+      return fn('mesh_create', v, bytes(vertices).length / 44, i, bytes(indices).length / 4);
+    },
+    pathExtrude(points, counts, depth, evenOdd) {
+      if (counts.some(c => !Number.isInteger(c) || c < 0) || counts.reduce((a, b) => a + b, 0) * 8 > bytes(points).length) throw new Error('pathExtrude: invalid contour counts');
+      const [p, c] = inputs([bytes(points), new Uint8Array(new Uint32Array(counts).buffer)]);
+      const count = fn('path_extrude', p, c, counts.length, depth, +evenOdd);
+      const out = zeroed(0, count * 4);
+      fn('path_extrude_copy', out, count);
+      return copy(out, count * 4);
+    },
+    geometrySmoothNormals(vertices, indices) {
+      const [v, i] = data(vertices, indices);
+      fn('geometry_smooth_normals', v, bytes(vertices).length / 44, i, bytes(indices).length / 4);
+      bytes(vertices).set(u8().subarray(v, v + vertices.byteLength));
+    },
+    geometrySolid(recipe) {
+      const b = encoder.encode(recipe);
+      const p = put(0, b);
+      return geometry(fn('geometry_solid', p, b.length));
+    },
+    geometryOptimize(vertices, indices, ratio, error, lock) {
+      const [v, i] = data(vertices, indices);
+      return geometry(fn('geometry_optimize', v, bytes(vertices).length / 4, i, bytes(indices).length / 4, ratio, error, +lock));
+    },
+    geometryFaceOutward(vertices, indices) {
+      const [v, i] = data(vertices, indices);
+      fn('geometry_face_outward', v, bytes(vertices).length / 44, i, bytes(indices).length / 4);
+      bytes(indices).set(u8().subarray(i, i + indices.byteLength));
+    },
+    geometryPlace(vertices, indices, placement, first, outVertices, vertexOffset, outIndices, indexOffset) {
+      const vbytes = bytes(vertices),
+        ibytes = bytes(indices);
+      if (placement.length < 13 || vertexOffset < 0 || indexOffset < 0 || vertexOffset * 4 + vbytes.length > bytes(outVertices).length || indexOffset * 4 + ibytes.length > bytes(outIndices).length) throw new Error('geometryPlace: invalid output bounds');
+      const [v, i, p, ov, oi] = inputs([vbytes, ibytes, new Uint8Array(new Float32Array(placement).buffer), bytes(outVertices), bytes(outIndices)]);
+      fn('geometry_place', v, vbytes.length / 44, i, ibytes.length / 4, p, first, ov + vertexOffset * 4, oi + indexOffset * 4);
+      bytes(outVertices).set(u8().subarray(ov, ov + outVertices.byteLength));
+      bytes(outIndices).set(u8().subarray(oi, oi + outIndices.byteLength));
+    },
+    textureLoad(value) {
+      const [p] = data(value);
+      return fn('texture_load', p, bytes(value).length);
+    },
+    texturePixels(id) {
+      const [width, height] = dimensions('texture_size', id, 2, false);
+      const pointer = fn('texture_pixels', id);
+      if (!pointer) throw new Error('NayanEngine: unknown world, mesh or texture');
+      return copy(pointer, width * height * 4);
+    },
+    textureSize: id => {
+      const [width, height] = dimensions('texture_size', id, 2, false);
+      return [width, height];
+    },
+    fontLoad(value, depth, chars, weight) {
+      const b = encoder.encode(chars);
+      const [p, c] = inputs([bytes(value), b]);
+      return fn('font_load', p, bytes(value).length, depth, c, b.length, weight);
+    },
+    fontGlyphs(id) {
+      const count = fn('font_glyph_floats', id);
+      const pointer = fn('font_glyphs', id);
+      return [...new Float32Array(memory(), pointer, count), fn('font_cap_height', id)];
+    },
+    loadError: () => string('load_error'),
+    generateBuiltinMeshes() {
+      fn('generate_builtin_meshes');
+    },
+    renderWarmUp() {},
+    renderMeshVertices: mesh => meshCopy(mesh, 'vertices'),
+    renderMeshIndices: mesh => meshCopy(mesh, 'indices'),
+    renderMesh(mesh, vertices, indices, texture, shine) {
+      const [v, i] = data(vertices, indices);
+      fn('render_mesh', mesh, v, bytes(vertices).length / 44, i, bytes(indices).length / 4, texture, shine);
+    },
+    renderFrame(surface, frame, matrices, colors, regions, ranges, count, viewProj, world) {
+      const frameBuffer = buf(frame);
+      const capacity = Math.min(buf(matrices).byteLength / MATRIX_BYTES, buf(colors).byteLength / VEC4_BYTES, buf(regions).byteLength / VEC4_BYTES);
+      const f = put(0, new Uint8Array(frameBuffer));
+      const m = source(1, matrices);
+      const c = source(2, colors);
+      const r = source(3, regions);
+      const buckets = source(4, ranges);
+      const out = buf(viewProj);
+      const vp = put(5, new Uint8Array(out));
+      const result = Number(ex('render_frame')(surface, f, frameBuffer.byteLength / 8, m, c, r, capacity, buckets, ranges.byteLength / 4, count, vp, world >= 0 ? ptr(world) : 0));
+      // Rendering may grow memory: u8() re-creates the view if so.
+      new Uint8Array(out, 0, 64).set(u8().subarray(vp, vp + 64));
+      return result;
+    },
+    renderOverlay(surface, matrices, colors, regions, ranges, count, width, height) {
+      const capacity = Math.min(buf(matrices).byteLength / MATRIX_BYTES, buf(colors).byteLength / VEC4_BYTES, buf(regions).byteLength / VEC4_BYTES);
+      const m = source(1, matrices);
+      const c = source(2, colors);
+      const r = source(3, regions);
+      const buckets = source(4, ranges);
+      ex('render_overlay')(surface, m, c, r, capacity, buckets, ranges.byteLength / 4, count, width, height);
+    },
+    renderError: () => string('render_error'),
+    renderBackend: () => string('render_backend'),
+    drawingCreate: (width, height, ratio) => fn('drawing_create', width, height, ratio),
+    drawingDestroy: document => {
+      fn('drawing_destroy', document);
+    },
+    drawingCommand(document, command) {
+      const text = encoder.encode(command);
+      const input = put(0, text);
+      const pointer = fn('drawing_command', document, input, text.length);
+      if (!pointer) throw new Error('Drawing command failed');
+      try {
+        const memory = u8();
+        const end = memory.indexOf(0, pointer);
+        if (end < 0) throw new Error('Invalid drawing response');
+        return decoder.decode(memory.subarray(pointer, end));
+      } finally {
+        fn('drawing_result_free', pointer);
+      }
+    },
+    audioLoad(value) {
+      const [p] = data(value);
+      return fn('audio_load_wav', p, bytes(value).length);
+    },
+    audioPlay(sound, volume, pan, pitch, loop) {
+      return fn('audio_play', sound, volume, pan, pitch, +loop);
+    },
+    audioStop(voice) {
+      const f = core.engine_audio_stop;
+      f(BigInt(voice));
+    },
+    audioSetVolume(volume) {
+      fn('audio_set_volume', volume);
+    },
+    audioSetMuted(muted) {
+      fn('audio_set_muted', +muted);
+    },
+    audioIsRunning: () => fn('audio_is_running') !== 0,
+    hapticsSupported: () => fn('haptics_supported') !== 0,
+    hapticsPlay(taps, throttle) {
+      const p = put(0, new Uint8Array(new Float32Array(taps).buffer));
+      fn('haptics_play', p, taps.length / 3, +throttle);
+    }
+  };
+  return engine;
+}
+//# sourceMappingURL=BrowserEngine.js.map

package/lib/module/native/EngineBridge.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=EngineBridge.js.map

package/lib/module/native/NativeNayanEngine.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import NativeModule from "./spec/NativeNayanEngine.js";
+
+// The native JSI implementation provides the buffers described by EngineBridge.
+export default NativeModule;
+//# sourceMappingURL=NativeNayanEngine.js.map

package/lib/module/native/NativeNayanEngine.web.js

@@ -0,0 +1,62 @@
+"use strict";
+
+import init, { attach_canvas, can_warm_asset_record, install_asset_storage, read_saved_asset, restore_asset_record } from '../../native/core/build/web/engine_core.js';
+import { IndexedDbCache } from "../assets/IndexedDbCache.web.js";
+import { installAudioOutput } from "../media/output.web.js";
+import { createBrowserEngine } from "./BrowserEngine.js";
+let storage;
+let core;
+let pending;
+let attaching = Promise.resolve();
+export function prepareEngine() {
+  return pending ??= (async () => {
+    core = await init();
+    try {
+      storage = await IndexedDbCache.open();
+      install_asset_storage(storage);
+      await storage.warm(can_warm_asset_record, restore_asset_record);
+    } catch {
+      /* IndexedDB denial is a cache miss, not a failed engine initialization. */
+    }
+    const ready = createBrowserEngine(core);
+    ready.audioIsRunning = installAudioOutput(core);
+    Object.assign(browser, ready);
+  })().catch(error => {
+    pending = undefined;
+    throw error;
+  });
+}
+export async function readSavedAsset(key) {
+  await prepareEngine();
+  const bytes = await read_saved_asset(key);
+  return bytes.length ? bytes.buffer : null;
+}
+export function flushAssetStorage() {
+  return storage ? storage.flush() : Promise.reject(new Error('IndexedDB unavailable'));
+}
+export function clearedAssetStorage() {
+  return storage ? storage.cleared() : Promise.reject(new Error('IndexedDB unavailable'));
+}
+export function attachCanvas(id, canvas) {
+  const attach = attaching.catch(() => {}).then(async () => {
+    await prepareEngine();
+    await attach_canvas(id, canvas);
+  });
+  attaching = attach;
+  return attach;
+}
+export function detachCanvas(id) {
+  const detach = core?.engine_render_detach;
+  detach?.(id);
+}
+
+// SSR-safe: importing binds nothing. Until warm-up every method throws; prepareEngine() then copies
+// the real methods onto this same object, so calls go straight to them (no per-access trap).
+const browser = {};
+const unready = () => {
+  throw new Error('Engine: await warmUpEngine() before creating worlds or procedural meshes on the web');
+};
+// createBrowserEngine touches nothing at creation: its keys list every bridge method.
+for (const key of Object.keys(createBrowserEngine({}))) browser[key] = unready;
+export default browser;
+//# sourceMappingURL=NativeNayanEngine.web.js.map

package/lib/module/native/prepare.js

@@ -0,0 +1,7 @@
+"use strict";
+
+/** Mobile is initialized by native module registration. */
+export function prepareEngine() {
+  return undefined;
+}
+//# sourceMappingURL=prepare.js.map

package/lib/module/native/prepare.web.js

@@ -0,0 +1,17 @@
+"use strict";
+
+import { prepareEngine as prepare } from "./NativeNayanEngine.web.js";
+let requestedPersistence = false;
+export function prepareEngine() {
+  if (!requestedPersistence && typeof navigator !== 'undefined') {
+    requestedPersistence = true;
+    // Browsers own the permission decision. Do not block game startup on a permission prompt.
+    try {
+      void navigator.storage?.persist?.().catch(() => {});
+    } catch {
+      /* Storage can be disabled. */
+    }
+  }
+  return prepare();
+}
+//# sourceMappingURL=prepare.web.js.map

package/lib/module/native/spec/NativeNayanEngine.js

@@ -0,0 +1,17 @@
+"use strict";
+
+/* eslint-disable @typescript-eslint/no-wrapper-object-types -- Codegen requires Object for JSI buffers; EngineBridge supplies their precise TypeScript types. */
+import { TurboModuleRegistry } from 'react-native';
+
+/**
+ * Bridge to the Rust core. Use the `World`, `audio` and `haptics` APIs instead of calling this.
+ *
+ * Worlds are identified by the number `createWorld` returns; entity ids are opaque numbers.
+ * Entities are created and changed with one call each: `spawnDesc` / `setDesc` take a
+ * Float64Array's ArrayBuffer encoding every option (layout in native/core/include/engine_core.h).
+ * Capacity is fixed at creation, so the buffers returned by `get*` alias Rust memory (zero-copy)
+ * and stay valid until `destroyWorld`.
+ */
+
+export default TurboModuleRegistry.get('NativeNayanEngine');
+//# sourceMappingURL=NativeNayanEngine.js.map

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}