@geastack/apple 0.2.8

package/targets/ios/main/ios_memory.cpp

@@ -0,0 +1,55 @@
+#include "memory.h"
+
+#include <cstddef>
+#include <cstdlib>
+
+namespace gea::framework::memory {
+
+void *Allocator::allocatePreferSpiram(std::size_t size, std::size_t alignment)
+{
+	if (size == 0) return nullptr;
+	if (alignment <= alignof(std::max_align_t)) return std::malloc(size);
+	void *ptr = nullptr;
+	if (posix_memalign(&ptr, alignment, size) != 0) return nullptr;
+	return ptr;
+}
+
+void *Allocator::reallocatePreferSpiram(void *ptr, std::size_t size)
+{
+	if (size == 0) {
+		std::free(ptr);
+		return nullptr;
+	}
+	return std::realloc(ptr, size);
+}
+
+void Allocator::free(void *ptr) noexcept
+{
+	std::free(ptr);
+}
+
+}  // namespace gea::framework::memory
+
+namespace gea::platform::memory {
+
+std::uint32_t Memory::internalFree() { return 0; }
+std::uint32_t Memory::internalLargestFreeBlock() { return 0; }
+std::uint32_t Memory::internalMinimumFree() { return 0; }
+std::uint32_t Memory::psramFree() { return 0; }
+std::uint32_t Memory::currentTaskStackHighWaterMark() { return 0; }
+std::uint32_t Memory::geaMainStackBytes() { return 0; }
+std::uint32_t Memory::geaInitStackBytes() { return 0; }
+std::uint32_t Memory::appFrameStackWords() { return 0; }
+std::uint32_t Memory::appFrameStackBytes() { return 0; }
+std::uint32_t Memory::displayFlushConfiguredRows() { return 0; }
+std::uint32_t Memory::displayFlushConfiguredDepth() { return 0; }
+std::uint32_t Memory::displayFlushBufferMaxBytes() { return 0; }
+std::uint32_t Memory::displayFlushRows() { return 0; }
+std::uint32_t Memory::displayFlushDepth() { return 0; }
+std::uint32_t Memory::displayFlushBufferBytes() { return 0; }
+
+// No internal/external split here, so there is nothing to hold back for the
+// display; the caller treats nullptr as "no reserve" and carries on.
+void *Memory::reserveInternalDma(std::size_t) { return nullptr; }
+void Memory::releaseInternalDma(void *) {}
+}  // namespace gea::platform::memory

package/targets/ios/main/ios_renderer.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#ifdef __OBJC__
+@class UIView;
+#else
+struct UIView;
+#endif
+
+namespace gea::ios {
+
+class IosRenderer {
+public:
+	static IosRenderer &instance();
+
+	void sync(UIView *parentForRoot, int rootNodeId);
+	void teardown();
+	bool hasNativeTree() const;
+};
+
+}  // namespace gea::ios

package/targets/ios/main/ios_renderer.mm

@@ -0,0 +1,27 @@
+#include "ios_renderer.h"
+#include "renderer/ios_renderer_internal.h"
+
+namespace gea::ios {
+
+IosRenderer &IosRenderer::instance()
+{
+	static IosRenderer renderer;
+	return renderer;
+}
+
+void IosRenderer::sync(UIView *parentForRoot, int rootNodeId)
+{
+	renderer::syncNativeTree(parentForRoot, rootNodeId);
+}
+
+void IosRenderer::teardown()
+{
+	renderer::teardownNativeTree();
+}
+
+bool IosRenderer::hasNativeTree() const
+{
+	return renderer::hasNativeTree();
+}
+
+}  // namespace gea::ios

package/targets/ios/main/ios_root_background.cpp

@@ -0,0 +1,20 @@
+#include "ios_root_background.h"
+
+#include "ui/tree_internal.h"
+
+namespace gea::ios {
+
+bool mountedRootBackgroundColor(gea::framework::graphics::pixel::native_t *outColor)
+{
+	auto &tree = gea::embedded::ui::Tree::instance();
+	const int root = tree.mountedRoot();
+	if (root < 0 || root >= tree.nodeCount()) return false;
+
+	const auto &style = tree.node(root).style;
+	if (!style.has_bg) return false;
+
+	if (outColor) *outColor = style.bg_color;
+	return true;
+}
+
+}  // namespace gea::ios

