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

package/lib/module/assets/source.js

@@ -0,0 +1,58 @@
+"use strict";
+
+import { Image } from 'react-native';
+// Loads asset bytes for the engine: `require("./file.ext")` assets (resolved by the bundler) or URIs.
+import { assetBytes } from "./AssetBytesCache.js";
+
+/** A `require("./file.ext")` asset, or a URI (http(s):// or file://). */
+
+/** The URI an asset resolves to (a Metro dev-server URL in development, a bundle path in release). */
+export function assetUri(source) {
+  return typeof source === 'number' ? Image.resolveAssetSource(source)?.uri : source;
+}
+
+/** Copies a bundled asset to a local file (Android release bundles them as res/raw resources). */
+async function localAssetUri(source) {
+  let Asset;
+  try {
+    ({
+      Asset
+    } = require('expo-asset'));
+  } catch {
+    throw new Error('loading bundled assets in Android release builds needs expo-asset installed');
+  }
+  const {
+    name,
+    type,
+    hash,
+    uri
+  } = Asset.fromModule(source);
+  // fromModule marks images as "downloaded" with localUri = the drawable name (fine for <Image>, not
+  // for reading bytes); an Asset without dimensions makes expo-asset copy the resource to a file.
+  const asset = await new Asset({
+    name,
+    type,
+    hash,
+    uri
+  }).downloadAsync();
+  if (!asset.localUri?.includes(':')) throw new Error(`couldn't copy the bundled asset ${name}`);
+  return asset.localUri;
+}
+
+/** Fetches an asset's bytes. */
+export async function loadAssetBytes(source) {
+  const uri = assetUri(source);
+  if (!uri) throw new Error("couldn't resolve the asset (is its extension in Metro's assetExts?)");
+  const bytes = await assetBytes(uri, async () => {
+    // Android bundled resources must be copied before their bytes can be read.
+    const url = typeof source === 'number' && !uri.includes(':') ? await localAssetUri(source) : uri;
+    const response = await fetch(url);
+    if (!response.ok && !url.startsWith('file:')) throw new Error(`HTTP ${response.status} for ${uri}`);
+    return response.arrayBuffer();
+  });
+  return {
+    uri,
+    bytes
+  };
+}
+//# sourceMappingURL=source.js.map

package/lib/module/assets/source.web.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import { assetBytes } from "./AssetBytesCache.js";
+/** Browser assets use URLs (including URLs emitted by Vite/webpack imports). */
+
+export function assetUri(source) {
+  return typeof source === 'string' ? source : undefined;
+}
+export async function loadAssetBytes(source) {
+  const uri = assetUri(source);
+  if (!uri) throw new Error('Engine: browser assets need a URL; use an asset import or a public URL');
+  const bytes = await assetBytes(uri, async () => {
+    const response = await fetch(uri);
+    if (!response.ok) throw new Error(`HTTP ${response.status} for ${uri}`);
+    return response.arrayBuffer();
+  });
+  return {
+    uri,
+    bytes
+  };
+}
+//# sourceMappingURL=source.web.js.map

package/lib/module/assets/storage.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export { proceduralStorage, readPersistentAsset, writePersistentAsset, removePersistentAsset, clearPersistentStorage } from "./storage.shared.js";
+//# sourceMappingURL=storage.js.map

package/lib/module/assets/storage.shared.js

@@ -0,0 +1,38 @@
+"use strict";
+
+// Persistence is implemented by the shared Rust core, not an application filesystem dependency.
+import NativeEngine from '../native/NativeNayanEngine';
+export function proceduralStorage(revision) {
+  const native = NativeEngine;
+  return {
+    // The Rust store checksums every record (SHA-256) and rejects any that don't match.
+    verified: true,
+    read(key) {
+      if (typeof native?.cacheRead !== 'function') return null;
+      const data = native.cacheRead(`procedural:${revision}:${key}`);
+      return data.byteLength ? new Uint8Array(data) : null;
+    },
+    write(key, bytes) {
+      if (typeof native?.cacheWrite !== 'function') return;
+      const data = bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength ? bytes.buffer : bytes.slice().buffer;
+      if (!native.cacheWrite(`procedural:${revision}:${key}`, data)) throw new Error(native.loadError() || 'Engine cache write failed');
+    }
+  };
+}
+export async function readPersistentAsset(key) {
+  if (typeof NativeEngine?.cacheRead !== 'function') return null;
+  const bytes = NativeEngine.cacheRead(`source:${key}`);
+  return bytes.byteLength ? bytes : null;
+}
+export async function writePersistentAsset(key, bytes) {
+  // Keep the async loader contract; writes themselves are serialized by the Rust storage lock.
+  if (typeof NativeEngine?.cacheWrite === 'function' && !NativeEngine.cacheWrite(`source:${key}`, bytes)) throw new Error(NativeEngine.loadError() || 'Engine cache write failed');
+}
+export async function removePersistentAsset(key) {
+  if (typeof NativeEngine?.cacheRemove === 'function') NativeEngine.cacheRemove(`source:${key}`);
+}
+export async function clearPersistentStorage() {
+  if (typeof NativeEngine?.cacheClear !== 'function') throw new Error('Rebuild the app with engine cache support');
+  if (!NativeEngine.cacheClear()) throw new Error(NativeEngine.loadError() || 'Engine cache clear failed');
+}
+//# sourceMappingURL=storage.shared.js.map

