@nayan-ui/engine 1.0.0-beta.4 → 1.0.0-beta.6

package/native/cpp/NayanEngineModule.cpp

@@ -186,6 +186,7 @@ NayanEngineModule::NayanEngineModule(std::shared_ptr<CallInvoker> jsInvoker)
 
 // Worlds are freed when the module and every buffer aliasing them are gone.
 NayanEngineModule::~NayanEngineModule() {
+  engine_speech_shutdown();
   {
     std::lock_guard<std::mutex> lock(framesMutex);
     liveModules.erase(this);
@@ -564,6 +565,20 @@ jsi::Array NayanEngineModule::modelSize(jsi::Runtime &rt, double mesh) {
   return jsi::Array::createWithElements(rt, size[0], size[1], size[2]);
 }
 
+jsi::Array NayanEngineModule::modelBake(jsi::Runtime &rt, double mesh, jsi::String spec) {
+  const auto json = spec.utf8(rt);
+  float out[4] = {0, 0, 0, 0};
+  if (!engine_model_bake(id(mesh), reinterpret_cast<const uint8_t *>(json.data()), json.size(), out)) {
+    return jsi::Array(rt, 0);
+  }
+  return jsi::Array::createWithElements(rt, out[0], out[1], out[2], out[3]);
+}
+
+bool NayanEngineModule::bakeKept(jsi::Runtime &rt, jsi::String key) {
+  const auto k = key.utf8(rt);
+  return engine_bake_kept(reinterpret_cast<const uint8_t *>(k.data()), k.size()) != 0;
+}
+
 double NayanEngineModule::modelTexture(jsi::Runtime &, double mesh) {
   return engine_model_texture(id(mesh));
 }
@@ -838,6 +853,19 @@ void NayanEngineModule::renderOverlay(
       static_cast<float>(width), static_cast<float>(height));
 }
 
+void NayanEngineModule::renderBackdrop(
+    jsi::Runtime &rt, double surface, jsi::Object matrices, jsi::Object colors, jsi::Object regions, jsi::Object ranges, double count) {
+  jsi::ArrayBuffer m = fileData(rt, matrices, "renderBackdrop");
+  jsi::ArrayBuffer c = fileData(rt, colors, "renderBackdrop");
+  jsi::ArrayBuffer g = fileData(rt, regions, "renderBackdrop");
+  jsi::ArrayBuffer r = fileData(rt, ranges, "renderBackdrop");
+  size_t capacity = std::min({m.size(rt) / (16 * sizeof(float)), c.size(rt) / (4 * sizeof(float)), g.size(rt) / (4 * sizeof(float))});
+  size_t n = count > 0 ? std::min(static_cast<size_t>(count), capacity) : 0;
+  engine_render_backdrop(
+      static_cast<int32_t>(surface), reinterpret_cast<const float *>(m.data(rt)), reinterpret_cast<const float *>(c.data(rt)),
+      reinterpret_cast<const float *>(g.data(rt)), capacity, reinterpret_cast<const uint32_t *>(r.data(rt)), r.size(rt) / sizeof(uint32_t), n);
+}
+
 jsi::String NayanEngineModule::renderError(jsi::Runtime &rt) {
   std::string message(engine_render_error(nullptr, 0) + 1, '\0');
   message.resize(engine_render_error(message.data(), message.size()));
@@ -901,6 +929,97 @@ bool NayanEngineModule::audioIsRunning(jsi::Runtime &) {
   return engine_audio_is_running() != 0;
 }
 
+void NayanEngineModule::audioRelease(jsi::Runtime &, double sound) {
+  engine_audio_release(id(sound));
+}
+
+double NayanEngineModule::audioDuration(jsi::Runtime &, double sound) {
+  return engine_audio_duration(id(sound));
+}
+
+jsi::Object NayanEngineModule::audioLevels(jsi::Runtime &rt, double sound, double perSecond) {
+  const uint32_t s = id(sound);
+  const size_t count = engine_audio_levels(s, static_cast<float>(perSecond), nullptr, 0);
+  auto buffer = std::make_shared<OwnedBuffer>(count * sizeof(float));
+  engine_audio_levels(s, static_cast<float>(perSecond), reinterpret_cast<float *>(buffer->data()), count);
+  return jsi::ArrayBuffer(rt, buffer);
+}
+
+namespace {
+// A pending microphone prompt: the promise it resolves, owned until the answer arrives.
+using MicPromise = AsyncPromise<bool>;
+
+#ifndef __ANDROID__
+void micAnswered(void *context, int32_t granted) {
+  std::unique_ptr<std::shared_ptr<MicPromise>> promise(static_cast<std::shared_ptr<MicPromise> *>(context));
+  (*promise)->resolve(granted != 0);
+}
+#endif
+
+#ifdef __ANDROID__
+facebook::jni::alias_ref<facebook::jni::JClass> microphoneClass() {
+  static auto cls = facebook::jni::findClassStatic("com/nayanui/engine/EngineMicrophone");
+  return cls;
+}
+#endif
+} // namespace
+
+double NayanEngineModule::micPermission(jsi::Runtime &) {
+#ifdef __ANDROID__
+  try {
+    static const auto permission = microphoneClass()->getStaticMethod<jint()>("permission");
+    return permission(microphoneClass());
+  } catch (...) {
+    return 0;
+  }
+#else
+  return engine_audio_mic_permission();
+#endif
+}
+
+jsi::Value NayanEngineModule::micRequestPermission(jsi::Runtime &rt) {
+  auto promise = std::make_shared<MicPromise>(rt, jsInvoker_);
+  jsi::Value result(rt, promise->get(rt));
+#ifdef __ANDROID__
+  // Java answers through nativePermissionResult(token, granted) below, which frees the token.
+  auto *token = new std::shared_ptr<MicPromise>(promise);
+  try {
+    static const auto request = microphoneClass()->getStaticMethod<void(jlong)>("request");
+    request(microphoneClass(), static_cast<jlong>(reinterpret_cast<intptr_t>(token)));
+  } catch (...) {
+    delete token;
+    promise->resolve(false);
+  }
+#else
+  engine_audio_mic_request(micAnswered, new std::shared_ptr<MicPromise>(promise));
+#endif
+  return result;
+}
+
+bool NayanEngineModule::micStart(jsi::Runtime &, double maxSeconds) {
+  return engine_audio_mic_start(static_cast<float>(maxSeconds)) != 0;
+}
+
+void NayanEngineModule::micStop(jsi::Runtime &) {
+  engine_audio_mic_stop();
+}
+
+double NayanEngineModule::micState(jsi::Runtime &) {
+  return engine_audio_mic_state();
+}
+
+double NayanEngineModule::micLevel(jsi::Runtime &) {
+  return engine_audio_mic_level();
+}
+
+double NayanEngineModule::micHeld(jsi::Runtime &) {
+  return engine_audio_mic_held();
+}
+
+double NayanEngineModule::micTake(jsi::Runtime &, double seconds, double skipEnd) {
+  return engine_audio_mic_take(static_cast<float>(seconds), static_cast<float>(skipEnd));
+}
+
 bool NayanEngineModule::hapticsSupported(jsi::Runtime &) {
   return engine_haptics_supported() != 0;
 }
@@ -915,6 +1034,158 @@ void NayanEngineModule::hapticsPlay(jsi::Runtime &rt, jsi::Array taps, bool thro
   engine_haptics_play(values.data(), static_cast<uint32_t>(n / 3), throttle ? 1 : 0);
 }
 
+// Procedural worlds. Handles are the core's own (u32, 0 = none); no JSI object owns them.
+
+namespace {
+
+uint32_t handle(double v) {
+  return (v >= 0 && v <= static_cast<double>(UINT32_MAX)) ? static_cast<uint32_t>(v) : 0;
+}
+
+const uint8_t *utf8(const std::string &text) {
+  return reinterpret_cast<const uint8_t *>(text.data());
+}
+
+/** A core function's f64 output (two calls: size, then copy) as an owned ArrayBuffer. */
+jsi::Object doubles(jsi::Runtime &rt, const std::function<size_t(double *, size_t)> &read) {
+  const size_t count = read(nullptr, 0);
+  auto out = std::make_shared<OwnedBuffer>(count * sizeof(double));
+  if (count > 0 && read(reinterpret_cast<double *>(out->data()), count) != count) {
+    throw jsi::JSError(rt, "NayanEngine worldgen: output changed while reading");
+  }
+  return jsi::ArrayBuffer(rt, std::move(out));
+}
+
+std::string text(const std::function<size_t(uint8_t *, size_t)> &read) {
+  std::string out(read(nullptr, 0), '\0');
+  if (!out.empty()) read(reinterpret_cast<uint8_t *>(out.data()), out.size() + 1);
+  return out;
+}
+
+} // namespace
+
+double NayanEngineModule::worldgenBuild(jsi::Runtime &rt, jsi::String recipe, jsi::String key, bool prepareTerrain) {
+  const auto r = recipe.utf8(rt), k = key.utf8(rt);
+  return engine_worldgen_build(utf8(r), r.size(), utf8(k), k.size(), prepareTerrain ? 1 : 0);
+}
+
+jsi::Value NayanEngineModule::worldgenBuildAsync(jsi::Runtime &rt, jsi::String recipe, jsi::String key, bool prepareTerrain) {
+  auto r = std::make_shared<std::string>(recipe.utf8(rt));
+  auto k = std::make_shared<std::string>(key.utf8(rt));
+  return runInBackground(rt, jsInvoker_, [r, k, prepareTerrain]() {
+    return static_cast<double>(engine_worldgen_build(utf8(*r), r->size(), utf8(*k), k->size(), prepareTerrain ? 1 : 0));
+  });
+}
+
+jsi::String NayanEngineModule::worldgenError(jsi::Runtime &rt) {
+  return jsi::String::createFromUtf8(rt, text([](uint8_t *out, size_t cap) { return engine_worldgen_error(out, cap); }));
+}
+
+bool NayanEngineModule::worldgenKept(jsi::Runtime &rt, jsi::String key) {
+  const auto k = key.utf8(rt);
+  return engine_worldgen_kept(utf8(k), k.size()) != 0;
+}
+
+void NayanEngineModule::worldgenFree(jsi::Runtime &, double world) {
+  engine_worldgen_free(handle(world));
+}
+
+jsi::String NayanEngineModule::worldgenInfo(jsi::Runtime &rt, double world) {
+  const uint32_t w = handle(world);
+  return jsi::String::createFromUtf8(rt, text([w](uint8_t *out, size_t cap) { return engine_worldgen_info(w, out, cap); }));
+}
+
+jsi::Object NayanEngineModule::worldgenLayer(jsi::Runtime &rt, double world, jsi::String name) {
+  const uint32_t w = handle(world);
+  const auto n = name.utf8(rt);
+  return doubles(rt, [w, &n](double *out, size_t cap) { return engine_worldgen_layer(w, utf8(n), n.size(), out, cap); });
+}
+
+jsi::Object NayanEngineModule::worldgenReachable(jsi::Runtime &rt, double world) {
+  const uint32_t w = handle(world);
+  return doubles(rt, [w](double *out, size_t cap) { return engine_worldgen_reachable(w, out, cap); });
+}
+
+jsi::Object NayanEngineModule::worldgenOverview(jsi::Runtime &rt, double world) {
+  const uint32_t w = handle(world);
+  const size_t count = engine_worldgen_overview(w, nullptr, 0);
+  auto out = std::make_shared<OwnedBuffer>(count);
+  if (count > 0) engine_worldgen_overview(w, out->data(), count);
+  return jsi::ArrayBuffer(rt, std::move(out));
+}
+
+bool NayanEngineModule::worldgenPick(jsi::Runtime &, double world, double run) {
+  return engine_worldgen_pick(handle(world), handle(run)) != 0;
+}
+
+jsi::Object NayanEngineModule::worldgenTerrain(jsi::Runtime &rt, double world, double material) {
+  return geometryResult(rt, engine_worldgen_terrain(handle(world), handle(material)));
+}
+
+jsi::Object NayanEngineModule::worldgenMesh(jsi::Runtime &rt, jsi::String recipe) {
+  const auto r = recipe.utf8(rt);
+  return geometryResult(rt, engine_worldgen_mesh(utf8(r), r.size()));
+}
+
+bool NayanEngineModule::worldgenPaint(jsi::Runtime &rt, jsi::Object vertices, jsi::String recipe) {
+  jsi::ArrayBuffer v = fileData(rt, vertices, "worldgenPaint");
+  if (v.size(rt) % (11 * sizeof(float)) != 0) {
+    throw jsi::JSError(rt, "NayanEngine.worldgenPaint: incomplete vertices");
+  }
+  const auto r = recipe.utf8(rt);
+  return engine_worldgen_paint(reinterpret_cast<float *>(v.data(rt)), v.size(rt) / (11 * sizeof(float)), utf8(r), r.size()) != 0;
+}
+
+double NayanEngineModule::worldgenGround(jsi::Runtime &, double world, double x, double z) {
+  return engine_worldgen_ground(handle(world), x, z);
+}
+
+double NayanEngineModule::worldgenSurface(jsi::Runtime &, double world, double x, double z) {
+  return engine_worldgen_surface(handle(world), x, z);
+}
+
+double NayanEngineModule::worldgenPlatform(jsi::Runtime &, double world, double x, double z) {
+  return engine_worldgen_platform(handle(world), x, z);
+}
+
+bool NayanEngineModule::worldgenWalkable(jsi::Runtime &, double world, double x, double z, double radius) {
+  return engine_worldgen_walkable(handle(world), x, z, radius) != 0;
+}
+
+double NayanEngineModule::worldgenClearance(jsi::Runtime &, double world, double x, double z, double radius) {
+  return engine_worldgen_clearance(handle(world), x, z, radius);
+}
+
+double NayanEngineModule::worldgenSolidClearance(jsi::Runtime &, double world, double x, double z, double radius, double bottom, double top) {
+  return engine_worldgen_solid_clearance(handle(world), x, z, radius, bottom, top);
+}
+
+double NayanEngineModule::worldgenFieldIndex(jsi::Runtime &rt, double world, jsi::String name) {
+  const auto n = name.utf8(rt);
+  return engine_worldgen_field_index(handle(world), utf8(n), n.size());
+}
+
+double NayanEngineModule::worldgenField(jsi::Runtime &, double world, double field, double x, double z) {
+  return engine_worldgen_field(handle(world), handle(field), x, z);
+}
+
+jsi::Array NayanEngineModule::worldgenTilt(jsi::Runtime &rt, double world, double x, double z, double yaw) {
+  double q[4] = {0, 0, 0, 1};
+  engine_worldgen_tilt(handle(world), x, z, yaw, q);
+  return jsi::Array::createWithElements(rt, q[0], q[1], q[2], q[3]);
+}
+
+bool NayanEngineModule::worldgenSight(jsi::Runtime &, double world, double ax, double az, double bx, double bz, double radius, double step, double rise) {
+  return engine_worldgen_sight(handle(world), ax, az, bx, bz, radius, step, rise) != 0;
+}
+
+jsi::Array NayanEngineModule::worldgenMove(jsi::Runtime &rt, double world, double x, double z, double dx, double dz, double radius, jsi::Object bodies) {
+  auto list = fileData(rt, bodies, "worldgenMove");
+  double point[2] = {x, z};
+  engine_worldgen_move(handle(world), point, dx, dz, radius, reinterpret_cast<const double *>(list.data(rt)), list.size(rt) / (3 * sizeof(double)));
+  return jsi::Array::createWithElements(rt, point[0], point[1]);
+}
+
 } // namespace facebook::react
 
 #ifdef __ANDROID__
@@ -963,6 +1234,13 @@ Java_com_nayanui_engine_EngineSurfaceView_nativeAttach(JNIEnv *env, jclass, jint
   return engine_render_attach(surface, window, static_cast<uint32_t>(width), static_cast<uint32_t>(height)) == 1 ? JNI_TRUE : JNI_FALSE;
 }
 
+/** EngineMicrophone's answer to micRequestPermission: resolves the promise and frees its token. */
+extern "C" JNIEXPORT void JNICALL Java_com_nayanui_engine_EngineMicrophone_nativePermissionResult(JNIEnv *, jclass, jlong token, jboolean granted) {
+  std::unique_ptr<std::shared_ptr<facebook::react::AsyncPromise<bool>>> promise(
+      reinterpret_cast<std::shared_ptr<facebook::react::AsyncPromise<bool>> *>(static_cast<intptr_t>(token)));
+  if (promise) (*promise)->resolve(granted == JNI_TRUE);
+}
+
 extern "C" JNIEXPORT void JNICALL Java_com_nayanui_engine_EngineSurfaceView_nativeDetach(JNIEnv *, jclass, jint surface) {
   releaseWindow(surface);
 }
@@ -996,3 +1274,21 @@ extern "C" JNIEXPORT jbyteArray JNICALL Java_com_nayanui_engine_EngineSurfaceVie
   return result;
 }
 #endif