package/targets/ios/main/ios_root_background.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "pixel.h"
+
+#include <cstdint>
+
+namespace gea::ios {
+
+bool mountedRootBackgroundColor(gea::framework::graphics::pixel::native_t *outColor);
+
+}  // namespace gea::ios

package/targets/ios/main/ios_sensors.mm

@@ -0,0 +1,244 @@
+#include "imu.h"
+#include "touch.h"
+
+#import <CoreMotion/CoreMotion.h>
+#import <Foundation/Foundation.h>
+
+#include <algorithm>
+#include <cmath>
+
+namespace gea::platform::sensors {
+
+namespace {
+
+constexpr NSTimeInterval kMotionUpdateInterval = 1.0 / 60.0;
+constexpr double kPi = 3.14159265358979323846;
+constexpr double kRadiansToDegrees = 180.0 / kPi;
+constexpr double kStandardGravity = 9.80665;
+
+double g_gyro_bias_x = 0.0;
+double g_gyro_bias_y = 0.0;
+double g_gyro_bias_z = 0.0;
+
+struct Acceleration {
+	double x = 0.0;
+	double y = 0.0;
+	double z = 1.0;
+};
+
+struct RotationRate {
+	double x = 0.0;
+	double y = 0.0;
+	double z = 0.0;
+};
+
+Acceleration mapCoreMotionAccelerationToGea(Acceleration raw)
+{
+	return { raw.y, -raw.x, raw.z };
+}
+
+RotationRate mapCoreMotionRotationRateToGea(RotationRate raw)
+{
+	return { raw.y, -raw.x, raw.z };
+}
+
+CMMotionManager *motionManager()
+{
+	static CMMotionManager *manager = nil;
+	static dispatch_once_t onceToken;
+	dispatch_once(&onceToken, ^{
+		manager = [[CMMotionManager alloc] init];
+	});
+	return manager;
+}
+
+void startMotionUpdates()
+{
+	CMMotionManager *manager = motionManager();
+	if (manager.deviceMotionAvailable) {
+		manager.deviceMotionUpdateInterval = kMotionUpdateInterval;
+		if (!manager.deviceMotionActive) {
+			[manager startDeviceMotionUpdates];
+		}
+		return;
+	}
+
+	if (manager.accelerometerAvailable && !manager.accelerometerActive) {
+		manager.accelerometerUpdateInterval = kMotionUpdateInterval;
+		[manager startAccelerometerUpdates];
+	}
+	if (manager.gyroAvailable && !manager.gyroActive) {
+		manager.gyroUpdateInterval = kMotionUpdateInterval;
+		[manager startGyroUpdates];
+	}
+}
+
+Acceleration currentAcceleration()
+{
+	startMotionUpdates();
+
+	CMMotionManager *manager = motionManager();
+	CMDeviceMotion *motion = manager.deviceMotion;
+	if (motion) {
+		CMAcceleration gravity = motion.gravity;
+		CMAcceleration userAcceleration = motion.userAcceleration;
+		return mapCoreMotionAccelerationToGea({
+			(gravity.x + userAcceleration.x) * kStandardGravity,
+			(gravity.y + userAcceleration.y) * kStandardGravity,
+			(gravity.z + userAcceleration.z) * kStandardGravity,
+		});
+	}
+
+	CMAccelerometerData *data = manager.accelerometerData;
+	if (data) {
+		CMAcceleration acceleration = data.acceleration;
+		return mapCoreMotionAccelerationToGea({
+			acceleration.x * kStandardGravity,
+			acceleration.y * kStandardGravity,
+			acceleration.z * kStandardGravity,
+		});
+	}
+
+	return {};
+}
+
+RotationRate currentRotationRate()
+{
+	startMotionUpdates();
+
+	CMMotionManager *manager = motionManager();
+	CMDeviceMotion *motion = manager.deviceMotion;
+	if (motion) {
+		CMRotationRate rate = motion.rotationRate;
+		return mapCoreMotionRotationRateToGea({
+			rate.x * kRadiansToDegrees,
+			rate.y * kRadiansToDegrees,
+			rate.z * kRadiansToDegrees,
+		});
+	}
+
+	CMGyroData *data = manager.gyroData;
+	if (data) {
+		CMRotationRate rate = data.rotationRate;
+		return mapCoreMotionRotationRateToGea({
+			rate.x * kRadiansToDegrees,
+			rate.y * kRadiansToDegrees,
+			rate.z * kRadiansToDegrees,
+		});
+	}
+
+	return {};
+}
+
+int tiltFromAxis(double axisMetersPerSecondSquared)
+{
+	const double axisG = axisMetersPerSecondSquared / kStandardGravity;
+	const int value = static_cast<int>(axisG * 70.0);
+	return std::clamp(value, -100, 100);
+}
+
+}  // namespace
+
+void Accelerometer::init()
+{
+	startMotionUpdates();
+}
+
+void Accelerometer::close()
+{
+	CMMotionManager *manager = motionManager();
+	if (manager.deviceMotionActive) [manager stopDeviceMotionUpdates];
+	if (manager.accelerometerActive) [manager stopAccelerometerUpdates];
+	if (manager.gyroActive) [manager stopGyroUpdates];
+}
+
+void Accelerometer::calibrateBias()
+{
+	RotationRate rate = currentRotationRate();
+	g_gyro_bias_x = rate.x;
+	g_gyro_bias_y = rate.y;
+	g_gyro_bias_z = rate.z;
+}
+
+int Accelerometer::tiltX()
+{
+	return tiltFromAxis(currentAcceleration().y);
+}
+
+int Accelerometer::tiltY()
+{
+	return tiltFromAxis(-currentAcceleration().x);
+}
+
+double Accelerometer::accelerationX()
+{
+	return currentAcceleration().x;
+}
+
+double Accelerometer::accelerationY()
+{
+	return currentAcceleration().y;
+}
+
+double Accelerometer::accelerationZ()
+{
+	return currentAcceleration().z;
+}
+
+double Accelerometer::gyroscopeX()
+{
+	return currentRotationRate().x - g_gyro_bias_x;
+}
+
+double Accelerometer::gyroscopeY()
+{
+	return currentRotationRate().y - g_gyro_bias_y;
+}
+
+double Accelerometer::gyroscopeZ()
+{
+	return currentRotationRate().z - g_gyro_bias_z;
+}
+
+void Accelerometer::setWebTilt(int, int) {}
+
+}  // namespace gea::platform::sensors
+
+namespace gea::platform::touch {
+
+namespace {
+bool g_touching = false;
+int g_touch_x = 0;
+int g_touch_y = 0;
+}  // namespace
+
+extern "C" void gea_ios_touch_set_state(int touching, int x, int y)
+{
+	g_touching = touching != 0;
+	g_touch_x = x;
+	g_touch_y = y;
+}
+
+void Touchscreen::setObserver(Observer) {}
+bool Touchscreen::init() { return true; }
+int Touchscreen::read(int *x, int *y)
+{
+	if (x) *x = g_touch_x;
+	if (y) *y = g_touch_y;
+	return g_touching ? 1 : 0;
+}
+
+int Touchscreen::readCached(int *x, int *y)
+{
+	if (x) *x = g_touch_x;
+	if (y) *y = g_touch_y;
+	return g_touching ? 1 : 0;
+}
+
+void Touchscreen::consumeLatestMove(int *x, int *y)
+{
+	if (x) *x = g_touch_x;
+	if (y) *y = g_touch_y;
+}
+
+}  // namespace gea::platform::touch

