Merge pull request #15 from PureSwift/feature/sdl1

Add SDL 1.2 wrappers

Author: colemancda

.github/workflows/swift.yml

@@ -14,7 +14,7 @@ jobs:
     - name: Swift Version
       run: swift --version
     - name: Install dependencies
-      run: brew install sdl2 sdl3 sdl2_image sdl2_mixer sdl3_image sdl3_mixer
+      run: brew install sdl12-compat sdl2 sdl3 sdl2_image sdl2_mixer sdl3_image sdl3_mixer
     - name: Build
       run: swift build -c ${{ matrix.config }}
 
@@ -34,7 +34,7 @@ jobs:
       run: swift --version
     - name: Install dependencies
       run: |
-        apt-get update && apt-get install -y libsdl2-dev libsdl2-image-dev libsdl2-mixer-dev \
+        apt-get update && apt-get install -y libsdl1.2-dev libsdl2-dev libsdl2-image-dev libsdl2-mixer-dev \
         cmake ninja-build pkg-config \
         libasound2-dev libpulse-dev libaudio-dev libfribidi-dev libjack-dev libsndio-dev \
         libx11-dev libxext-dev libxrandr-dev libxcursor-dev libxfixes-dev libxi-dev libxss-dev libxtst-dev \

Package.swift

