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

package/native/ios/NayanEngineProvider.h

@@ -0,0 +1,5 @@
+#import <Foundation/Foundation.h>
+#import <ReactCommon/RCTTurboModule.h>
+
+@interface NayanEngineProvider : NSObject <RCTModuleProvider>
+@end

package/native/ios/NayanEngineProvider.mm

@@ -0,0 +1,21 @@
+#import "NayanEngineProvider.h"
+
+#import <ReactCommon/CallInvoker.h>
+#import <ReactCommon/TurboModule.h>
+
+#include "NayanEngineModule.h"
+#include <engine_core.h>
+#import <Foundation/Foundation.h>
+
+@implementation NayanEngineProvider
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  NSURL *support = [[[NSFileManager defaultManager] URLsForDirectory:NSApplicationSupportDirectory inDomains:NSUserDomainMask] firstObject];
+  NSData *path = [support.path dataUsingEncoding:NSUTF8StringEncoding];
+  if (path != nil) engine_cache_directory(static_cast<const uint8_t *>(path.bytes), path.length);
+  return std::make_shared<facebook::react::NayanEngineModule>(params.jsInvoker);
+}
+
+@end

package/native/ios/NayanEngineSurface.mm

@@ -0,0 +1,252 @@
+// The EngineSurface view: a CAMetalLayer the Rust renderer draws into with Metal. JS refers to it by
+// `surfaceId`. A display link asks the game for each frame on the JS thread (`deliverFrame`); the
+// frames it publishes are drawn on the engine's render thread.
+#import <QuartzCore/CAMetalLayer.h>
+#import <QuartzCore/CADisplayLink.h>
+#import <React/RCTViewManager.h>
+#import <UIKit/UIKit.h>
+
+#include <engine_core.h>
+
+namespace facebook::react {
+void deliverFrame(int surface, double timeMs); // NayanEngineModule.cpp
+}
+
+@interface NayanEngineSurfaceView : UIView <UIGestureRecognizerDelegate>
+@property (nonatomic, assign) NSInteger surfaceId;
+@property (nonatomic, assign) NSInteger drawingId;
+@property (nonatomic, assign) NSInteger drawingMode;
+@property (nonatomic, assign) NSInteger drawingBackground;
+@property (nonatomic, copy) RCTDirectEventBlock onDrawingChange;
+@end
+
+@implementation NayanEngineSurfaceView {
+  BOOL _attached;
+  CADisplayLink *_drawingClock;
+  CADisplayLink *_clock;
+  UITouch *_drawingTouch;
+  UIPinchGestureRecognizer *_drawingPinch;
+  UIPanGestureRecognizer *_drawingPan;
+  CFTimeInterval _lastDrawingEvent;
+}
+
++ (Class)layerClass
+{
+  return [CAMetalLayer class];
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    _surfaceId = -1;
+    _drawingId = -1;
+    _drawingBackground = 0xffffff;
+    self.multipleTouchEnabled = YES;
+    _drawingPinch = [[UIPinchGestureRecognizer alloc] initWithTarget:self action:@selector(pinchDrawing:)];
+    _drawingPan = [[UIPanGestureRecognizer alloc] initWithTarget:self action:@selector(panDrawing:)];
+    _drawingPinch.delegate = self;
+    _drawingPan.delegate = self;
+    _drawingPan.minimumNumberOfTouches = 2;
+    _drawingPinch.enabled = NO;
+    _drawingPan.enabled = NO;
+    [self addGestureRecognizer:_drawingPinch];
+    [self addGestureRecognizer:_drawingPan];
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(stopDrawingClock) name:UIApplicationWillResignActiveNotification object:nil];
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(startDrawingClock) name:UIApplicationDidBecomeActiveNotification object:nil];
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(stopClock) name:UIApplicationWillResignActiveNotification object:nil];
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(startClock) name:UIApplicationDidBecomeActiveNotification object:nil];
+    self.layer.opaque = YES;
+  }
+  return self;
+}
+
+- (void)setSurfaceId:(NSInteger)surfaceId
+{
+  if (surfaceId == _surfaceId) {
+    return;
+  }
+  [self detach];
+  _surfaceId = surfaceId;
+  [self attach];
+}
+
+- (void)attach
+{
+  CGFloat scale = self.window.screen.scale ?: UIScreen.mainScreen.scale;
+  CGSize size = self.bounds.size;
+  if (_surfaceId < 0 || self.window == nil || size.width <= 0 || size.height <= 0) {
+    return;
+  }
+  self.layer.contentsScale = scale;
+  _attached = engine_render_attach(
+                  (int32_t)_surfaceId, (__bridge void *)self.layer, (uint32_t)(size.width * scale), (uint32_t)(size.height * scale)) == 1;
+  if (_drawingId >= 0) engine_drawing_invalidate((int32_t)_drawingId);
+  [self startDrawingClock];
+  [self startClock];
+}
+
+- (void)detach
+{
+  [self stopClock];
+  [self stopDrawingClock];
+  if (_attached) {
+    engine_render_detach((int32_t)_surfaceId);
+    _attached = NO;
+  }
+}
+
+- (void)layoutSubviews
+{
+  [super layoutSubviews];
+  [self attach];
+}
+
+- (void)didMoveToWindow
+{
+  [super didMoveToWindow];
+  if (self.window == nil) {
+    [self detach];
+  } else {
+    [self attach];
+  }
+}
+
+- (void)dealloc
+{
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+  [self detach];
+}
+
+- (void)setDrawingId:(NSInteger)value {
+  if (_drawingId == value) return;
+  [self stopDrawingClock];
+  _drawingId = value;
+  _drawingPinch.enabled = value >= 0;
+  _drawingPan.enabled = value >= 0;
+  if (value >= 0) engine_drawing_invalidate((int32_t)value);
+  [self startDrawingClock];
+}
+- (void)setDrawingMode:(NSInteger)value {
+  if (_drawingTouch != nil) engine_drawing_touch((int32_t)_drawingId, 3, 0, 0, 1);
+  _drawingTouch = nil;
+  _drawingMode = value;
+  _drawingPan.minimumNumberOfTouches = value == 0 ? 2 : 1;
+}
+- (void)setDrawingBackground:(NSInteger)value {
+  _drawingBackground = value;
+  if (_drawingId >= 0) engine_drawing_invalidate((int32_t)_drawingId);
+}
+/**
+ * The game's display clock: once per refresh while the surface is attached, on screen and the app is
+ * active, the engine is asked for its next frame on the JS thread. 60 a second, also on ProMotion
+ * screens, so a JS game loop isn't run twice as often.
+ */
+- (void)startClock {
+  if (_clock != nil || _surfaceId < 0 || self.window == nil || !_attached || UIApplication.sharedApplication.applicationState != UIApplicationStateActive) return;
+  _clock = [CADisplayLink displayLinkWithTarget:self selector:@selector(tick:)];
+  if (@available(iOS 15.0, *)) _clock.preferredFrameRateRange = CAFrameRateRangeMake(30, 60, 60);
+  else _clock.preferredFramesPerSecond = 60;
+  [_clock addToRunLoop:NSRunLoop.mainRunLoop forMode:NSRunLoopCommonModes];
+}
+- (void)stopClock {
+  [_clock invalidate];
+  _clock = nil;
+}
+- (void)tick:(CADisplayLink *)link {
+  if (_surfaceId >= 0) facebook::react::deliverFrame((int)_surfaceId, link.timestamp * 1000.0);
+}
+- (void)startDrawingClock {
+  if (_drawingClock != nil || _drawingId < 0 || self.window == nil || !_attached || UIApplication.sharedApplication.applicationState != UIApplicationStateActive) return;
+  _drawingClock = [CADisplayLink displayLinkWithTarget:self selector:@selector(presentDrawing)];
+  if (@available(iOS 15.0, *)) _drawingClock.preferredFrameRateRange = CAFrameRateRangeMake(30, 120, 120);
+  [_drawingClock addToRunLoop:NSRunLoop.mainRunLoop forMode:NSRunLoopCommonModes];
+}
+- (void)stopDrawingClock {
+  [_drawingClock invalidate];
+  _drawingClock = nil;
+  if (_drawingTouch != nil) {
+    CGPoint point = [_drawingTouch locationInView:self];
+    engine_drawing_touch((int32_t)_drawingId, 2, point.x, point.y, 1);
+    _drawingTouch = nil;
+  }
+}
+- (void)presentDrawing {
+  engine_drawing_present((int32_t)_drawingId, (int32_t)_surfaceId, self.bounds.size.width, self.bounds.size.height, (uint32_t)_drawingBackground);
+  CFTimeInterval now = CACurrentMediaTime();
+  if (_onDrawingChange != nil && now - _lastDrawingEvent >= 0.1) {
+    _lastDrawingEvent = now;
+    char *event = engine_drawing_take_event((int32_t)_drawingId);
+    if (event != nullptr) {
+      NSString *state = [NSString stringWithUTF8String:event];
+      engine_drawing_result_free(event);
+      _onDrawingChange(@{@"state": state ?: @"{}", @"documentId": @(_drawingId)});
+    }
+  }
+}
+- (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer *)gesture { return _drawingTouch == nil || _drawingTouch.type != UITouchTypePencil; }
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)a shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)b { return YES; }
+- (void)pinchDrawing:(UIPinchGestureRecognizer *)gesture {
+  if (gesture.state == UIGestureRecognizerStateChanged) {
+    engine_drawing_transform((int32_t)_drawingId, 0, 0, gesture.scale);
+    gesture.scale = 1;
+  }
+}
+- (void)panDrawing:(UIPanGestureRecognizer *)gesture {
+  if (gesture.state == UIGestureRecognizerStateChanged) {
+    CGPoint delta = [gesture translationInView:self];
+    engine_drawing_transform((int32_t)_drawingId, delta.x, delta.y, 1);
+    [gesture setTranslation:CGPointZero inView:self];
+  }
+}
+- (void)sampleDrawing:(UITouch *)touch phase:(int32_t)phase {
+  CGPoint point = [touch locationInView:self];
+  CGFloat pressure = touch.type == UITouchTypePencil && touch.maximumPossibleForce > 0 ? touch.force / touch.maximumPossibleForce : 1;
+  engine_drawing_touch((int32_t)_drawingId, phase, point.x, point.y, pressure);
+}
+- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
+  if (_drawingId < 0) { [super touchesBegan:touches withEvent:event]; return; }
+  if (_drawingMode != 0 || _drawingTouch != nil) return;
+  UITouch *touch = touches.anyObject;
+  for (UITouch *candidate in touches) if (candidate.type == UITouchTypePencil) { touch = candidate; break; }
+  // A Pencil is tracked independently; fingers arriving during its stroke are palm touches.
+  if (touch.type != UITouchTypePencil && event.allTouches.count != 1) return;
+  _drawingTouch = touch;
+  [self sampleDrawing:touch phase:0];
+}
+- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
+  if (_drawingId < 0) { [super touchesMoved:touches withEvent:event]; return; }
+  if (_drawingTouch == nil || ![touches containsObject:_drawingTouch]) return;
+  NSArray<UITouch *> *samples = [event coalescedTouchesForTouch:_drawingTouch];
+  if (samples.count == 0) [self sampleDrawing:_drawingTouch phase:1];
+  else for (UITouch *sample in samples) [self sampleDrawing:sample phase:1];
+}
+- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
+  if (_drawingId < 0) { [super touchesEnded:touches withEvent:event]; return; }
+  if (_drawingTouch != nil && [touches containsObject:_drawingTouch]) { [self sampleDrawing:_drawingTouch phase:2]; _drawingTouch = nil; }
+}
+- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
+  if (_drawingId < 0) { [super touchesCancelled:touches withEvent:event]; return; }
+  if (_drawingTouch != nil && [touches containsObject:_drawingTouch]) { engine_drawing_touch((int32_t)_drawingId, 3, 0, 0, 1); _drawingTouch = nil; }
+}
+
+@end
+
+@interface NayanEngineSurfaceManager : RCTViewManager
+@end
+
+@implementation NayanEngineSurfaceManager
+
+RCT_EXPORT_MODULE(NayanEngineSurface)
+
+- (UIView *)view
+{
+  return [NayanEngineSurfaceView new];
+}
+
+RCT_EXPORT_VIEW_PROPERTY(surfaceId, NSInteger)
+RCT_EXPORT_VIEW_PROPERTY(drawingId, NSInteger)
+RCT_EXPORT_VIEW_PROPERTY(drawingMode, NSInteger)
+RCT_EXPORT_VIEW_PROPERTY(drawingBackground, NSInteger)
+RCT_EXPORT_VIEW_PROPERTY(onDrawingChange, RCTDirectEventBlock)
+
+@end

