Package.swift

// swift-tools-version:5.9
// The swift-tools-version declares the minimum version of Swift required to build this package.

import PackageDescription

let package = Package(
    name: "GateEngine",
    platforms: [.macOS(.v10_15), .iOS(.v13), .tvOS(.v13)],
    products: [
        .library(name: "GateEngine", targets: ["GateEngine"]),
        .library(name: "GameMath", targets: ["GameMath"]),
    ],
    dependencies: {
        var packageDependencies: [Package.Dependency] = []

        // Official
        #if os(Windows)
        packageDependencies.append(
            // Windows requires 1.2.0+
            .package(url: "https://github.com/apple/swift-atomics.git", .upToNextMajor(from: "1.2.0"))
        )
        #else
        packageDependencies.append(
            // swift-atomics must use extact 1.1.0 pending https://github.com/apple/swift/issues/69264
            .package(url: "https://github.com/apple/swift-atomics.git", exact: "1.1.0")
        )
        #endif
        packageDependencies.append(
            .package(url: "https://github.com/apple/swift-collections.git", .upToNextMajor(from: "1.0.0"))
        )

        // SwiftWASM
        #if os(macOS) || os(Linux)
        packageDependencies.append(contentsOf: [
            .package(url: "https://github.com/swiftwasm/WebAPIKit.git", .upToNextMajor(from: "0.1.0")),
            .package(url: "https://github.com/swiftwasm/JavaScriptKit.git", .upToNextMajor(from: "0.16.0")),
        ])
        #endif
        
        // Linting / Formating
        packageDependencies.append(contentsOf: [
            //.package(url: "https://github.com/apple/swift-format", .upToNextMajor(from: "509.0.0")),
            //.package(url: "https://github.com/realm/SwiftLint.git", .upToNextMajor(from: "0.52.0")),
        ])
        
        return packageDependencies
    }(),
    targets: {
        var targets: [Target] = []
        targets.append(contentsOf: [
            .target(name: "GateEngine",
                    dependencies: {
                        var dependencies: [Target.Dependency] = []
                        dependencies.append(contentsOf: [
                            "GameMath",
                            "Shaders",
                            "TrueType",
                            "LibSPNG",
                            "Gravity",
                            "uFBX",
                        ])
                        dependencies.append(
                            .target(name: "Vorbis",
                                    condition: .when(platforms: .any(except: .wasi)))
                        )
                        
                        #if os(macOS) || os(Linux)
                        dependencies.append(
                            .target(name: "OpenGL_GateEngine",
                                    condition: .when(platforms: .any(except: .windows, .wasi)))
                        )
                        #endif
                        
                        #if os(Windows)
                        dependencies.append(contentsOf: [
                            .target(name: "Direct3D12",
                                    condition: .when(platforms: [.windows])),
                            .target(name: "XAudio2",
                                    condition: .when(platforms: [.windows])),
                        ])
                        #endif
                        
                        #if os(Linux)
                        dependencies.append(contentsOf: [
                            .target(name: "LinuxSupport",
                                    condition: .when(platforms: [.linux, .android])),
                            //.target(name: "OpenALSoft",
                            //        condition: .when(platforms: [.linux, .android])),
                        ])
                        #endif
                        
                        dependencies.append(contentsOf: [
                            .product(name: "Atomics",
                                     package: "swift-atomics"),
                            .product(name: "Collections",
                                     package: "swift-collections")
                        ])

                        #if os(macOS) || os(Linux)
                        dependencies.append(contentsOf: [
                            .product(name: "JavaScriptEventLoop",
                                     package: "JavaScriptKit",
                                     condition: .when(platforms: [.wasi])),
                            .product(name: "DOM",
                                     package: "WebAPIKit",
                                     condition: .when(platforms: [.wasi])),
                            .product(name: "FileSystem",
                                     package: "WebAPIKit",
                                     condition: .when(platforms: [.wasi])),
                            .product(name: "WebAudio",
                                     package: "WebAPIKit",
                                     condition: .when(platforms: [.wasi])),
                            .product(name: "Gamepad",
                                     package: "WebAPIKit",
                                     condition: .when(platforms: [.wasi])),
                            .product(name: "WebGL2",
                                     package: "WebAPIKit",
                                     condition: .when(platforms: [.wasi])),
                        ])
                        #endif
                        
                        return dependencies
                    }(),
                    resources: [
                        .copy("Resources/_PackageResources/GateEngine"),
                    ],
                    cSettings: [
                        .define("GL_SILENCE_DEPRECATION",
                            .when(platforms: [.macOS])),
                        .define("GLES_SILENCE_DEPRECATION",
                            .when(platforms: [.iOS, .tvOS])),
                    ],
                    swiftSettings: {
                        var settings: [SwiftSetting] = []

                        settings.append(
                            .define("GATEENGINE_USE_OPENAL", .when(platforms: [.linux]))
                        )
                        
                        // MARK: Gate Engine options.
                        settings.append(contentsOf: [
                            /// Closes all open windows when the main window is closed
                            .define("GATEENGINE_CLOSES_ALLWINDOWS_WITH_MAINWINDOW",
                                .when(platforms: .desktop)),
                            /// Checks for reloadable resources and reloads them if they have changed
                            .define("GATEENGINE_ENABLE_HOTRELOADING",
                                .when(platforms: .desktop, configuration: .debug)),
                            /// The host platform requests the main window, so GateEngine won't create one until it's requested
                            .define("GATEENGINE_PLATFORM_CREATES_MAINWINDOW",
                                .when(platforms: [.iOS, .tvOS])),
                            /// The host platform updates and draws from an event callback, so GateEngine won't create a game loop.
                            .define("GATEENGINE_PLATFORM_EVENT_DRIVEN",
                                    .when(platforms: .any)),
                            /// The host platform requires an intermediate task, so GateEngine won't load default systems.
                            .define("GATEENGINE_PLATFORM_DEFERS_LAUNCH",
                                .when(platforms: [.wasi])),
                            /// The host platform supports file system read/write
                            .define("GATEENGINE_PLATFORM_HAS_FILESYSTEM",
                                .when(platforms: .any)),
                            /// The host platform supports Foundation.FileManager
                            .define("GATEENGINE_PLATFORM_FOUNDATION_FILEMANAGER",
                                .when(platforms: .any(except: .wasi))),
                        ])
                        #if !(os(macOS) || os(Linux))
                        /// The host platform can't be used to compile HTML5 products
                        settings.append(.define("GATEENGINE_WASI_UNSUPPORTED_HOST", .when(platforms: [.wasi])))
                        #endif

                        #if false // Experimental and upcomming language features.
                        // These should be disabled for releases.
                        // These are to get a headstart on the next Swift versions.
                        // https://www.swift.org/swift-evolution/#?upcoming=true
                        settings.append(contentsOf: [
                            .enableUpcomingFeature("IsolatedDefaultValues"),
                            .enableUpcomingFeature("InternalImportsByDefault"),
                            .enableUpcomingFeature("DisableOutwardActorInference"),
                            .enableUpcomingFeature("ImportObjcForwardDeclarations"),
                            .enableUpcomingFeature("BareSlashRegexLiterals"),
                            .enableUpcomingFeature("ExistentialAny"),
                            .enableUpcomingFeature("ForwardTrailingClosures"),
                            .enableUpcomingFeature("ConciseMagicFile"),
                            .enableUpcomingFeature("DynamicActorIsolation"),
                            .enableUpcomingFeature("FullTypedThrows"),
                            .enableUpcomingFeature("InferSendableFromCaptures"),
                            .enableUpcomingFeature("DeprecateApplicationMain"),
                            
                            .enableExperimentalFeature("AccessLevelOnImport"),
//                            .enableExperimentalFeature("StrictConcurrency"),
//                            .enableExperimentalFeature("StrictConcurrency=minimal"),
                            .enableExperimentalFeature("StrictConcurrency=complete"),
                        ])
                        #endif
                        
                        #if false // Options for development of GateEngine. These should be disabled for tagged version releases.
                        #warning("GateEngine development options are enabled. These can cause strange build errors on some platforms.")
                        
                        // Options for development of WASI platform
                        #if false
                        settings.append(contentsOf: [
                            /// Allows HTML5 platform to be compiled from a compatible host, such as macOS.
                            /// This allows the IDE to show compile errors without targeting WASI.
                            .define("GATEENGINE_ENABLE_WASI_IDE_SUPPORT",
                                .when(platforms: [.macOS, .linux], configuration: .debug)),
                            /// see comment in "Gate Engine options".
                            .define("GATEENGINE_PLATFORM_EVENT_DRIVEN",
                                .when(platforms: [.macOS, .linux, .wasi], configuration: .debug)),
                        ])
                        #endif
                        
                        settings.append(contentsOf: [
                            /// Prints the output of generated shaders
                            .define("GATEENGINE_DEBUG_LAYOUT"),
                            /// Prints the output of generated shaders
                            //.define("GATEENGINE_LOG_SHADERS"),
                            /// Enables various additional checks and output for rendering
                            .define("GATEENGINE_DEBUG_RENDERING"),
                            /// Enables various additional checks and output for input
                            //.define("GATEENGINE_DEBUG_HID"),
                            /// Enables varius additional, additional, checks and output for input
                            //.define("GATEENGINE_DEBUG_HID_VERBOSE"),
                            /// Forces Apple platforms to use OpenGL for rendering
                            //.define("GATEENGINE_FORCE_OPNEGL_APPLE", .when(platforms: [.macOS, /*.iOS, .tvOS*/])),
                        ])
                        #endif
                        return settings
                    }(),
                    plugins: [
                        //.plugin(name: "SwiftLintPlugin", package: "SwiftLint"),
                    ]),
            
            .target(name: "Shaders",
                    dependencies: [
                        "GameMath",
                        .product(name: "Collections", package: "swift-collections")
                    ], swiftSettings: [
                        .define("GATEENGINE_DEBUG_SHADERS", .when(configuration: .debug))
                    ]),
            
            .target(name: "GameMath", swiftSettings: {
                var array: [SwiftSetting] = []
                
                #if false
                // Possibly faster on old hardware, but less accurate.
                // There is no reason to use this on modern hardware.
                array.append(.define("GameMathUseFastInverseSquareRoot"))
                #endif
                
                // These settings are faster only with optimization.
                #if true
                array.append(.define("GameMathUseSIMD", .when(configuration: .release)))
                array.append(.define("GameMathUseLoopVectorization", .when(configuration: .release)))
                #endif
                
                return array.isEmpty ? nil : array
            }()),
        ])
        
        // MARK: - Dependencies
        
        targets.append(contentsOf: [
            // Vorbis
            .target(name: "Vorbis",
                    path: "Dependencies/Vorbis",
                    publicHeadersPath: "include",
                    cSettings: [
                        .define("extern", to: "__declspec(dllexport) extern", .when(platforms: [.windows]))
                    ]),
            
            // miniz
            .target(name: "miniz",
                    path: "Dependencies/miniz",
                    cSettings: [
                        .define("_CRT_SECURE_NO_WARNINGS", .when(platforms: [.windows])),
                    ]),
            
            // libspng
            .target(name: "LibSPNG",
                    dependencies: ["miniz"],
                    path: "Dependencies/LibSPNG",
                    cSettings: [
                        .define("SPNG_STATIC"),
                        .define("SPNG_USE_MINIZ"),
                        // When public, the miniz.h header crashes Clang on Windows since Swift 5.8.0
                        .headerSearchPath("src/"),
                        .define("_CRT_SECURE_NO_WARNINGS", .when(platforms: [.windows])),
                    ]),
            
            // TrueType
            .target(name: "TrueType",
                    path: "Dependencies/TrueType",
                    cSettings: [
                        .define("STB_TRUETYPE_IMPLEMENTATION"), .define("STB_RECT_PACK_IMPLEMENTATION"),
                        .define("extern", to: "__declspec(dllexport) extern", .when(platforms: [.windows])),
                        .define("_CRT_SECURE_NO_WARNINGS", .when(platforms: [.windows])), // Silence warnings
                    ]),
            
            // Gravity
            .target(name: "Gravity",
                    path: "Dependencies/Gravity",
                    cSettings: [
                        .define("BUILD_GRAVITY_API"),
                        // WASI doesn't have umask
                        .define("umask(x)", to: "022", .when(platforms: [.wasi])),
                        .define("_CRT_SECURE_NO_WARNINGS", .when(platforms: [.windows])),
                    ], linkerSettings: [
                        // For math functions
                        .linkedLibrary("m", .when(platforms: .any(except: .windows))),
                        // For path functions
                        .linkedLibrary("Shlwapi", .when(platforms: [.windows])),
                    ]),
            
            // uFBX
            .target(name: "uFBX",
                    path: "Dependencies/uFBX"),
        ])
        
        #if os(Windows)
        targets.append(contentsOf: [
            // Direct3D12
            .target(name: "Direct3D12",
                    path: "Dependencies/Direct3D12",
                    swiftSettings: [
                        .define("Direct3D12ExcludeOriginalStyleAPI", .when(configuration: .release)),
                    ]),
            // XAudio2
            .target(name: "XAudio2",
                    dependencies: ["XAudio2C"],
                    path: "Dependencies/XAudio/XAudio2"),
            .systemLibrary(name: "XAudio2C",
                           path: "Dependencies/XAudio/XAudio2C"),
        ])
        #endif
        
        #if os(macOS)
        targets.append(contentsOf: [
            .target(name: "OpenGL_GateEngine",
                    path: "Dependencies/OpenGL/OpenGL_GateEngine",
                    cSettings: [
                        .define("GL_SILENCE_DEPRECATION", .when(platforms: [.macOS])),
                        .define("GLES_SILENCE_DEPRECATION", .when(platforms: [.iOS, .tvOS])),
                    ])
        ])
        #endif
        
        #if os(Linux) || os(Android)
        targets.append(contentsOf: [
            // LinuxSupport
            .target(name: "LinuxSupport",
                    dependencies: [
                        .targetItem(name: "LinuxImports",
                                    condition: .when(platforms: [.linux])),
                        .targetItem(name: "LinuxExtensions",
                                    condition: .when(platforms: [.linux]))
                    ],
                    path: "Dependencies/LinuxSupport/LinuxSupport"),
            .target(name: "LinuxExtensions",
                    path: "Dependencies/LinuxSupport/LinuxExtensions"),
            .systemLibrary(name: "LinuxImports",
                           path: "Dependencies/LinuxSupport/LinuxImports"),
            
            // OpenGL
            .systemLibrary(name: "OpenGL_Linux",
                           path: "Dependencies/OpenGL/OpenGL_Linux"),
            .target(name: "OpenGL_GateEngine",
                    dependencies: ["OpenGL_Linux"],
                    path: "Dependencies/OpenGL/OpenGL_GateEngine")
        ])
        #endif
        
        #if os(Linux) || os(Android)
        targets.append(contentsOf: [
        // OpenALSoft
        .target(name: "OpenALSoft",
                path: "Dependencies/OpenAL/OpenALSoft",
                sources: openALSources,
                publicHeadersPath: "UnmodifiedSource/include",
                cSettings: openALCSettings,
                linkerSettings: openALLinkerSettings),
        ])
        #endif
        
        
        // MARK: - Tests
        
        targets.append(contentsOf: [
            .testTarget(name: "GateEngineTests",
                        dependencies: ["GateEngine"],
                        resources: [.copy("Resources")],
                        swiftSettings: [
                            .define("DISABLE_GRAVITY_TESTS", .when(platforms: [.wasi])),
                        ]),
            .testTarget(name: "GameMathTests",
                        dependencies: ["GameMath"]),
            .testTarget(name: "GravityTests",
                        dependencies: ["Gravity", "GateEngine"],
                        resources: [
                            .copy("Resources/disabled"),
                            .copy("Resources/fuzzy"),
                            .copy("Resources/infiniteloop"),
                            .copy("Resources/unittest"),
                        ],
                        swiftSettings: [
                            // https://github.com/STREGAsGate/GateEngine/issues/36
                            .define("DISABLE_GRAVITY_TESTS", .when(platforms: [.wasi])),
                        ]),
        ])
        #if !os(Windows)
        targets.append(contentsOf: [
            .testTarget(name: "GameMathSIMDTests",
                        dependencies: ["GameMath"],
                        swiftSettings: [
                            .define("GameMathUseSIMD"),
                            .define("GameMathUseLoopVectorization")
                        ]),
        ])
        #endif
        
        return targets
    }(),
    swiftLanguageVersions: [.v5],
    cLanguageStandard: .gnu11,
    cxxLanguageStandard: .gnucxx14
)