@@ -4,6 +4,10 @@ import PackageDescription
 let package = Package(
     name: "SDL",
     products: [
+        .library(
+            name: "SDL1Swift",
+            targets: ["SDL1Swift"]
+        ),
         .library(
             name: "SDL2Swift",
             targets: ["SDL2Swift"]
@@ -54,6 +58,21 @@ let package = Package(
             name: "SDLDemo",
             dependencies: ["SDL2Swift"]
         ),
+        // Named `SDL1Swift` (not `SDL1`) so the built module doesn't share a name
+        // with the `SDL` system library, which would shadow `-lSDL` when linking.
+        .target(
+            name: "SDL1Swift",
+            dependencies: ["CSDL"],
+            path: "Sources/SDL1"
+        ),
+        .systemLibrary(
+            name: "CSDL",
+            pkgConfig: "sdl",
+            providers: [
+                .brew(["sdl12-compat"]),
+                .apt(["libsdl1.2-dev"])
+            ]
+        ),
         // Named `SDL2Swift` (not `SDL2`) so the built module doesn't share a name
         // with the `SDL2` system library, which would shadow `-lSDL2` when linking.
         .target(
@@ -137,6 +156,9 @@ let package = Package(
                 .apt(["libsdl3-mixer-dev"])
             ]
         ),
+        .testTarget(
+            name: "SDL1Tests",
+            dependencies: ["SDL1Swift"]),
         .testTarget(
             name: "SDL2Tests",
             dependencies: ["SDL2Swift"]),

Sources/CSDL/module.modulemap

@@ -0,0 +1,5 @@
+module CSDL [system] {
+    header "shim.h"
+    link "SDL"
+    export *
+}

Sources/CSDL/shim.h

@@ -0,0 +1,5 @@
+#ifdef __APPLE__
+#include "/opt/homebrew/include/SDL/SDL.h"
+#else
+#include <SDL/SDL.h>
+#endif

Sources/SDL1/BitMaskOption.swift

@@ -0,0 +1,194 @@
+//
+//  BitMaskOption.swift
+//  SDL1
+//
+//  Created by Alsey Coleman Miller on 6/6/17.
+//
+
+/// Enum that represents a bit mask flag / option.
+///
+/// Basically `Swift.OptionSet` for enums.
+public protocol BitMaskOption: RawRepresentable, Hashable, CaseIterable where RawValue: FixedWidthInteger { }
+
+public extension Sequence where Element: BitMaskOption {
+
+    /// Convert Swift enums for bit mask options into their raw values OR'd.
+    var rawValue: Element.RawValue {
+
+        @inline(__always)
+        get { return reduce(0, { $0 | $1.rawValue }) }
+    }
+}
+
+public extension BitMaskOption {
+
+    /// Whether the enum case is present in the raw value.
+    @inline(__always)
+    func isContained(in rawValue: RawValue) -> Bool {
+
+        return (self.rawValue & rawValue) != 0
+    }
+
+    @inline(__always)
+    static func from(rawValue: RawValue) -> [Self] {
+
+        return Self.allCases.filter { $0.isContained(in: rawValue) }
+    }
+}
+
+// MARK: - BitMaskOptionSet
+
+/// Integer-backed array type for `BitMaskOption`.
+///
+/// The elements are packed in the integer with bitwise math and stored on the stack.
+public struct BitMaskOptionSet <Element: BitMaskOption>: RawRepresentable {
+
+    public typealias RawValue = Element.RawValue
+
+    public private(set) var rawValue: RawValue
+
+    @inline(__always)
+    public init(rawValue: RawValue) {
+
+        self.rawValue = rawValue
+    }
+
+    @inline(__always)
+    public init() {
+
+        self.rawValue = 0
+    }
+
+    public static var all: BitMaskOptionSet<Element> {
+
+        return BitMaskOptionSet<Element>(rawValue: Element.allCases.rawValue)
+    }
+
+    @inline(__always)
+    public mutating func insert(_ element: Element) {
+
+        rawValue = rawValue | element.rawValue
+    }
+
+    @discardableResult
+    public mutating func remove(_ element: Element) -> Bool {
+
+        guard contains(element) else { return false }
+
+        rawValue = rawValue & ~element.rawValue
+
+        return true
+    }
+
+    @inline(__always)
+    public mutating func removeAll() {
+
+        self.rawValue = 0
+    }
+
+    @inline(__always)
+    public func contains(_ element: Element) -> Bool {
+
+        return element.isContained(in: rawValue)
+    }
+
+    public func contains <S: Sequence> (_ other: S) -> Bool where S.Iterator.Element == Element {
+
+        for element in other {
+
+            guard element.isContained(in: rawValue)
+                else { return false }
+        }
+
+        return true
+    }
+
+    public var count: Int {
+
+        return Element.allCases.reduce(0, { $0 + ($1.isContained(in: rawValue) ? 1 : 0) })
+    }
+
+    public var isEmpty: Bool {
+
+        return rawValue == 0
+    }
+}
+
+// MARK: - Sequence Conversion
+
+public extension BitMaskOptionSet {
+
+    init<S: Sequence>(_ sequence: S) where S.Iterator.Element == Element {
+
+        self.rawValue = sequence.rawValue
+    }
+}
+
+// MARK: - Equatable
+
+extension BitMaskOptionSet: Equatable {
+
+    public static func == (lhs: BitMaskOptionSet, rhs: BitMaskOptionSet) -> Bool {
+
+        return lhs.rawValue == rhs.rawValue
+    }
+}
+
+// MARK: - CustomStringConvertible
+
+extension BitMaskOptionSet: CustomStringConvertible {
+
+    public var description: String {
+
+        return Element.from(rawValue: rawValue)
+            .sorted(by: { $0.rawValue < $1.rawValue })
+            .description
+    }
+}
+
+// MARK: - Hashable
+
+extension BitMaskOptionSet: Hashable {
+
+    #if swift(>=4.2)
+    public func hash(into hasher: inout Hasher) {
+
+        rawValue.hash(into: &hasher)
+    }
+    #else
+    public var hashValue: Int {
+
+        return rawValue.hashValue
+    }
+    #endif
+}
+
+// MARK: - ExpressibleByArrayLiteral
+
+extension BitMaskOptionSet: ExpressibleByArrayLiteral {
+
+    public init(arrayLiteral elements: Element...) {
+
+        self.init(elements)
+    }
+}
+
+// MARK: - ExpressibleByIntegerLiteral
+
+extension BitMaskOptionSet: ExpressibleByIntegerLiteral {
+
+    public init(integerLiteral value: UInt64) {
+
+        self.init(rawValue: numericCast(value))
+    }
+}
+
+// MARK: - Sequence
+
+extension BitMaskOptionSet: Sequence {
+
+    public func makeIterator() -> IndexingIterator<[Element]> {
+
+        return Element.from(rawValue: rawValue).makeIterator()
+    }
+}

Sources/SDL1/Color.swift

@@ -0,0 +1,36 @@
+//
+//  Color.swift
+//  SDL1
+//
+//  Created by Alsey Coleman Miller on 7/10/26.
+//
+
+import CSDL
+
+/// SDL Color
+///
+/// A single color entry, as used by palettes. SDL 1.2 colors carry no alpha channel.
+public struct SDLColor: Equatable, Hashable, Sendable {
+
+    public var red: UInt8
+
+    public var green: UInt8
+
+    public var blue: UInt8
+
+    public init(red: UInt8, green: UInt8, blue: UInt8) {
+        self.red = red
+        self.green = green
+        self.blue = blue
+    }
+
+    internal init(_ color: SDL_Color) {
+        self.red = color.r
+        self.green = color.g
+        self.blue = color.b
+    }
+
+    internal var internalValue: SDL_Color {
+        SDL_Color(r: red, g: green, b: blue, unused: 0)
+    }
+}

Sources/SDL1/CountableSet.swift

@@ -0,0 +1,63 @@
+//
+//  CountableSet.swift
+//  SDL1
+//
+//  Created by Alsey Coleman Miller on 10/19/18.
+//
+
+/// Static Integer-based array for use on the stack.
+///
+/// Allows a count value to be used a collection.
+/// Each element is basically a valid index in the collection (e.g. `0 ..< count`).
+public struct CountableSet <Element: IndexRepresentable>: Collection {
+
+    public typealias Index = Int
+
+    public init(count: Int) {
+
+        precondition(count >= 0, "Invalid negative value \(count)")
+
+        self.count = count
+    }
+
+    public var count: Int
+
+    public subscript (index: Index) -> Element {
+
+        assert(index < count, "Invalid index")
+
+        return Element(rawValue: index)
+    }
+
+    /// The start `Index`.
+    public var startIndex: Index {
+        return 0
+    }
+
+    /// The end `Index`.
+    ///
+    /// This is the "one-past-the-end" position, and will always be equal to the `count`.
+    public var endIndex: Index {
+        return count
+    }
+
+    public func index(before i: Index) -> Index {
+        return i - 1
+    }
+
+    public func index(after i: Index) -> Index {
+        return i + 1
+    }
+
+    public func makeIterator() -> IndexingIterator<CountableSet<Element>> {
+        return IndexingIterator(_elements: self)
+    }
+}
+
+/// A struct wrapper that represents an index value.
+public protocol IndexRepresentable: RawRepresentable, Hashable {
+
+    init(rawValue: Int)
+
+    var rawValue: Int { get }
+}