package/native/scripts/check-package.mjs

@@ -0,0 +1,39 @@
+import { readFile, stat } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = resolve(fileURLToPath(new URL('../..', import.meta.url)));
+const metadata = JSON.parse(await readFile(resolve(root, 'package.json'), 'utf8'));
+const required = new Set([
+  'README.md',
+  'NayanEngine.podspec',
+  'react-native.config.js',
+  'src/native/spec/NativeNayanEngine.ts',
+  'native/cpp/generated/NayanEngineSpecJSI.h',
+  'native/core/include/engine_core.h',
+  'native/core/build/EngineCore.xcframework/Info.plist',
+  'native/core/build/EngineCore.xcframework/ios-arm64/libengine_core.a',
+  'native/core/build/EngineCore.xcframework/ios-arm64-simulator/libengine_core.a',
+  'lib/web/engine_core_bg.wasm',
+  'lib/web/audio-worklet.js'
+]);
+for (const abi of ['arm64-v8a', 'armeabi-v7a', 'x86_64', 'x86']) required.add(`native/core/build/android/${abi}/libengine_core.a`);
+function exportedFiles(value) {
+  if (typeof value === 'string') required.add(value);
+  else for (const item of Object.values(value)) exportedFiles(item);
+}
+exportedFiles(metadata.exports);
+const missing = [];
+for (const path of required) {
+  try {
+    const info = await stat(resolve(root, path));
+    if (!info.isFile() || info.size === 0) missing.push(path);
+  } catch {
+    missing.push(path);
+  }
+}
+if (missing.length)
+  throw new Error(
+    `Engine package is incomplete:\n${missing.map((path) => `  ${path}`).join('\n')}\nBuild the native core on macOS and run engine:build before packing or publishing.`
+  );
+console.error(`Verified ${required.size} required engine package files for ${metadata.version}.`);