#if os(Linux) || os(Android)
var openALLinkerSettings: [LinkerSetting] {
    var array: [LinkerSetting] = []
    
    array.append(contentsOf: [
        .linkedFramework("AudioToolbox", .when(platforms: .anyApple)),
        .linkedFramework("CoreFoundation", .when(platforms: .anyApple)),
        .linkedFramework("CoreAudio", .when(platforms: .anyApple)),
    ])
    // array.append(contentsOf: [
    //     .linkedLibrary("winmm", .when(platforms: [.windows])),
    //     .linkedLibrary("kernel32", .when(platforms: [.windows])),
    //     .linkedLibrary("user32", .when(platforms: [.windows])),
    //     .linkedLibrary("gdi32", .when(platforms: [.windows])),
    //     .linkedLibrary("winspool", .when(platforms: [.windows])),
    //     .linkedLibrary("shell32", .when(platforms: [.windows])),
    //     .linkedLibrary("ole32", .when(platforms: [.windows])),
    //     .linkedLibrary("oleaut32", .when(platforms: [.windows])),
    //     .linkedLibrary("uuid", .when(platforms: [.windows])),
    //     .linkedLibrary("comdlg32", .when(platforms: [.windows])),
    //     .linkedLibrary("advapi32", .when(platforms: [.windows])),
    // ])

    return array
}