+
+namespace {
+void speechAnswered(void *context, const uint8_t *data, size_t len) {
+  using Promise = facebook::react::AsyncPromise<std::string>;
+  std::unique_ptr<std::shared_ptr<Promise>> promise(static_cast<std::shared_ptr<Promise> *>(context));
+  (*promise)->resolve(std::string(reinterpret_cast<const char *>(data), len));
+}
+}
+namespace facebook::react {
+jsi::Value NayanEngineModule::speechRequest(jsi::Runtime &rt, jsi::String command) {
+  auto promise = std::make_shared<AsyncPromise<std::string>>(rt, jsInvoker_);
+  jsi::Value result(rt, promise->get(rt));
+  const std::string text = command.utf8(rt);
+  engine_speech_request(reinterpret_cast<const uint8_t *>(text.data()), text.size(), speechAnswered,
+      new std::shared_ptr<AsyncPromise<std::string>>(promise));
+  return result;
+}
+}

package/native/cpp/NayanEngineModule.h

@@ -15,6 +15,8 @@ class NayanEngineModule : public NativeNayanEngineCxxSpec<NayanEngineModule> {
   explicit NayanEngineModule(std::shared_ptr<CallInvoker> jsInvoker);
   ~NayanEngineModule();
 
+  jsi::Value speechRequest(jsi::Runtime &rt, jsi::String command);
+
   double createWorld(jsi::Runtime &rt, double capacity);
   void destroyWorld(jsi::Runtime &rt, double world);
   double spawnDesc(jsi::Runtime &rt, double world, jsi::Object desc);
@@ -67,6 +69,8 @@ class NayanEngineModule : public NativeNayanEngineCxxSpec<NayanEngineModule> {
   jsi::Object modelVertices(jsi::Runtime &rt, double mesh);
   jsi::Object modelIndices(jsi::Runtime &rt, double mesh);
   jsi::Array modelSize(jsi::Runtime &rt, double mesh);
+  jsi::Array modelBake(jsi::Runtime &rt, double mesh, jsi::String spec);
+  bool bakeKept(jsi::Runtime &rt, jsi::String key);
   double modelTexture(jsi::Runtime &rt, double mesh);
   double meshAlias(jsi::Runtime &rt, double base);
   double meshCreate(jsi::Runtime &rt, jsi::Object vertices, jsi::Object indices);
@@ -137,6 +141,7 @@ class NayanEngineModule : public NativeNayanEngineCxxSpec<NayanEngineModule> {
       double count,
       double width,
       double height);
+  void renderBackdrop(jsi::Runtime &rt, double surface, jsi::Object matrices, jsi::Object colors, jsi::Object regions, jsi::Object ranges, double count);
   jsi::String renderError(jsi::Runtime &rt);
   jsi::String renderBackend(jsi::Runtime &rt);
   double drawingCreate(jsi::Runtime &rt, double width, double height, double ratio);
@@ -149,8 +154,43 @@ class NayanEngineModule : public NativeNayanEngineCxxSpec<NayanEngineModule> {
   void audioSetVolume(jsi::Runtime &rt, double volume);
   void audioSetMuted(jsi::Runtime &rt, bool muted);
   bool audioIsRunning(jsi::Runtime &rt);
+  void audioRelease(jsi::Runtime &rt, double sound);
+  double audioDuration(jsi::Runtime &rt, double sound);
+  jsi::Object audioLevels(jsi::Runtime &rt, double sound, double perSecond);
+  double micPermission(jsi::Runtime &rt);
+  jsi::Value micRequestPermission(jsi::Runtime &rt);
+  bool micStart(jsi::Runtime &rt, double maxSeconds);
+  void micStop(jsi::Runtime &rt);
+  double micState(jsi::Runtime &rt);
+  double micLevel(jsi::Runtime &rt);
+  double micHeld(jsi::Runtime &rt);
+  double micTake(jsi::Runtime &rt, double seconds, double skipEnd);
   bool hapticsSupported(jsi::Runtime &rt);
   void hapticsPlay(jsi::Runtime &rt, jsi::Array taps, bool throttle);
+  double worldgenBuild(jsi::Runtime &rt, jsi::String recipe, jsi::String key, bool prepareTerrain);
+  jsi::Value worldgenBuildAsync(jsi::Runtime &rt, jsi::String recipe, jsi::String key, bool prepareTerrain);
+  jsi::String worldgenError(jsi::Runtime &rt);
+  bool worldgenKept(jsi::Runtime &rt, jsi::String key);
+  void worldgenFree(jsi::Runtime &rt, double world);
+  jsi::String worldgenInfo(jsi::Runtime &rt, double world);
+  jsi::Object worldgenLayer(jsi::Runtime &rt, double world, jsi::String name);
+  jsi::Object worldgenReachable(jsi::Runtime &rt, double world);
+  jsi::Object worldgenOverview(jsi::Runtime &rt, double world);
+  bool worldgenPick(jsi::Runtime &rt, double world, double run);
+  jsi::Object worldgenTerrain(jsi::Runtime &rt, double world, double material);
+  jsi::Object worldgenMesh(jsi::Runtime &rt, jsi::String recipe);
+  bool worldgenPaint(jsi::Runtime &rt, jsi::Object vertices, jsi::String recipe);
+  double worldgenGround(jsi::Runtime &rt, double world, double x, double z);
+  double worldgenSurface(jsi::Runtime &rt, double world, double x, double z);
+  double worldgenPlatform(jsi::Runtime &rt, double world, double x, double z);
+  bool worldgenWalkable(jsi::Runtime &rt, double world, double x, double z, double radius);
+  double worldgenClearance(jsi::Runtime &rt, double world, double x, double z, double radius);
+  double worldgenSolidClearance(jsi::Runtime &rt, double world, double x, double z, double radius, double bottom, double top);
+  double worldgenFieldIndex(jsi::Runtime &rt, double world, jsi::String name);
+  double worldgenField(jsi::Runtime &rt, double world, double field, double x, double z);
+  jsi::Array worldgenTilt(jsi::Runtime &rt, double world, double x, double z, double yaw);
+  bool worldgenSight(jsi::Runtime &rt, double world, double ax, double az, double bx, double bz, double radius, double step, double rise);
+  jsi::Array worldgenMove(jsi::Runtime &rt, double world, double x, double z, double dx, double dz, double radius, jsi::Object bodies);
 
  private:
   std::shared_ptr<::World> owner(double id) const;