package/package.json

@@ -1,6 +1,164 @@
 {
   "name": "@nayan-ui/engine",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0-beta.4",
+  "description": "Fast 3D game engine for React and React Native: Rust and wgpu rendering, Rapier physics, animation, particle effects, audio, haptics and drawing.",
+  "keywords": [
+    "3d",
+    "android",
+    "drawing",
+    "game-engine",
+    "ios",
+    "metal",
+    "nayan-ui",
+    "particles",
+    "physics",
+    "rapier",
+    "react",
+    "react-game-engine",
+    "react-native",
+    "react-native-game-engine",
+    "rust",
+    "vulkan",
+    "web",
+    "webassembly",
+    "webgl",
+    "webgpu",
+    "wgpu"
+  ],
+  "homepage": "https://www.nayanui.com/game-engine",
+  "bugs": {
+    "url": "https://github.com/ursnj/nayan-ui/issues"
+  },
+  "license": "MIT",
+  "author": "Niranjan Devasani <niranjan.devasani@gmail.com> (https://github.com/ursnj)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ursnj/nayan-ui.git"
+  },
+  "workspaces": [
+    "example"
+  ],
+  "files": [
+    "src/native/spec",
+    "lib",
+    "native/cpp",
+    "native/ios",
+    "native/android",
+    "*.podspec",
+    "react-native.config.js",
+    "native/core/include",
+    "native/core/build",
+    "!native/core/build/web",
+    "!**/.*",
+    "!**/*.map",
+    "!src/**/__tests__",
+    "native/scripts/check-package.mjs"
+  ],
+  "sideEffects": false,
+  "main": "./lib/module/index.js",
+  "browser": "./lib/web/index.js",
+  "types": "./lib/web/types/src/index.d.ts",
+  "exports": {
+    ".": {
+      "react-native": {
+        "source": "./src/index.ts",
+        "types": "./lib/typescript/src/index.d.ts",
+        "default": "./lib/module/index.js"
+      },
+      "react-native-strict-api": {
+        "source": "./src/index.ts",
+        "types": "./lib/typescript/src/index.d.ts",
+        "default": "./lib/module/index.js"
+      },
+      "browser": {
+        "types": "./lib/web/types/src/index.d.ts",
+        "default": "./lib/web/index.js"
+      },
+      "source": "./src/index.ts",
+      "types": "./lib/web/types/src/index.d.ts",
+      "default": "./lib/web/index.js"
+    },
+    "./package.json": "./package.json",
+    "./web": {
+      "types": "./lib/web/types/src/index.d.ts",
+      "default": "./lib/web/index.js"
+    }
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "example": "bun run --cwd example",
+    "clean": "del-cli lib",
+    "build": "bun run build:web && bob build",
+    "typecheck": "bun check && bun check -p tsconfig.test.json",
+    "core:test": "cargo test --manifest-path native/core/Cargo.toml",
+    "core:bench": "cargo run --release --example bench --manifest-path native/core/Cargo.toml",
+    "core:build": "native/core/scripts/build-ios.sh && native/core/scripts/build-android.sh",
+    "core:build:ios": "native/core/scripts/build-ios.sh",
+    "core:build:android": "native/core/scripts/build-android.sh",
+    "test": "bun test --isolate src",
+    "test:coverage": "bun test --isolate --coverage src native/tests && bun native/scripts/check-coverage.mjs",
+    "codegen": "node native/scripts/codegen-cxx.js",
+    "lint": "bun lint --no-script .",
+    "lint:fix": "bun lint --no-script --fix .",
+    "core:build:web": "native/core/scripts/build-web.sh",
+    "build:web": "bun run core:build:web && bun native/scripts/build-web.mjs",
+    "test:web": "bun test native/tests/web.test.ts",
+    "prepack": "node native/scripts/check-package.mjs"
+  },
+  "devDependencies": {
+    "@types/react": "~19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "bun-types": "latest",
+    "del-cli": "^7.0.0",
+    "fake-indexeddb": "^6.2.6",
+    "happy-dom": "^21.0.4",
+    "react": "19.3.0",
+    "react-dom": "19.3.0",
+    "react-native": "0.88.0",
+    "react-native-builder-bob": "^0.43.1",
+    "typescript": "~6.0.3"
+  },
+  "peerDependencies": {
+    "expo-asset": "*",
+    "react": "*",
+    "react-native": "*"
+  },
+  "peerDependenciesMeta": {
+    "expo-asset": {
+      "optional": true
+    },
+    "react-native": {
+      "optional": true
+    }
+  },
+  "codegenConfig": {
+    "name": "NayanEngineSpec",
+    "type": "modules",
+    "jsSrcsDir": "src/native",
+    "ios": {
+      "modulesProvider": {
+        "NativeNayanEngine": "NayanEngineProvider"
+      }
+    }
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  }
+}

package/react-native.config.js

@@ -0,0 +1,18 @@
+// Autolinking. iOS uses NayanEngine.podspec; Android builds native/android/CMakeLists.txt into the app as a
+// pure C++ TurboModule (the generated autolinking code instantiates NayanEngineModule).
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        sourceDir: 'native/android',
+        // The EngineSurface view (native/android/src/main/java).
+        packageImportPath: 'import com.nayanui.engine.NayanEnginePackage;',
+        packageInstance: 'new NayanEnginePackage()',
+        cmakeListsPath: 'codegen/CMakeLists.txt',
+        cxxModuleCMakeListsModuleName: 'NayanEngine',
+        cxxModuleCMakeListsPath: 'CMakeLists.txt',
+        cxxModuleHeaderName: 'NayanEngineModule'
+      }
+    }
+  }
+};