package/targets/ios/main/ios_timers.mm

@@ -0,0 +1,53 @@
+#import <Foundation/Foundation.h>
+
+#include "services/frame_scheduler.h"
+
+#include <cstdint>
+#include <mach/mach_time.h>
+
+namespace {
+
+int millis_since_boot()
+{
+	static mach_timebase_info_data_t tb = {0, 0};
+	if (tb.denom == 0) mach_timebase_info(&tb);
+	const std::uint64_t ns = mach_absolute_time() * tb.numer / tb.denom;
+	return static_cast<int>(ns / 1000000ULL);
+}
+
+int g_frame_interval_ms = gea::framework::services::FrameScheduler::kDefaultFrameIntervalMs;
+
+}  // namespace
+
+extern "C" int gea_embedded_now_ms(void)
+{
+	return millis_since_boot();
+}
+
+namespace gea::framework::services {
+
+EventQueue FrameScheduler::createEventQueue() { return EventQueue{}; }
+EventQueue FrameScheduler::eventQueue() { return EventQueue{}; }
+bool FrameScheduler::sendEvent(const gea::framework::events::Event &, int) { return true; }
+bool FrameScheduler::receiveEvent(gea::framework::events::Event *) { return false; }
+void FrameScheduler::start(EventQueue) {}
+void FrameScheduler::runFrame(const FrameCallbacks &callbacks)
+{
+	if (callbacks.frame) callbacks.frame(millis_since_boot(), callbacks.context);
+}
+void FrameScheduler::setFrameIntervalMs(int intervalMs)
+{
+	if (intervalMs < kMinFrameIntervalMs) intervalMs = kMinFrameIntervalMs;
+	if (intervalMs > kMaxFrameIntervalMs) intervalMs = kMaxFrameIntervalMs;
+	g_frame_interval_ms = intervalMs;
+}
+int FrameScheduler::frameIntervalMs() { return g_frame_interval_ms; }
+void FrameScheduler::setFrameRate(double fps)
+{
+	if (fps <= 0.0) return;
+	setFrameIntervalMs(static_cast<int>(1000.0 / fps + 0.5));
+}
+double FrameScheduler::frameRate() { return 1000.0 / static_cast<double>(g_frame_interval_ms); }
+int FrameScheduler::nowMs() { return millis_since_boot(); }
+
+}  // namespace gea::framework::services

