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

package/lib/module/world/color.js

@@ -0,0 +1,80 @@
+"use strict";
+
+// Colors: every engine option that takes a color accepts either a linear 0..1 tuple or a CSS color
+// string, so theme colors go straight in: `world.spawn({ color: '#FF4757' })`.
+
+/** A color as an option takes it: `[r, g, b]` / `[r, g, b, a]` (0..1, channels above 1 glow) or a CSS string. */
+
+const HEX = /^#([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+const RGB = /^rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*(?:,\s*([\d.]+%?)\s*)?\)$/i;
+const NAMED = {
+  transparent: [0, 0, 0, 0],
+  black: [0, 0, 0, 1],
+  white: [1, 1, 1, 1],
+  red: [1, 0, 0, 1],
+  green: [0, 128 / 255, 0, 1],
+  blue: [0, 0, 1, 1],
+  yellow: [1, 1, 0, 1],
+  orange: [1, 165 / 255, 0, 1],
+  purple: [128 / 255, 0, 128 / 255, 1],
+  gray: [128 / 255, 128 / 255, 128 / 255, 1],
+  grey: [128 / 255, 128 / 255, 128 / 255, 1]
+};
+
+// Theme colors repeat endlessly; parse each string once.
+const parsed = new Map();
+const PARSED_LIMIT = 1024;
+function parse(css) {
+  const text = css.trim();
+  const named = NAMED[text.toLowerCase()];
+  if (named) return named;
+  const hex = HEX.exec(text);
+  if (hex) {
+    let digits = hex[1];
+    if (digits.length <= 4) digits = [...digits].map(d => d + d).join('');
+    const n = i => parseInt(digits.slice(i, i + 2), 16) / 255;
+    return [n(0), n(2), n(4), digits.length === 8 ? n(6) : 1];
+  }
+  const rgb = RGB.exec(text);
+  if (rgb) {
+    const alpha = rgb[4] === undefined ? 1 : rgb[4].endsWith('%') ? parseFloat(rgb[4]) / 100 : Number(rgb[4]);
+    return [Number(rgb[1]) / 255, Number(rgb[2]) / 255, Number(rgb[3]) / 255, alpha];
+  }
+  throw new Error(`@nayan-ui/engine: "${css}" is not a color (use '#RRGGBB', '#RGB', '#RRGGBBAA', 'rgb(…)', 'rgba(…)' or a 0..1 tuple)`);
+}
+
+/**
+ * Any color input as an `[r, g, b, a]` tuple (0..1), with its alpha multiplied by `alpha`. Use it when
+ * you need the numbers (to brighten, mix or fade a theme color); options take strings directly.
+ *
+ * ```ts
+ * toColor('#FF4757'); // [1, 0.278, 0.341, 1]
+ * toColor('#FF4757', 0.5); // half see-through
+ * ```
+ */
+export function toColor(color, alpha = 1) {
+  let c;
+  if (typeof color === 'string') {
+    let hit = parsed.get(color);
+    if (!hit) {
+      hit = parse(color);
+      if (parsed.size >= PARSED_LIMIT) parsed.clear();
+      parsed.set(color, hit);
+    }
+    c = hit;
+  } else c = color;
+  return [c[0], c[1], c[2], (c[3] ?? 1) * alpha];
+}
+
+/** A color input as a tuple, without copying tuples (the hot path of `spawn`, `set` and `animate`). */
+export function resolveColor(color) {
+  return typeof color === 'string' ? toColor(color) : color;
+}
+
+/** One color input, or a list to pick from, as tuples. */
+export function resolveColors(colors) {
+  if (typeof colors === 'string') return [toColor(colors)];
+  if (typeof colors[0] === 'number') return [colors];
+  return colors.map(resolveColor);
+}
+//# sourceMappingURL=color.js.map

package/lib/module/world/desc.js