package/lib/module/assets/storage.web.js

@@ -0,0 +1,38 @@
+"use strict";
+
+import { clearedAssetStorage, flushAssetStorage, prepareEngine, readSavedAsset } from "../native/NativeNayanEngine.web.js";
+// Browser platform I/O is asynchronous; Rust still owns record validation and cache policy.
+
+import * as shared from "./storage.shared.js";
+export function proceduralStorage(revision) {
+  const storage = shared.proceduralStorage(revision);
+  if (!storage) return;
+  return {
+    verified: storage.verified,
+    read: storage.read,
+    write(key, bytes) {
+      storage.write(key, bytes);
+      return flushAssetStorage();
+    }
+  };
+}
+export async function readPersistentAsset(key) {
+  return readSavedAsset(`source:${key}`);
+}
+export async function writePersistentAsset(key, bytes) {
+  const writing = shared.writePersistentAsset(key, bytes);
+  const saved = flushAssetStorage();
+  await Promise.all([writing, saved]);
+}
+export async function removePersistentAsset(key) {
+  const removing = shared.removePersistentAsset(key);
+  const saved = flushAssetStorage();
+  await Promise.all([removing, saved]);
+}
+export async function clearPersistentStorage() {
+  await prepareEngine();
+  const clearing = shared.clearPersistentStorage();
+  const saved = clearedAssetStorage();
+  await Promise.all([clearing, saved]);
+}
+//# sourceMappingURL=storage.web.js.map

package/lib/module/assets/surface.js

@@ -0,0 +1,47 @@
+"use strict";
+
+import { recolor, smoothNormals } from "./shape.js";
+/**
+ * Samples an arbitrary surface on u/v in [0,1]. Winding follows dP/du cross dP/dv.
+ * Use for terrain, cloth, wings, twisted ribbons and custom mathematical forms. Wrapped edges
+ * retain texture seams; coincident pole vertices share normals. Degenerate triangles are omitted.
+ */
+export function parametricSurface(sample, options = {}) {
+  const nu = options.uSegments ?? 32,
+    nv = options.vSegments ?? 16;
+  if (![nu, nv].every(n => Number.isInteger(n) && n >= 1 && n <= 1024) || (nu + 1) * (nv + 1) > 1_000_000) throw new Error('parametricSurface: invalid segments or surface exceeds one million vertices');
+  const vertices = new Float32Array((nu + 1) * (nv + 1) * 11);
+  for (let y = 0; y <= nv; y++) for (let x = 0; x <= nu; x++) {
+    const u = x / nu,
+      v = y / nv;
+    const p = sample(options.wrapU && x === nu ? 0 : u, options.wrapV && y === nv ? 0 : v);
+    if (p.some(c => !Number.isFinite(c))) throw new Error('parametricSurface: sample returned a non-finite position');
+    vertices.set([p[0], p[1], p[2], 0, 1, 0, 1, 1, 1, u, v], (y * (nu + 1) + x) * 11);
+  }
+  const indices = [];
+  const triangle = (a, b, c) => {
+    const v = vertices;
+    const oa = a * 11,
+      ob = b * 11,
+      oc = c * 11;
+    const x1 = v[ob] - v[oa],
+      y1 = v[ob + 1] - v[oa + 1],
+      z1 = v[ob + 2] - v[oa + 2];
+    const x2 = v[oc] - v[oa],
+      y2 = v[oc + 1] - v[oa + 1],
+      z2 = v[oc + 2] - v[oa + 2];
+    if (Math.hypot(y1 * z2 - z1 * y2, z1 * x2 - x1 * z2, x1 * y2 - y1 * x2) > 0) indices.push(a, b, c);
+  };
+  for (let y = 0; y < nv; y++) for (let x = 0; x < nu; x++) {
+    const a = y * (nu + 1) + x,
+      b = a + nu + 1;
+    triangle(a, a + 1, b);
+    triangle(a + 1, b + 1, b);
+  }
+  const geometry = smoothNormals({
+    vertices,
+    indices: new Uint32Array(indices)
+  });
+  return options.color ? recolor(geometry, typeof options.color === 'function' ? options.color : () => options.color) : geometry;
+}
+//# sourceMappingURL=surface.js.map