package/targets/ios/main/renderer/ios_renderer_internal.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#import <UIKit/UIKit.h>
+
+#include "ui/node_model.h"
+
+#include <cstdint>
+#include <string>
+
+@class GeaCanvasView;
+
+@interface GeaNativeLabel : UILabel
+@property(nonatomic, assign) BOOL geaUseBitmapFont;
+@property(nonatomic, copy) NSString *geaBitmapText;
+@property(nonatomic, strong) UIColor *geaBitmapColor;
+@property(nonatomic, assign) CGFloat geaBitmapGlyphScale;
+@property(nonatomic, assign) NSInteger geaBitmapTextDecoration;
+@property(nonatomic, assign) BOOL geaHostedByNativeButtonTitle;
+@end
+
+@interface GeaNativeButton : UIButton
+@property(nonatomic, assign) int nodeId;
+- (void)handleTouchDown:(id)sender;
+- (void)handleTouchDrag:(id)sender;
+- (void)handleTouchUpInside:(id)sender;
+- (void)handleTouchUpOutside:(id)sender;
+- (void)handleTouchCancel:(id)sender;
+@end
+
+@interface GeaNativeScrollContainer : UIScrollView <UIScrollViewDelegate>
+@property(nonatomic, assign) int nodeId;
+@property(nonatomic, assign) BOOL syncingFromTree;
+@property(nonatomic, strong) UIView *contentView;
+@property(nonatomic, strong) UILabel *debugTelemetryLabel;
+@property(nonatomic, strong) UILabel *debugTopMarkerLabel;
+@property(nonatomic, strong) UILabel *debugBottomMarkerLabel;
+@property(nonatomic, assign) CGFloat minObservedContentOffsetY;
+@property(nonatomic, assign) CGFloat maxObservedContentOffsetY;
+- (void)updateScrollTelemetryWithScale:(CGFloat)scale;
+- (void)commitNativeScrollTopWithScale:(CGFloat)scale;
+@end
+
+namespace gea::ios::renderer {
+
+UIColor *rgb565ToUIColor(gea::framework::graphics::pixel::native_t color);
+CGFloat canvasScaleForView(UIView *view);
+void dispatchSyntheticTap(UIView *rootView, CGPoint point);
+bool isScrollableNode(const gea::embedded::ui::Node &node);
+NSMutableDictionary<NSNumber *, UIView *> *nodeIdToView();
+NSString *NSStringFromText(const std::string &value);
+NSTextAlignment textAlignmentForStyle(int align);
+NSMutableDictionary *textAttributes(UIFont *font, UIColor *color, int textDecoration);
+
+void applyTextProps(GeaNativeLabel *label, const gea::embedded::ui::Node &node, CGFloat scale);
+void applyButtonProps(GeaNativeButton *button, const gea::embedded::ui::Node &node, int nodeId, CGFloat scale);
+void applyScrollProps(GeaNativeScrollContainer *scrollView,
+                      const gea::embedded::ui::Node &node,
+                      int nodeId,
+                      CGFloat scale);
+
+void syncNativeTree(UIView *parentForRoot, int rootNodeId);
+void teardownNativeTree();
+bool hasNativeTree();
+
+}  // namespace gea::ios::renderer

package/targets/ios/main/renderer/ios_renderer_support.mm