@@ -0,0 +1,187 @@
+"use strict";
+
+// Encodes entity options into the flat layout the Rust core decodes (native/core/include/engine_core.h,
+// native/core/src/world/desc.rs). One reusable Float64Array per world: spawning or changing an entity is
+// a single native call, and doubles keep entity ids and layer bits exact.
+import { resolveColor } from "./color.js";
+export const DESC_LEN = 64;
+const FLAG = {
+  MESH: 1 << 0,
+  POSITION: 1 << 1,
+  ROTATION: 1 << 2,
+  SCALE: 1 << 3,
+  COLOR: 1 << 4,
+  VELOCITY: 1 << 5,
+  GROUND_VELOCITY: 1 << 6,
+  SPIN: 1 << 7,
+  BOB: 1 << 8,
+  FOLLOW: 1 << 9,
+  LIFETIME: 1 << 10,
+  PARENT: 1 << 11,
+  PHYSICS: 1 << 12,
+  IMPACT: 1 << 13,
+  ACCELERATION: 1 << 14,
+  PICKABLE: 1 << 15,
+  REGION: 1 << 16
+};
+const SLOT = {
+  FLAGS: 0,
+  MESH: 1,
+  POSITION: 2,
+  ROTATION: 5,
+  SCALE: 9,
+  COLOR: 12,
+  VELOCITY: 16,
+  GROUND_VELOCITY: 19,
+  SPIN: 21,
+  BOB: 24,
+  FOLLOW: 29,
+  LIFETIME: 31,
+  PARENT: 32,
+  PHYSICS: 33,
+  IMPACT: 50,
+  ACCELERATION: 56,
+  PICKABLE: 59,
+  REGION: 60
+};
+const BODY_KIND = {
+  dynamic: 1,
+  kinematic: 2,
+  fixed: 3
+};
+const SHAPE = {
+  ball: 0,
+  box: 1,
+  fromMesh: 2,
+  cylinder: 3,
+  capsule: 4,
+  cone: 5
+};
+function encodePhysics(d, physics) {
+  const p = SLOT.PHYSICS;
+  const shape = physics.shape !== undefined ? SHAPE[physics.shape] : physics.size !== undefined ? SHAPE.box : physics.radius !== undefined ? SHAPE.ball : SHAPE.fromMesh;
+  // Sizes <= 0 tell the core to size the collider from the entity's mesh and scale.
+  const [sx, sy, sz] = shape === SHAPE.box ? physics.size ? [physics.size[0] / 2, physics.size[1] / 2, physics.size[2] / 2] : [0, 0, 0] : [physics.radius ?? 0, (physics.height ?? 0) / 2, 0];
+  d[p] = BODY_KIND[physics.type];
+  d[p + 1] = shape;
+  d[p + 2] = sx;
+  d[p + 3] = sy;
+  d[p + 4] = sz;
+  d[p + 5] = physics.layer ?? 1;
+  d[p + 6] = physics.mask ?? -1; // all layers
+  d[p + 7] = physics.sensor ? 1 : 0;
+  d[p + 8] = physics.friction ?? 0.5;
+  d[p + 9] = physics.bounce ?? 0;
+  d[p + 10] = physics.density ?? 1;
+  d[p + 11] = physics.drag ?? 0;
+  d[p + 12] = physics.angularDrag ?? 0.05;
+  d[p + 13] = physics.gravityScale ?? 1;
+  d[p + 14] = physics.upright ? 1 : 0;
+  d[p + 15] = physics.ccd ? 1 : 0;
+  d[p + 16] = physics.planar ? 1 : 0;
+}
+
+/** Writes `options` into `d`, with the mesh id already resolved. Only the fields present are flagged. */
+export function encode(d, o, mesh) {
+  let flags = 0;
+  if (mesh !== undefined) {
+    flags |= FLAG.MESH;
+    d[SLOT.MESH] = mesh;
+  }
+  if (o.position) {
+    flags |= FLAG.POSITION;
+    d.set(o.position, SLOT.POSITION);
+  }
+  if (o.rotation) {
+    flags |= FLAG.ROTATION;
+    d.set(o.rotation, SLOT.ROTATION);
+  }
+  if (o.scale !== undefined) {
+    flags |= FLAG.SCALE;
+    if (typeof o.scale === 'number') d.fill(o.scale, SLOT.SCALE, SLOT.SCALE + 3);else d.set(o.scale, SLOT.SCALE);
+  }
+  if (o.color) {
+    flags |= FLAG.COLOR;
+    const c = resolveColor(o.color);
+    d[SLOT.COLOR] = c[0];
+    d[SLOT.COLOR + 1] = c[1];
+    d[SLOT.COLOR + 2] = c[2];
+    d[SLOT.COLOR + 3] = c[3] ?? 1;
+  }
+  if (o.velocity) {
+    flags |= FLAG.VELOCITY;
+    d.set(o.velocity, SLOT.VELOCITY);
+  }
+  if (o.groundVelocity) {
+    flags |= FLAG.GROUND_VELOCITY;
+    d.set(o.groundVelocity, SLOT.GROUND_VELOCITY);
+  }
+  if (o.spin) {
+    flags |= FLAG.SPIN;
+    d.set(o.spin, SLOT.SPIN);
+  }
+  if (o.bob !== undefined) {
+    flags |= FLAG.BOB;
+    d.set(o.bob?.amplitude ?? [0, 0, 0], SLOT.BOB);
+    d[SLOT.BOB + 3] = o.bob?.speed ?? 0;
+    d[SLOT.BOB + 4] = o.bob?.phase ?? 0;
+  }
+  if (o.follow !== undefined) {
+    flags |= FLAG.FOLLOW;
+    d[SLOT.FOLLOW] = o.follow?.target ?? -1;
+    d[SLOT.FOLLOW + 1] = o.follow?.speed ?? 0;
+  }
+  if (o.lifetime !== undefined) {
+    flags |= FLAG.LIFETIME;
+    d[SLOT.LIFETIME] = o.lifetime ?? 0;
+  }
+  if (o.parent !== undefined) {
+    flags |= FLAG.PARENT;
+    d[SLOT.PARENT] = o.parent ?? -1;
+  }
+  if (o.physics !== undefined) {
+    flags |= FLAG.PHYSICS;
+    if (o.physics === null) d[SLOT.PHYSICS] = 0;else encodePhysics(d, typeof o.physics === 'string' ? {
+      type: o.physics
+    } : o.physics);
+  }
+  if (o.impact !== undefined) {
+    flags |= FLAG.IMPACT;
+    const i = SLOT.IMPACT;
+    d[i] = o.impact ? 1 : 0;
+    d[i + 1] = o.impact?.sound ?? -1;
+    d[i + 2] = o.impact?.minSpeed ?? 1;
+    d[i + 3] = o.impact?.maxSpeed ?? 10;
+    d[i + 4] = o.impact?.volume ?? 1;
+    d[i + 5] = o.impact?.haptic ?? 0;
+  }
+  if (o.acceleration) {
+    flags |= FLAG.ACCELERATION;
+    d.set(o.acceleration, SLOT.ACCELERATION);
+  }
+  if (o.pickable !== undefined) {
+    flags |= FLAG.PICKABLE;
+    d[SLOT.PICKABLE] = o.pickable ? 1 : 0;
+  }
+  if (o.textureRegion) {
+    flags |= FLAG.REGION;
+    d.set(o.textureRegion, SLOT.REGION);
+  }
+  d[SLOT.FLAGS] = flags;
+}
+
+// ── Animations and bursts (layouts in native/core/include/engine_core.h) ─────────
+
+export const ANIM_HEADER = 12;
+export const ANIM_KEY_LEN = 23;
+export const BURST_LEN = 36;
+export const EASING = {
+  linear: 0,
+  easeIn: 1,
+  easeOut: 2,
+  easeInOut: 3,
+  back: 4,
+  bounce: 5,
+  elastic: 6
+};
+//# sourceMappingURL=desc.js.map