var openALCSettings: [CSetting] {
    var array: [CSetting] = []
    
    array.append(.headerSearchPath("ConfiguredSource/macOS/", .when(platforms: [.macOS])))
    array.append(.headerSearchPath("ConfiguredSource/Windows/", .when(platforms: [.windows])))
    array.append(.headerSearchPath("ConfiguredSource/Linux/", .when(platforms: [.linux])))
    array.append(.headerSearchPath("ConfiguredSource/iOS/", .when(platforms: [.iOS, .tvOS, .watchOS, .macCatalyst])))
    
    array.append(.headerSearchPath("UnmodifiedSource/"))
    array.append(.headerSearchPath("UnmodifiedSource/common/"))
    array.append(.headerSearchPath("UnmodifiedSource/core/mixer"))
    
    array.append(.headerSearchPath("UnmodifiedSource/alc/backends/", .when(platforms: [.windows])))
    array.append(.headerSearchPath("UnmodifiedSource/alc/effects/", .when(platforms: [.windows])))
    array.append(.headerSearchPath("UnmodifiedSource/core/", .when(platforms: [.windows])))
    array.append(.headerSearchPath("UnmodifiedSource/core/effects/", .when(platforms: [.windows])))
    array.append(.headerSearchPath("UnmodifiedSource/core/filters/", .when(platforms: [.windows])))
    
    array.append(.define("RESTRICT", to: "__restrict"))
    array.append(.define("AL_BUILD_LIBRARY"))
    array.append(.define("AL_ALEXT_PROTOTYPES"))
    
    array.append(.define("_CRT_SECURE_NO_WARNINGS", .when(platforms: [.windows]))) // Silence warnings
    array.append(.define("NOMINMAX", .when(platforms: [.windows])))
    array.append(.define("AL_NO_UID_DEFS", .when(platforms: [.windows])))
    
    array.append(.define("EXPORT_DECL", to: "__declspec(dllexport)", .when(platforms: [.windows])))
    array.append(.define("ALC_API", to: "__declspec(dllexport)", .when(platforms: [.windows])))
    array.append(.define("AL_API", to: "__declspec(dllexport)", .when(platforms: [.windows])))
    array.append(.define("_WIN32", .when(platforms: [.windows])))
        
    return array
}