@@ -0,0 +1,111 @@
+#include "ios_renderer_internal.h"
+
+#include "display.h"
+#include "events.h"
+#include "pixel.h"
+#include "ui/tree_internal.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstdlib>
+#include <cstring>
+
+extern "C" void gea_ios_touch_set_state(int touching, int x, int y);
+
+namespace gea::ios::renderer {
+
+UIColor *rgb565ToUIColor(gea::framework::graphics::pixel::native_t color)
+{
+	// Style colours are native pixels (RGBA8888 on iOS) — unpack the full 8-bit
+	// channels so native UIKit views render true colour, not 565-quantized.
+	int r, g, b, a;
+	gea::framework::graphics::pixel::unpackNative8(color, &r, &g, &b, &a);
+	return [UIColor colorWithRed:static_cast<CGFloat>(r) / 255.0
+	                       green:static_cast<CGFloat>(g) / 255.0
+	                        blue:static_cast<CGFloat>(b) / 255.0
+	                       alpha:1.0];
+}
+
+CGFloat canvasScaleForView(UIView *view)
+{
+	auto *canvas = gea::platform::display::Display::canvas();
+	if (!view || !canvas || canvas->width() <= 0 || view.bounds.size.width <= 0) return 1.0;
+	return view.bounds.size.width / static_cast<CGFloat>(canvas->width());
+}
+
+void dispatchSyntheticTap(UIView *rootView, CGPoint point)
+{
+	auto *canvas = gea::platform::display::Display::canvas();
+	if (!rootView || !canvas || canvas->width() <= 0 || canvas->height() <= 0) return;
+	const CGFloat scale = canvasScaleForView(rootView);
+	int x = std::clamp(static_cast<int>(std::lround(point.x / std::max<CGFloat>(scale, 0.0001))),
+	                   0,
+	                   std::max(0, canvas->width() - 1));
+	int y = std::clamp(static_cast<int>(std::lround(point.y / std::max<CGFloat>(scale, 0.0001))),
+	                   0,
+	                   std::max(0, canvas->height() - 1));
+
+	auto fireTouch = [&](gea::framework::events::TouchPhase phase, bool touching) {
+		gea_ios_touch_set_state(touching ? 1 : 0, x, y);
+		gea::framework::events::Event event{};
+		event.type = gea::framework::events::EventType::Touch;
+		event.touchPhase = phase;
+		event.touching = touching;
+		event.x = x;
+		event.y = y;
+		gea::framework::events::TouchRuntime::dispatchEvent(event);
+	};
+
+	gea::framework::events::TouchRuntime::resetGestureState();
+	fireTouch(gea::framework::events::TouchPhase::Down, true);
+	fireTouch(gea::framework::events::TouchPhase::Up, false);
+}
+
+bool isScrollableNode(const gea::embedded::ui::Node &node)
+{
+	using gea::embedded::ui::NodeType;
+	if (node.type == NodeType::VirtualList) return node.layout.scroll_content_height > node.layout.height;
+	return node.style.overflow == 2 && node.layout.scroll_content_height > node.layout.height;
+}
+
+NSMutableDictionary<NSNumber *, UIView *> *nodeIdToView()
+{
+	static NSMutableDictionary<NSNumber *, UIView *> *map = [NSMutableDictionary new];
+	return map;
+}
+
+NSString *NSStringFromText(const std::string &value)
+{
+	return [NSString stringWithUTF8String:value.empty() ? "" : value.c_str()] ?: @"";
+}
+
+NSTextAlignment textAlignmentForStyle(int align)
+{
+	switch (align) {
+	case 1: return NSTextAlignmentCenter;
+	case 2: return NSTextAlignmentRight;
+	default: return NSTextAlignmentLeft;
+	}
+}
+
+static void addTextDecorationAttributes(NSMutableDictionary *attrs, int textDecoration)
+{
+	if (!attrs) return;
+	NSNumber *style = @((NSInteger)NSUnderlineStyleSingle);
+	if (textDecoration == 1) {
+		attrs[NSUnderlineStyleAttributeName] = style;
+	} else if (textDecoration == 2) {
+		attrs[NSStrikethroughStyleAttributeName] = style;
+	}
+}
+
+NSMutableDictionary *textAttributes(UIFont *font, UIColor *color, int textDecoration)
+{
+	NSMutableDictionary *attrs = [NSMutableDictionary dictionary];
+	attrs[NSFontAttributeName] = font ?: [UIFont systemFontOfSize:16];
+	attrs[NSForegroundColorAttributeName] = color ?: UIColor.whiteColor;
+	addTextDecorationAttributes(attrs, textDecoration);
+	return attrs;
+}
+
+}  // namespace gea::ios::renderer