package/lib/module/assets/texture.js

@@ -0,0 +1,69 @@
+"use strict";
+
+import NativeEngine from '../native/NativeNayanEngine';
+// Textures: PNG / JPEG images, decoded by the Rust core, drawn on built-in shapes or models.
+import { meshInfo } from "../render/meshes.js";
+import { AssetLoader } from "./AssetLoader.js";
+import { registerCoreMesh } from "./model.js";
+
+/** A loaded image. Pass it as an entity's `texture`. */
+
+const loader = new AssetLoader('loadTexture');
+
+/**
+ * Initializes the engine automatically. Loads a PNG or JPEG once (up to 4096 x 4096). Use it on any entity: `{ mesh: "cube", texture }`.
+ * The entity's `color` tints it; `textureRegion` shows part of it (sprite sheets, card atlases).
+ *
+ * ```ts
+ * const crate = await loadTexture(require("./assets/crate.png"));
+ * world.spawn({ mesh: "cube", texture: crate });
+ * ```
+ */
+export function loadTexture(source) {
+  return loader.load(source, (native, bytes) => {
+    const finish = id => {
+      if (id < 0) throw new Error(native.loadError() || 'not a PNG or JPEG image');
+      const [width, height] = native.textureSize(id);
+      return {
+        id,
+        width,
+        height
+      };
+    };
+    // Decoded on a background native thread where the app's build supports it.
+    return typeof native.textureLoadAsync === 'function' ? native.textureLoadAsync(bytes).then(finish) : finish(native.textureLoad(bytes));
+  });
+}
+
+/** Pixels of a texture id (aliasing native memory), for the renderer. */
+export function textureImage(id) {
+  const [width, height] = NativeEngine.textureSize(id);
+  return {
+    width,
+    height,
+    pixels: new Uint8Array(NativeEngine.texturePixels(id))
+  };
+}
+const variants = new Map();
+
+/**
+ * The mesh id that draws `mesh`'s geometry with `texture`: a textured variant made on first use
+ * (it shares the geometry, colliders and picking of the original).
+ */
+export function texturedMesh(mesh, texture) {
+  const key = `${mesh}:${texture.id}`;
+  let id = variants.get(key);
+  if (id === undefined) {
+    const base = meshInfo(mesh);
+    if (!base) throw new Error('texture: this mesh has nothing to draw');
+    id = NativeEngine.meshAlias(mesh);
+    if (id < 0) throw new Error(`texture: ${NativeEngine.loadError()}`);
+    registerCoreMesh(id, {
+      texture: texture.id,
+      shine: base.shine
+    }, () => base.geometry);
+    variants.set(key, id);
+  }
+  return id;
+}
+//# sourceMappingURL=texture.js.map

package/lib/module/drawing/DrawingCanvas.js

@@ -0,0 +1,38 @@
+"use strict";
+
+import { memo, useCallback } from 'react';
+import { processColor } from 'react-native';
+import { EngineSurface } from '../render/host';
+import { jsx as _jsx } from "react/jsx-runtime";
+/** Native coalesced finger/Pencil/stylus input, with pinch zoom and pan, bypasses the JS thread. */
+export const DrawingCanvas = /*#__PURE__*/memo(function DrawingCanvas({
+  document,
+  mode = 'draw',
+  background = '#ffffff',
+  active = true,
+  onChange,
+  onError,
+  style
+}) {
+  const color = processColor(background);
+  const change = useCallback(event => {
+    if (!active || document.isDisposed || event.nativeEvent.documentId !== document.id) return;
+    try {
+      onChange?.(JSON.parse(event.nativeEvent.state));
+    } catch (failure) {
+      onError?.(failure instanceof Error ? failure : new Error(String(failure)));
+    }
+  }, [onChange, onError, active, document]);
+  return /*#__PURE__*/_jsx(EngineSurface, {
+    onDrawingChange: onChange ? change : undefined,
+    surfaceId: document.id,
+    drawingId: active ? document.id : -1,
+    drawingMode: mode === 'draw' ? 0 : mode === 'move' ? 1 : 2,
+    drawingBackground: typeof color === 'number' ? color & 0xffffff : 0xffffff,
+    style: {
+      flex: 1,
+      ...style
+    }
+  });
+});
+//# sourceMappingURL=DrawingCanvas.js.map