var openALSources: [String] {
    var array: [String] = []
    let common = [
        "UnmodifiedSource/common/alcomplex.cpp",
        "UnmodifiedSource/common/alfstream.cpp",
        "UnmodifiedSource/common/almalloc.cpp",
        "UnmodifiedSource/common/alstring.cpp",
        "UnmodifiedSource/common/dynload.cpp",
        "UnmodifiedSource/common/polyphase_resampler.cpp",
        "UnmodifiedSource/common/ringbuffer.cpp",
        "UnmodifiedSource/common/strutils.cpp",
        "UnmodifiedSource/common/threads.cpp",
    ]
    array.append(contentsOf: common)
    
    let shared = [
        "UnmodifiedSource/al/auxeffectslot.cpp",
        "UnmodifiedSource/al/buffer.cpp",
        "UnmodifiedSource/al/effect.cpp",
        "UnmodifiedSource/al/effects/effects.cpp",
        "UnmodifiedSource/al/error.cpp",
        "UnmodifiedSource/al/event.cpp",
        "UnmodifiedSource/al/extension.cpp",
        "UnmodifiedSource/al/filter.cpp",
        "UnmodifiedSource/al/listener.cpp",
        "UnmodifiedSource/al/source.cpp",
        "UnmodifiedSource/al/state.cpp",
        "UnmodifiedSource/alc/alc.cpp",
        "UnmodifiedSource/alc/alconfig.cpp",
        "UnmodifiedSource/alc/alu.cpp",
        "UnmodifiedSource/alc/backends/base.cpp",
        "UnmodifiedSource/alc/backends/loopback.cpp",
        "UnmodifiedSource/alc/backends/wave.cpp",
        "UnmodifiedSource/alc/panning.cpp",
        "UnmodifiedSource/core/ambdec.cpp",
        "UnmodifiedSource/core/ambidefs.cpp",
        "UnmodifiedSource/core/bformatdec.cpp",
        "UnmodifiedSource/core/bs2b.cpp",
        "UnmodifiedSource/core/bsinc_tables.cpp",
        "UnmodifiedSource/core/buffer_storage.cpp",
        "UnmodifiedSource/core/converter.cpp",
        "UnmodifiedSource/core/cpu_caps.cpp",
        "UnmodifiedSource/core/devformat.cpp",
        "UnmodifiedSource/core/effectslot.cpp",
        "UnmodifiedSource/core/except.cpp",
        "UnmodifiedSource/core/filters/biquad.cpp",
        "UnmodifiedSource/core/filters/nfc.cpp",
        "UnmodifiedSource/core/filters/splitter.cpp",
        "UnmodifiedSource/core/fmt_traits.cpp",
        "UnmodifiedSource/core/fpu_ctrl.cpp",
        "UnmodifiedSource/core/helpers.cpp",
        "UnmodifiedSource/core/hrtf.cpp",
        "UnmodifiedSource/core/logging.cpp",
        "UnmodifiedSource/core/mastering.cpp",
        "UnmodifiedSource/core/mixer.cpp",
        "UnmodifiedSource/core/mixer/mixer_c.cpp",
        "UnmodifiedSource/core/uhjfilter.cpp",
        "UnmodifiedSource/core/uiddefs.cpp",
        "UnmodifiedSource/core/voice.cpp",
        "ConfiguredSource/core/mixer/mixer_neon.cpp",
        "ConfiguredSource/core/mixer/mixer_sse.cpp",
        "ConfiguredSource/core/mixer/mixer_sse2.cpp",
        "ConfiguredSource/core/mixer/mixer_sse3.cpp",
        "ConfiguredSource/core/mixer/mixer_sse41.cpp",
        "UnmodifiedSource/al/effects/autowah.cpp",
        "UnmodifiedSource/al/effects/chorus.cpp",
        "UnmodifiedSource/al/effects/compressor.cpp",
        "UnmodifiedSource/al/effects/convolution.cpp",
        "UnmodifiedSource/al/effects/dedicated.cpp",
        "UnmodifiedSource/al/effects/distortion.cpp",
        "UnmodifiedSource/al/effects/echo.cpp",
        "UnmodifiedSource/al/effects/equalizer.cpp",
        "UnmodifiedSource/al/effects/fshifter.cpp",
        "UnmodifiedSource/al/effects/modulator.cpp",
        "UnmodifiedSource/al/effects/null.cpp",
        "UnmodifiedSource/al/effects/pshifter.cpp",
        "UnmodifiedSource/al/effects/reverb.cpp",
        "UnmodifiedSource/al/effects/vmorpher.cpp",
        "UnmodifiedSource/alc/context.cpp",
        "UnmodifiedSource/alc/device.cpp",
        "UnmodifiedSource/alc/effects/autowah.cpp",
        "UnmodifiedSource/alc/effects/chorus.cpp",
        "UnmodifiedSource/alc/effects/compressor.cpp",
        "UnmodifiedSource/alc/effects/convolution.cpp",
        "UnmodifiedSource/alc/effects/dedicated.cpp",
        "UnmodifiedSource/alc/effects/distortion.cpp",
        "UnmodifiedSource/alc/effects/echo.cpp",
        "UnmodifiedSource/alc/effects/equalizer.cpp",
        "UnmodifiedSource/alc/effects/fshifter.cpp",
        "UnmodifiedSource/alc/effects/modulator.cpp",
        "UnmodifiedSource/alc/effects/null.cpp",
        "UnmodifiedSource/alc/effects/pshifter.cpp",
        "UnmodifiedSource/alc/effects/reverb.cpp",
        "UnmodifiedSource/alc/effects/vmorpher.cpp",
        "UnmodifiedSource/core/context.cpp",
        "UnmodifiedSource/core/device.cpp",
        "UnmodifiedSource/alc/backends/null.cpp",
    ]
    array.append(contentsOf: shared)
    
    #if os(Windows)
    let windows = [
        // "UnmodifiedSource/al/eax/api.cpp",
        // "UnmodifiedSource/al/eax/call.cpp",
        // "UnmodifiedSource/al/eax/exception.cpp",
        // "UnmodifiedSource/al/eax/fx_slot_index.cpp",
        // "UnmodifiedSource/al/eax/fx_slots.cpp",
        // "UnmodifiedSource/al/eax/globals.cpp",
        // "UnmodifiedSource/al/eax/utils.cpp",
        // not in WinSDK for Swift yet "UnmodifiedSource/alc/backends/dsound.cpp",
        // not in WinSDK for Swift yet "UnmodifiedSource/alc/backends/wasapi.cpp",
        "UnmodifiedSource/alc/backends/winmm.cpp",
    ]
    array.append(contentsOf: windows)
    #endif
    
    #if os(macOS)
    let macOS = [
        "UnmodifiedSource/alc/backends/coreaudio.cpp",
    ]
    array.append(contentsOf: macOS)
    #endif

    #if os(Linux)
    let linux = [
        "UnmodifiedSource/alc/backends/oss.cpp",
    ]
    array.append(contentsOf: linux)
    #endif
    return array
}
#endif


// Package.swift Helpers
extension Array where Element == Platform {
    static func any(except excluding: Platform...) -> Self {
        var array = self.any
        for platform in excluding {
            array.removeAll(where: {$0 == platform})
        }
        return array
    }
    
    static var desktop: Self {[.windows, .linux, .macOS]}
    static var mobile: Self {[.iOS, .android]}
    static var anyApple: Self {
        return [.macOS, .iOS, .tvOS, .watchOS, .visionOS]
    }
    
    static var any: Self {
        return [
            .macOS, .iOS, .tvOS, .visionOS,
            .linux, .android,
            .windows,
            .wasi
        ]
    }
}