Add ORBPath, ORBPathCallbacks, and ORBPathStorage APIs

Package.swift

@@ -159,12 +159,12 @@ let renderBoxCondtion = envBoolValue("RENDERBOX", default: buildForDarwinPlatfor
 
 var sharedCSettings: [CSetting] = [
     .unsafeFlags(["-I", libSwiftPath], .when(platforms: .nonDarwinPlatforms)),
-    .unsafeFlags(["-fmodules"]),
+    // .unsafeFlags(["-fmodules"]),
     .define("__COREFOUNDATION_FORSWIFTFOUNDATIONONLY__", to: "1", .when(platforms: .nonDarwinPlatforms)),
 ]
 var sharedCxxSettings: [CXXSetting] = [
     .unsafeFlags(["-I", libSwiftPath], .when(platforms: .nonDarwinPlatforms)),
-    .unsafeFlags(["-fcxx-modules"]),
+    // .unsafeFlags(["-fcxx-modules"]),
     .define("__COREFOUNDATION_FORSWIFTFOUNDATIONONLY__", to: "1", .when(platforms: .nonDarwinPlatforms)),
 ]
 var sharedSwiftSettings: [SwiftSetting] = [

Scripts/build.sh

@@ -9,4 +9,10 @@ OPENRENDERBOX_ROOT="$(dirname $(dirname $(filepath $0)))"
 
 cd $OPENRENDERBOX_ROOT
 
+# Set OPENRENDERBOX_LIB_SWIFT_PATH on Linux if swiftly is installed
+if [[ "$(uname)" == "Linux" ]] && command -v swiftly &> /dev/null && [[ -z "$OPENRENDERBOX_LIB_SWIFT_PATH" ]]; then
+  export OPENRENDERBOX_LIB_SWIFT_PATH="$(swiftly use --print-location)/usr/lib/swift"
+  echo "Set OPENRENDERBOX_LIB_SWIFT_PATH=$OPENRENDERBOX_LIB_SWIFT_PATH"
+fi
+
 swift build

Sources/OpenRenderBox/Path/ORBPath.cpp

@@ -5,12 +5,144 @@
 //  Created by Kyle on 2025/3/25.
 //
 
-#include <OpenRenderBox/ORBPathStorage.h>
+#include <OpenRenderBox/ORBPath.h>
+#include <OpenRenderBox/ORBPathCallbacks.h>
+
+// Empty path callbacks (all null) - C++ internal linkage
+static const ORBPathCallbacks empty_path_callbacks = {
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+};
+
+// Empty path (storage = null)
+const ORBPath ORBPathEmpty = {
+    nullptr,
+    &empty_path_callbacks,
+};
+
+// Null path (storage = 0x1)
+const ORBPath ORBPathNull = {
+    reinterpret_cast<ORBPathStorage *>(0x1),
+    &empty_path_callbacks,
+};
 
 void ORBPathRetain(ORBPath path) {
-    // TODO
+    auto retain = path.callbacks->retain;
+    if (retain != nullptr) {
+        retain(&path);
+    }
 }
 
 void ORBPathRelease(ORBPath path) {
-    // TODO
+    auto release = path.callbacks->release;
+    if (release != nullptr) {
+        release(&path);
+    }
+}
+
+#if ORB_TARGET_OS_DARWIN
+
+// MARK: - Path Creation
+
+// TODO: TO be implemented natively
+
+ORBPath ORBPathMakeWithCGPath(CGPathRef cgPath) {
+    if (cgPath == nullptr) {
+        return ORBPathNull;
+    }
+    CFRetain(cgPath);
+    return ORBPath {
+        reinterpret_cast<ORBPathStorage *>(const_cast<CGPath *>(cgPath)),
+        &ORBPathCGPathCallbacks,
+    };
 }
+
+ORBPath ORBPathMakeRect(CGRect rect, const CGAffineTransform *transform) {
+    CGPathRef cgPath = CGPathCreateWithRect(rect, transform);
+    ORBPath path = {
+        reinterpret_cast<ORBPathStorage *>(const_cast<CGPath *>(cgPath)),
+        &ORBPathCGPathCallbacks,
+    };
+    return path;
+}
+
+ORBPath ORBPathMakeEllipse(CGRect rect, const CGAffineTransform *transform) {
+    CGPathRef cgPath = CGPathCreateWithEllipseInRect(rect, transform);
+    ORBPath path = {
+        reinterpret_cast<ORBPathStorage *>(const_cast<CGPath *>(cgPath)),
+        &ORBPathCGPathCallbacks,
+    };
+    return path;
+}
+
+ORBPath ORBPathMakeRoundedRect(CGRect rect, CGFloat cornerWidth, CGFloat cornerHeight, ORBPathRoundedCornerStyle style, const CGAffineTransform *transform) {
+    // TODO: Handle ORBRoundedCornerStyleContinuous with custom bezier curves
+    CGPathRef cgPath = CGPathCreateWithRoundedRect(rect, cornerWidth, cornerHeight, transform);
+    ORBPath path = {
+        reinterpret_cast<ORBPathStorage *>(const_cast<CGPath *>(cgPath)),
+        &ORBPathCGPathCallbacks,
+    };
+    return path;
+}
+
+ORBPath ORBPathMakeUnevenRoundedRect(CGRect rect, CGFloat topLeftRadius, CGFloat bottomLeftRadius, CGFloat bottomRightRadius, CGFloat topRightRadius, ORBPathRoundedCornerStyle style, const CGAffineTransform *transform) {
+    // TODO: Handle ORBRoundedCornerStyleContinuous with custom bezier curves
+    CGMutablePathRef cgPath = CGPathCreateMutable();
+
+    CGFloat minX = CGRectGetMinX(rect);
+    CGFloat minY = CGRectGetMinY(rect);
+    CGFloat maxX = CGRectGetMaxX(rect);
+    CGFloat maxY = CGRectGetMaxY(rect);
+
+    // Start at top-left corner (after the rounded corner)
+    CGPathMoveToPoint(cgPath, transform, minX + topLeftRadius, minY);
+
+    // Top edge and top-right corner
+    CGPathAddLineToPoint(cgPath, transform, maxX - topRightRadius, minY);
+    CGPathAddArc(cgPath, transform, maxX - topRightRadius, minY + topRightRadius, topRightRadius, -M_PI_2, 0, false);
+
+    // Right edge and bottom-right corner
+    CGPathAddLineToPoint(cgPath, transform, maxX, maxY - bottomRightRadius);
+    CGPathAddArc(cgPath, transform, maxX - bottomRightRadius, maxY - bottomRightRadius, bottomRightRadius, 0, M_PI_2, false);
+
+    // Bottom edge and bottom-left corner
+    CGPathAddLineToPoint(cgPath, transform, minX + bottomLeftRadius, maxY);
+    CGPathAddArc(cgPath, transform, minX + bottomLeftRadius, maxY - bottomLeftRadius, bottomLeftRadius, M_PI_2, M_PI, false);
+
+    // Left edge and top-left corner
+    CGPathAddLineToPoint(cgPath, transform, minX, minY + topLeftRadius);
+    CGPathAddArc(cgPath, transform, minX + topLeftRadius, minY + topLeftRadius, topLeftRadius, M_PI, M_PI + M_PI_2, false);
+
+    CGPathCloseSubpath(cgPath);
+
+    ORBPath path = {
+        reinterpret_cast<ORBPathStorage *>(cgPath),
+        &ORBPathCGPathCallbacks,
+    };
+    return path;
+}
+
+CGPathRef ORBPathCopyCGPath(ORBPath path) {
+    // TODO: Return a retained copy of the CGPath
+    return nullptr;
+}
+
+bool ORBPathContainsPoint(ORBPath path, CGPoint point, bool eoFill) {
+    return ORBPathContainsPoints(path, 1, &point, eoFill, nullptr);
+}
+
+bool ORBPathContainsPoints(ORBPath path, uint64_t count, const CGPoint *points, bool eoFill, const CGAffineTransform *transform) {
+    // TODO: Implement point containment testing with winding rule
+    return false;
+}
+
+#endif /* ORB_TARGET_OS_DARWIN */

Sources/OpenRenderBox/Path/ORBPathCallbacks.cpp

@@ -0,0 +1,75 @@
+//
+//  ORBPathCallbacks.cpp
+//  OpenRenderBox
+//
+//  Audited for 6.5.1
+//  Status: Complete
+
+#include <OpenRenderBox/ORBPathCallbacks.h>
+#include <OpenRenderBoxCxx/Util/assert.hpp>
+
+#if ORB_TARGET_OS_DARWIN
+
+CG_EXTERN size_t CGPathGetNumberOfPoints(CGPathRef cg_nullable path);
+CG_EXTERN size_t CGPathGetNumberOfElements(CGPathRef cg_nullable path);
+typedef void (^CGPathApplyBlock2)(const CGPathElement * element, bool *stop);
+CG_EXTERN void CGPathApplyWithBlock2(CGPathRef path, CGPathApplyBlock2 CF_NOESCAPE block);
+
+namespace {
+    uint32_t cgpath_bezier_order(CGPathRef cgPath) {
+        size_t pointsCount = CGPathGetNumberOfPoints(cgPath);
+        size_t elementsCount = CGPathGetNumberOfElements(cgPath);
+        if (pointsCount > elementsCount) { return 3; }
+        if (pointsCount != 3 || elementsCount != 3) { return 1; }
+        bool hasCurve = false;
+        CGPathApply(cgPath, &hasCurve, [](void *info, const CGPathElement *element) {
+            if (element->type == kCGPathElementAddQuadCurveToPoint
+                || element->type == kCGPathElementAddCurveToPoint) {
+                *static_cast<bool*>(info) = true;
+            }
+        });
+        return hasCurve ? 3 : 1;
+    }
+}
+
+const ORBPathCallbacks ORBPathCGPathCallbacks = {
+    nullptr,
+    CFRetain,
+    CFRelease,
+    +[](const void *object, void *info, ORBPathApplyCallback callback) -> bool {
+        CGPathRef cgPath = reinterpret_cast<CGPathRef>(object);
+        __block bool shouldStop = false;
+        CGPathApplyWithBlock2(cgPath, ^(const CGPathElement *element, bool *stop) {
+            bool result = callback(info,
+                                   (ORBPathElement)element->type,
+                                   (CGFloat *)element->points,
+                                   nullptr);
+            if (!result) {
+                *stop = true;
+                shouldStop = true;
+            }
+        });
+        return !shouldStop;
+    },
+    +[](const void *object, const void *otherObject) -> bool {
+        return CGPathEqualToPath(static_cast<CGPathRef>(object), static_cast<CGPathRef>(otherObject));
+    },
+    +[](const void *object) -> bool {
+        return CGPathIsEmpty(static_cast<CGPathRef>(object));
+    },
+    +[](const void *object) -> bool {
+        return false;
+    },
+    +[](const void *object) -> uint32_t {
+        return cgpath_bezier_order(static_cast<CGPathRef>(object));
+    },
+    +[](const void *object) -> CGRect {
+        return CGPathGetPathBoundingBox(static_cast<CGPathRef>(object));
+    },
+    +[](const void *object) -> CGPathRef {
+        return static_cast<CGPathRef>(object);
+    },
+    nullptr,
+};
+
+#endif /* ORB_TARGET_OS_DARWIN */

Sources/OpenRenderBox/Path/ORBPathStorage.cpp

@@ -24,7 +24,17 @@ void ORBPathStorageClear(ORBPathStorageRef storage) {
     storage->storage.clear();
 }
 
-// ...
+bool ORBPathStorageAppendElement(ORBPathStorageRef storage, ORBPathElement element, double const * points, const void * userInfo) {
+    precondition_failure("TODO");
+}
+
+void ORBPathStorageAppendPath(ORBPathStorageRef storage, ORBPath path) {
+    precondition_failure("TODO");
+}
+
+void ORBPathStorageApplyElements(ORBPathStorageRef, void *info, ORBPathApplyCallback callback) {
+    precondition_failure("TODO");
+}
 
 bool ORBPathStorageIsEmpty(ORBPathStorageRef storage) {
     return storage->storage.isEmpty();

Sources/OpenRenderBox/Path/PathStorage.cpp

@@ -5,10 +5,24 @@
 #include <OpenRenderBoxCxx/Path/PathStorage.hpp>
 #include <OpenRenderBoxCxx/Util/assert.hpp>
 
+#if ORB_TARGET_OS_DARWIN
+#include <CoreGraphics/CoreGraphics.h>
+#endif
+
 namespace ORB {
 namespace Path {
 atomic_long Storage::_last_identifier;
 
+Storage::Storage(uint32_t capacity) {
+    _unknown = nullptr;
+    if (capacity <= 63) {
+        precondition_failure("invalid capacity");
+    }
+    uint32_t cappedCapacity = fmin(capacity - 16, 4095);
+    _flags = StorageFlags().withCapacity(cappedCapacity);
+    _identifier = get_identifier();
+}
+
 Storage::Storage(uint32_t capacity, const Storage &storage): Storage(capacity) {
     uint32_t originalCapity = flags().capacity();
     StorageFlags sourceFlags = storage.flags();
@@ -44,8 +58,8 @@ Storage::Storage(uint32_t capacity, const Storage &storage): Storage(capacity) {
 }
 
 Storage::~Storage() {
-    if (_unknonw != nullptr) {
-        _unknonw = nullptr;
+    if (_unknown != nullptr) {
+        _unknown = nullptr;
         // TODO
     }
 }
@@ -59,5 +73,16 @@ void Storage::clear() {
     // TODO
 }
 
+void * Storage::cgpath() const ORB_NOEXCEPT {
+    if (_flags.isInline()) {
+        return nullptr;
+    }
+    if (_cached_cgPath != nullptr) {
+        return _cached_cgPath;
+    }
+    // TODO: Create CGPath via RBPathCopyCGPath
+    return nullptr;
+}
+
 } /* Path */
 } /* ORB */

Sources/OpenRenderBox/Util/assert.cpp

@@ -19,7 +19,7 @@ void precondition_failure(const char *format, ...) {
         os_log_error(error_log(), "precondition failure: %s", s);
         #endif /* ORB_TARGET_OS_DARWIN */
         if (error_message == nullptr) {
-            asprintf(&error_message, "OpenGraph precondition failure: %s.\n", s);
+            asprintf(&error_message, "OpenRenderBox precondition failure: %s.\n", s);
         }
         free(s);
     }