package/lib/module/drawing/DrawingCanvas.web.js

@@ -0,0 +1,206 @@
+"use strict";
+
+import { memo, useEffect, useRef, useState } from 'react';
+import { attachCanvas, detachCanvas } from "../native/NativeNayanEngine.web.js";
+import { warmUpEngine } from "../render/meshes.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+export const DrawingCanvas = /*#__PURE__*/memo(function DrawingCanvas({
+  document: drawing,
+  mode = 'draw',
+  background = '#ffffff',
+  active = true,
+  onError,
+  onChange,
+  style
+}) {
+  const ref = useRef(null);
+  const [error, setError] = useState('');
+  const live = useRef({
+    mode,
+    background,
+    active,
+    onError,
+    onChange
+  });
+  live.current = {
+    mode,
+    background,
+    active,
+    onError,
+    onChange
+  };
+  useEffect(() => {
+    const canvas = ref.current;
+    setError('');
+    let alive = true,
+      ready = false,
+      raf = 0,
+      drawingPointer = null;
+    const pointers = new Map();
+    let lastEvent = 0;
+    let oldDistance = 0,
+      oldCenter = [0, 0];
+    // Measure layout once per event: coalesced samples reuse the event's rectangle.
+    const coords = (e, r = canvas.getBoundingClientRect()) => ({
+      x: e.clientX - r.left,
+      y: e.clientY - r.top,
+      pen: e.pointerType === 'pen'
+    });
+    const cancel = () => {
+      if (drawingPointer !== null && !drawing.isDisposed) drawing.cancel();
+      drawingPointer = null;
+      pointers.clear();
+      oldDistance = 0;
+    };
+    const down = e => {
+      if (!ready || drawing.isDisposed || !live.current.active || e.button !== 0) return;
+      if ([...pointers.values()].some(p => p.pen) && e.pointerType !== 'pen') return;
+      e.preventDefault();
+      canvas.focus();
+      canvas.setPointerCapture(e.pointerId);
+      const p = coords(e);
+      pointers.set(e.pointerId, p);
+      if (pointers.size === 1 && live.current.mode === 'draw') {
+        drawingPointer = e.pointerId;
+        drawing.input(0, p.x, p.y, p.pen ? e.pressure : 1);
+      } else {
+        if (drawingPointer !== null && !drawing.isDisposed) drawing.cancel();
+        drawingPointer = null;
+        oldDistance = 0;
+      }
+    };
+    const move = e => {
+      if (!live.current.active || drawing.isDisposed) return;
+      const previous = pointers.get(e.pointerId);
+      if (!previous) return;
+      const rect = canvas.getBoundingClientRect();
+      const p = coords(e, rect);
+      pointers.set(e.pointerId, p);
+      if (e.pointerId === drawingPointer) {
+        const coalesced = e.getCoalescedEvents?.();
+        for (const sample of coalesced?.length ? coalesced : [e]) {
+          const v = coords(sample, rect);
+          drawing.input(1, v.x, v.y, v.pen ? sample.pressure : 1);
+        }
+      } else if (pointers.size > 1) {
+        const points = [...pointers.values()];
+        const a = points[0],
+          b = points[1];
+        const distance = Math.hypot(a.x - b.x, a.y - b.y);
+        const center = [(a.x + b.x) / 2, (a.y + b.y) / 2];
+        if (oldDistance > 0) drawing.transform(center[0] - oldCenter[0], center[1] - oldCenter[1], distance / oldDistance);
+        oldDistance = distance;
+        oldCenter = center;
+      } else drawing.transform(p.x - previous.x, p.y - previous.y);
+    };
+    const up = e => {
+      if (drawingPointer === e.pointerId && !drawing.isDisposed) {
+        const p = coords(e);
+        drawing.input(e.type === 'pointercancel' ? 3 : 2, p.x, p.y, p.pen ? e.pressure : 1);
+        drawingPointer = null;
+      }
+      pointers.delete(e.pointerId);
+      oldDistance = 0;
+    };
+    const key = e => {
+      if (drawing.isDisposed || !live.current.active || !(e.ctrlKey || e.metaKey) || live.current.mode === 'view') return;
+      if (e.key.toLowerCase() === 'z') {
+        e.preventDefault();
+        e.shiftKey ? drawing.redo() : drawing.undo();
+      } else if (e.key.toLowerCase() === 'y') {
+        e.preventDefault();
+        drawing.redo();
+      }
+    };
+    const wheel = e => {
+      if (!ready || drawing.isDisposed || !live.current.active) return;
+      e.preventDefault();
+      e.ctrlKey || e.metaKey ? drawing.transform(0, 0, Math.exp(-e.deltaY * 0.003)) : drawing.transform(-e.deltaX, -e.deltaY);
+    };
+    const visibility = () => {
+      if (document.hidden) cancel();
+    };
+    const render = () => {
+      if (!alive) return;
+      if (ready && !drawing.isDisposed && live.current.active && !document.hidden) {
+        const bounds = canvas.getBoundingClientRect();
+        const ratio = Math.min(window.devicePixelRatio || 1, 3);
+        const w = Math.max(1, Math.round(bounds.width * ratio)),
+          h = Math.max(1, Math.round(bounds.height * ratio));
+        if (canvas.width !== w || canvas.height !== h) {
+          canvas.width = w;
+          canvas.height = h;
+        }
+        try {
+          drawing.present(bounds.width, bounds.height, live.current.background, ratio);
+          if (live.current.onChange && performance.now() - lastEvent >= 100) {
+            lastEvent = performance.now();
+            const state = drawing.readChange();
+            if (state) live.current.onChange(state);
+          }
+        } catch (failure) {
+          ready = false;
+          const error = failure instanceof Error ? failure : new Error(String(failure));
+          live.current.onError?.(error);
+          setError(error.message);
+        }
+      }
+      raf = requestAnimationFrame(render);
+    };
+    void warmUpEngine().then(() => alive ? attachCanvas(drawing.id, canvas) : undefined).then(() => {
+      if (alive && !drawing.isDisposed) {
+        drawing.invalidateView();
+        ready = true;
+      } else detachCanvas(drawing.id);
+    }).catch(failure => {
+      if (!alive) return;
+      const error = failure instanceof Error ? failure : new Error(String(failure));
+      live.current.onError?.(error);
+      setError(error.message);
+    });
+    canvas.addEventListener('pointerdown', down);
+    canvas.addEventListener('pointermove', move);
+    canvas.addEventListener('pointerup', up);
+    canvas.addEventListener('pointercancel', up);
+    canvas.addEventListener('lostpointercapture', up);
+    canvas.addEventListener('keydown', key);
+    canvas.addEventListener('wheel', wheel, {
+      passive: false
+    });
+    window.addEventListener('blur', cancel);
+    document.addEventListener('visibilitychange', visibility);
+    raf = requestAnimationFrame(render);
+    return () => {
+      alive = false;
+      cancelAnimationFrame(raf);
+      cancel();
+      detachCanvas(drawing.id);
+      canvas.removeEventListener('pointerdown', down);
+      canvas.removeEventListener('pointermove', move);
+      canvas.removeEventListener('pointerup', up);
+      canvas.removeEventListener('pointercancel', up);
+      canvas.removeEventListener('lostpointercapture', up);
+      canvas.removeEventListener('keydown', key);
+      canvas.removeEventListener('wheel', wheel);
+      window.removeEventListener('blur', cancel);
+      document.removeEventListener('visibilitychange', visibility);
+    };
+  }, [drawing]);
+  return /*#__PURE__*/_jsx("canvas", {
+    ref: ref,
+    tabIndex: 0,
+    "aria-label": error ? `Drawing unavailable: ${error}` : 'Drawing canvas',
+    title: error || undefined,
+    style: {
+      display: 'block',
+      flex: 1,
+      width: '100%',
+      height: '100%',
+      minHeight: 0,
+      touchAction: 'none',
+      outline: 'none',
+      ...style
+    }
+  });
+});
+//# sourceMappingURL=DrawingCanvas.web.js.map