wyvrnpm 2.0.2 → 2.1.0

package/cmake/functions.cmake

@@ -0,0 +1,224 @@
+# ── Internal helper ───────────────────────────────────────────────────────────
+# Collects all sources for the calling directory in three layers:
+#
+#   1. General sources  — all .cpp/.h/.hpp under CMAKE_CURRENT_SOURCE_DIR,
+#                         excluding HAL/, Platform/, and include/HAL|Platform/
+#   2. HAL common       — files sitting directly (non-recursive) in any HAL/ or
+#                         Platform/ root; these are platform-neutral shared headers
+#   3. HAL layered      — recursive sources from each applicable subdirectory,
+#                         resolved in order: family → leaf
+#
+#                         Family tiers (from variables.cmake derived vars):
+#                           microsoft  — Windows + Xbox
+#                           unix       — Linux + SteamOS + Android + Darwin + PlayStation
+#                           darwin     — macOS + iOS
+#                           playstation— PS4 + PS5
+#
+#                         Leaf dirs:
+#                           win  xbox  linux  steamos  mac  ios
+#                           android  ps4  ps5
+#
+#                         Search roots for both family and leaf dirs:
+#                           HAL/  Platform/  src/HAL/  src/Platform/
+#                           include/HAL/  include/Platform/
+#
+# Result is written to the variable named by <out_var> in the caller's scope.
+# Any additional arguments are treated as regex patterns to exclude from all source lists.
+function(_wyvrn_collect_sources out_var)
+    set(_extra_excludes ${ARGN})
+    file(GLOB_RECURSE _sources
+        "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp"
+        "${CMAKE_CURRENT_SOURCE_DIR}/*.h"
+        "${CMAKE_CURRENT_SOURCE_DIR}/*.hpp"
+    )
+    list(FILTER _sources EXCLUDE REGEX ".*[/\\\\]HAL[/\\\\].*")
+    list(FILTER _sources EXCLUDE REGEX ".*[/\\\\]Platform[/\\\\].*")
+    list(FILTER _sources EXCLUDE REGEX ".*[/\\\\]tests[/\\\\].*")
+    list(FILTER _sources EXCLUDE REGEX ".*[/\\\\]vendors[/\\\\].*")
+    list(FILTER _sources EXCLUDE REGEX ".*[/\\\\]wyvrn_internal[/\\\\].*")
+    list(FILTER _sources EXCLUDE REGEX ".*[/\\\\]build[/\\\\].*")
+    list(FILTER _sources EXCLUDE REGEX ".*[/\\\\]output[/\\\\].*")
+    
+    # Shared / platform-neutral files sitting directly in any HAL/ or Platform/ root
+    file(GLOB _hal_common
+        "${CMAKE_CURRENT_SOURCE_DIR}/HAL/*.*"
+        "${CMAKE_CURRENT_SOURCE_DIR}/Platform/*.*"
+        "${CMAKE_CURRENT_SOURCE_DIR}/src/HAL/*.*"
+        "${CMAKE_CURRENT_SOURCE_DIR}/src/Platform/*.*"
+        "${CMAKE_CURRENT_SOURCE_DIR}/include/HAL/*.*"
+        "${CMAKE_CURRENT_SOURCE_DIR}/include/Platform/*.*"
+    )
+
+    # Build an ordered list of HAL subdirectory names to search: family first, then leaf.
+    # Each entry is searched under every search root listed in _hal_roots below.
+    set(_plat_dirs)
+
+    # ── Family tiers ──────────────────────────────────────────────────────────
+    if(WYVRN_PLATFORM_MICROSOFT)
+        list(APPEND _plat_dirs microsoft)
+    endif()
+    if(WYVRN_PLATFORM_UNIX)
+        list(APPEND _plat_dirs unix)
+    endif()
+    if(WYVRN_PLATFORM_DARWIN)
+        list(APPEND _plat_dirs darwin)
+    endif()
+    if(WYVRN_PLATFORM_PLAYSTATION)
+        list(APPEND _plat_dirs playstation)
+    endif()
+
+    # ── Leaf tiers ────────────────────────────────────────────────────────────
+    # Exactly one leaf is set by variables.cmake; SteamOS also gets a linux pass
+    # first (most SteamOS-targeting code lives there) then a steamos overlay pass.
+    if(WYVRN_PLATFORM_WINDOWS)
+        list(APPEND _plat_dirs win)
+    elseif(WYVRN_PLATFORM_XBOX)
+        list(APPEND _plat_dirs xbox)
+    elseif(WYVRN_PLATFORM_PS5)
+        list(APPEND _plat_dirs ps5)
+    elseif(WYVRN_PLATFORM_PS4)
+        list(APPEND _plat_dirs ps4)
+    elseif(WYVRN_PLATFORM_ANDROID)
+        list(APPEND _plat_dirs android)
+    elseif(WYVRN_PLATFORM_IOS)
+        list(APPEND _plat_dirs ios)
+    elseif(WYVRN_PLATFORM_MACOS)
+        list(APPEND _plat_dirs mac)
+    elseif(WYVRN_PLATFORM_STEAMOS)
+        list(APPEND _plat_dirs linux steamos)
+    elseif(WYVRN_PLATFORM_LINUX)
+        list(APPEND _plat_dirs linux)
+    endif()
+
+    # All directory roots that may contain HAL/<subdir>/ trees
+    set(_hal_roots
+        "${CMAKE_CURRENT_SOURCE_DIR}/HAL"
+        "${CMAKE_CURRENT_SOURCE_DIR}/Platform"
+        "${CMAKE_CURRENT_SOURCE_DIR}/src/HAL"
+        "${CMAKE_CURRENT_SOURCE_DIR}/src/Platform"
+        "${CMAKE_CURRENT_SOURCE_DIR}/include/HAL"
+        "${CMAKE_CURRENT_SOURCE_DIR}/include/Platform"
+    )
+
+    set(_hal_plat)
+    foreach(_dir IN LISTS _plat_dirs)
+        foreach(_root IN LISTS _hal_roots)
+            file(GLOB_RECURSE _tmp "${_root}/${_dir}/*.*")
+            list(APPEND _hal_plat ${_tmp})
+        endforeach()
+    endforeach()
+
+    foreach(_pat IN LISTS _extra_excludes)
+        list(FILTER _sources    EXCLUDE REGEX "${_pat}")
+        list(FILTER _hal_common EXCLUDE REGEX "${_pat}")
+        list(FILTER _hal_plat   EXCLUDE REGEX "${_pat}")
+    endforeach()
+
+    set(${out_var} ${_sources} ${_hal_common} ${_hal_plat} PARENT_SCOPE)
+endfunction()
+
+# ── Internal helper ───────────────────────────────────────────────────────────
+# Applies the standard Wyvrn compiler flags to <target>.
+function(_wyvrn_apply_compiler_flags target)
+    get_target_property(_wyvrn_target_type ${target} TYPE)
+    if(_wyvrn_target_type STREQUAL "INTERFACE_LIBRARY")
+        return()
+    endif()
+    target_compile_options(${target} PRIVATE ${WYVRN_COMPILER_FLAGS})
+    target_compile_options(${target} PRIVATE $<$<CONFIG:Debug>:${WYVRN_COMPILER_FLAGS_DEBUG}>)
+    target_compile_options(${target} PRIVATE $<$<CONFIG:Release>:${WYVRN_COMPILER_FLAGS_RELEASE}>)
+endfunction()
+
+# ── SETUP_LIBRARY(target type [EXCLUDE pat...] [extra_sources...]) ────────────
+# Creates a library target from all sources in CMAKE_CURRENT_SOURCE_DIR,
+# with platform-specific HAL sources included automatically.
+#
+# Arguments:
+#   target         CMake target name
+#   type           Library type: STATIC | SHARED | INTERFACE | OBJECT
+#   EXCLUDE        (optional) One or more regex patterns; matched files are
+#                  excluded from the auto-collected source list
+#   extra_sources  (optional) Additional source files to append (positional,
+#                  or via the SOURCES keyword)
+#
+# Side effects:
+#   - Registers aliases  chroma::<target>  and  wyvrn::<target>
+#   - Applies standard Wyvrn compiler flags
+#   - Configures source_group for IDE folder view
+#
+# Example:
+#   SETUP_LIBRARY(WyvrnLog STATIC)
+#   SETUP_LIBRARY(WyvrnRenderer SHARED ${PLATFORM_GENERATED_SOURCES})
+#   SETUP_LIBRARY(WyvrnCore STATIC EXCLUDE ".*legacy.*" ".*_old\\.cpp")
+function(SETUP_LIBRARY target type)
+    cmake_parse_arguments(_SETUP "" "" "EXCLUDE;SOURCES" ${ARGN})
+    _wyvrn_collect_sources(_sources ${_SETUP_EXCLUDE})
+    list(APPEND _sources ${_SETUP_SOURCES} ${_SETUP_UNPARSED_ARGUMENTS})
+
+    add_library(${target} ${type} ${_sources})
+    _wyvrn_apply_compiler_flags(${target})
+    set(_src_sources "")
+    set(_gen_sources "")
+    foreach(_f IN LISTS _sources)
+        cmake_path(IS_PREFIX CMAKE_CURRENT_SOURCE_DIR "${_f}" NORMALIZE _is_under_src)
+        if(_is_under_src)
+            list(APPEND _src_sources "${_f}")
+        else()
+            list(APPEND _gen_sources "${_f}")
+        endif()
+    endforeach()
+    if(_src_sources)
+        source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${_src_sources})
+    endif()
+    if(_gen_sources)
+        source_group("Generated" FILES ${_gen_sources})
+    endif()
+
+    # chroma is a legacy alias namespace; new code should use wyvrn::, but both are provided for compatibility
+    add_library(chroma::${target} ALIAS ${target})
+    add_library(wyvrn::${target}  ALIAS ${target})
+
+    get_target_property(_wyvrn_target_type ${target} TYPE)
+    if(_wyvrn_target_type STREQUAL "INTERFACE_LIBRARY")
+        return()
+    endif()
+
+    target_include_directories(${target} 
+        PUBLIC 
+            $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/${target}>
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+            $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+    )
+
+endfunction()
+
+# ── SETUP_EXE(target [EXCLUDE pat...] [extra_sources...]) ─────────────────────
+# Creates an executable target from all sources in CMAKE_CURRENT_SOURCE_DIR,
+# with platform-specific HAL sources included automatically.
+# On Windows and Xbox the WIN32 subsystem flag is set automatically.
+#
+# Arguments:
+#   target         CMake target name
+#   EXCLUDE        (optional) One or more regex patterns; matched files are
+#                  excluded from the auto-collected source list
+#   extra_sources  (optional) Additional source files to append (positional,
+#                  or via the SOURCES keyword)
+#
+# Example:
+#   SETUP_EXE(ChromaApp)
+#   SETUP_EXE(ChromaTool ${TOOL_GENERATED_SOURCES})
+#   SETUP_EXE(ChromaTool EXCLUDE ".*test_stub.*" SOURCES ${EXTRA})
+function(SETUP_EXE target)
+    cmake_parse_arguments(_SETUP "" "" "EXCLUDE;SOURCES" ${ARGN})
+    _wyvrn_collect_sources(_sources ${_SETUP_EXCLUDE})
+    list(APPEND _sources ${_SETUP_SOURCES} ${_SETUP_UNPARSED_ARGUMENTS})
+
+    if(WYVRN_PLATFORM_WINDOWS OR WYVRN_PLATFORM_XBOX)
+        add_executable(${target} WIN32 ${_sources})
+    else()
+        add_executable(${target} ${_sources})
+    endif()
+
+    _wyvrn_apply_compiler_flags(${target})
+    source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${_sources})
+endfunction()

package/cmake/macros.cmake

@@ -0,0 +1,233 @@
+
+# Transitional helper for unified versioning.
+#
+# The shared generated header is produced once at the top-level and placed under:
+#   ${CMAKE_BINARY_DIR}/wyvrn/WyvrnConfig.h
+# Targets that want to include it as `#include "wyvrn/WyvrnConfig.h"` should
+# have `${CMAKE_BINARY_DIR}` on their include path.
+#
+# This macro exists to preserve older module CMake patterns during migration.
+macro(WYVRN_CONFIGURE_VERSION_HEADER)
+    if(ARGC GREATER 0)
+        set(_wyvrn_version_target ${ARGV0})
+    else()
+        set(_wyvrn_version_target ${PROJECT_NAME})
+    endif()
+
+    if(NOT DEFINED WYVRN_VERSION_HEADER_INCLUDE_DIR)
+        set(WYVRN_VERSION_HEADER_INCLUDE_DIR ${CMAKE_BINARY_DIR})
+    endif()
+
+    target_include_directories(${_wyvrn_version_target}
+        PUBLIC
+            $<BUILD_INTERFACE:${WYVRN_VERSION_HEADER_INCLUDE_DIR}>
+            $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+    )
+endmacro()
+
+function(WYVRN_INSTALL_PACKAGE_EXPORT)
+    set(options)
+    set(oneValueArgs
+        TARGET
+        EXPORT_NAME
+        CONFIG_INPUT
+        CONFIG_OUTPUT
+        VERSION_OUTPUT
+        INSTALL_CMAKEDIR
+        NAMESPACE
+        EXPORT_FILE
+        PACKAGE_VERSION
+    )
+    set(multiValueArgs)
+    cmake_parse_arguments(WYVRN_EXPORT "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    include(CMakePackageConfigHelpers)
+
+    if(NOT WYVRN_EXPORT_TARGET)
+        message(FATAL_ERROR "WYVRN_INSTALL_PACKAGE_EXPORT requires TARGET")
+    endif()
+    if(NOT WYVRN_EXPORT_EXPORT_NAME)
+        message(FATAL_ERROR "WYVRN_INSTALL_PACKAGE_EXPORT requires EXPORT_NAME")
+    endif()
+    if(NOT WYVRN_EXPORT_CONFIG_INPUT)
+        message(FATAL_ERROR "WYVRN_INSTALL_PACKAGE_EXPORT requires CONFIG_INPUT")
+    endif()
+    if(NOT WYVRN_EXPORT_CONFIG_OUTPUT)
+        message(FATAL_ERROR "WYVRN_INSTALL_PACKAGE_EXPORT requires CONFIG_OUTPUT")
+    endif()
+    if(NOT WYVRN_EXPORT_VERSION_OUTPUT)
+        message(FATAL_ERROR "WYVRN_INSTALL_PACKAGE_EXPORT requires VERSION_OUTPUT")
+    endif()
+    if(NOT WYVRN_EXPORT_INSTALL_CMAKEDIR)
+        message(FATAL_ERROR "WYVRN_INSTALL_PACKAGE_EXPORT requires INSTALL_CMAKEDIR")
+    endif()
+    if(NOT WYVRN_EXPORT_NAMESPACE)
+        message(FATAL_ERROR "WYVRN_INSTALL_PACKAGE_EXPORT requires NAMESPACE")
+    endif()
+    if(NOT WYVRN_EXPORT_EXPORT_FILE)
+        message(FATAL_ERROR "WYVRN_INSTALL_PACKAGE_EXPORT requires EXPORT_FILE")
+    endif()
+
+    if(NOT WYVRN_EXPORT_PACKAGE_VERSION)
+        if(DEFINED PROJECT_VERSION AND NOT "${PROJECT_VERSION}" STREQUAL "")
+            set(WYVRN_EXPORT_PACKAGE_VERSION ${PROJECT_VERSION})
+        elseif(DEFINED WYVRN_PROJECT_VERSION AND NOT "${WYVRN_PROJECT_VERSION}" STREQUAL "")
+            set(WYVRN_EXPORT_PACKAGE_VERSION ${WYVRN_PROJECT_VERSION})
+        else()
+            message(FATAL_ERROR "WYVRN_INSTALL_PACKAGE_EXPORT requires PACKAGE_VERSION or a non-empty PROJECT_VERSION/WYVRN_PROJECT_VERSION")
+        endif()
+    endif()
+
+    configure_package_config_file(
+        "${WYVRN_EXPORT_CONFIG_INPUT}"
+        "${WYVRN_EXPORT_CONFIG_OUTPUT}"
+        INSTALL_DESTINATION "${WYVRN_EXPORT_INSTALL_CMAKEDIR}"
+    )
+
+    write_basic_package_version_file(
+        "${WYVRN_EXPORT_VERSION_OUTPUT}"
+        VERSION "${WYVRN_EXPORT_PACKAGE_VERSION}"
+        COMPATIBILITY SameMajorVersion
+    )
+
+    install(FILES
+        "${WYVRN_EXPORT_CONFIG_OUTPUT}"
+        "${WYVRN_EXPORT_VERSION_OUTPUT}"
+        DESTINATION "${WYVRN_EXPORT_INSTALL_CMAKEDIR}"
+    )
+
+    install(TARGETS ${WYVRN_EXPORT_TARGET}
+        EXPORT ${WYVRN_EXPORT_EXPORT_NAME}
+        RUNTIME DESTINATION bin/$<CONFIG>          # .dll files (Windows)
+        LIBRARY DESTINATION lib/$<CONFIG>           # .so files (Linux/macOS)
+        ARCHIVE DESTINATION lib/$<CONFIG>           # .lib files (static or import libs)
+    )
+
+    install(EXPORT ${WYVRN_EXPORT_EXPORT_NAME}
+        FILE ${WYVRN_EXPORT_EXPORT_FILE}
+        NAMESPACE ${WYVRN_EXPORT_NAMESPACE}
+        DESTINATION "${WYVRN_EXPORT_INSTALL_CMAKEDIR}"
+    )
+endfunction()
+
+function(WYVRN_INSTALL_MODULE)
+    set(options
+        COPY_DLL_TO_OUTPUT
+    )
+    set(oneValueArgs
+        TARGET
+        PACKAGE_NAME
+        INSTALL_CMAKEDIR
+        NAMESPACE
+        EXPORT_NAME
+        EXPORT_FILE
+        DLL_OUTPUT_DIR
+        CONSUMER_DLL_OUTPUT_DIR
+    )
+    set(multiValueArgs
+        DEPENDENCIES
+        FIND_PACKAGES
+    )
+    cmake_parse_arguments(WYVRN "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(NOT WYVRN_TARGET)
+        message(FATAL_ERROR "WYVRN_INSTALL_MODULE requires TARGET")
+    endif()
+    if(NOT WYVRN_PACKAGE_NAME)
+        message(FATAL_ERROR "WYVRN_INSTALL_MODULE requires PACKAGE_NAME (example: WyvrnMemory)")
+    endif()
+
+    if(NOT WYVRN_NAMESPACE)
+        set(WYVRN_NAMESPACE wyvrn::)
+    endif()
+    if(NOT WYVRN_EXPORT_NAME)
+        set(WYVRN_EXPORT_NAME "${WYVRN_PACKAGE_NAME}Targets")
+    endif()
+    if(NOT WYVRN_EXPORT_FILE)
+        set(WYVRN_EXPORT_FILE "${WYVRN_PACKAGE_NAME}Targets.cmake")
+    endif()
+    if(NOT WYVRN_INSTALL_CMAKEDIR)
+        set(WYVRN_INSTALL_CMAKEDIR "${CMAKE_INSTALL_DATADIR}/${WYVRN_PACKAGE_NAME}")
+    endif()
+
+    if(WYVRN_COPY_DLL_TO_OUTPUT)
+        get_target_property(_wyvrn_target_type ${WYVRN_TARGET} TYPE)
+        set(_wyvrn_enable_dll_copy FALSE)
+
+        if(NOT WYVRN_DLL_OUTPUT_DIR)
+            if(DEFINED CMAKE_RUNTIME_OUTPUT_DIRECTORY AND NOT "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}" STREQUAL "")
+                set(WYVRN_DLL_OUTPUT_DIR "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/$<CONFIG>")
+            else()
+                set(WYVRN_DLL_OUTPUT_DIR "${CMAKE_BINARY_DIR}/bin/$<CONFIG>")
+            endif()
+        endif()
+
+        if(WIN32 AND (_wyvrn_target_type STREQUAL "SHARED_LIBRARY" OR _wyvrn_target_type STREQUAL "MODULE_LIBRARY"))
+            set(_wyvrn_enable_dll_copy TRUE)
+            add_custom_command(TARGET ${WYVRN_TARGET} POST_BUILD
+                COMMAND ${CMAKE_COMMAND} -E make_directory "${WYVRN_DLL_OUTPUT_DIR}"
+                COMMAND ${CMAKE_COMMAND} -E copy_if_different
+                    "$<TARGET_FILE:${WYVRN_TARGET}>"
+                    "${WYVRN_DLL_OUTPUT_DIR}/"
+                COMMENT "Copying DLL for ${WYVRN_TARGET} to ${WYVRN_DLL_OUTPUT_DIR}"
+            )
+        else()
+            message(WARNING "WYVRN_INSTALL_MODULE(COPY_DLL_TO_OUTPUT) is set for '${WYVRN_TARGET}', but it is not a Windows shared/module library. Skipping DLL copy.")
+        endif()
+    endif()
+
+    set(_wyvrn_config_in "${CMAKE_CURRENT_BINARY_DIR}/${WYVRN_PACKAGE_NAME}Config.cmake.in")
+    set(_wyvrn_config_out "${CMAKE_CURRENT_BINARY_DIR}/${WYVRN_PACKAGE_NAME}Config.cmake")
+    set(_wyvrn_version_out "${CMAKE_CURRENT_BINARY_DIR}/${WYVRN_PACKAGE_NAME}ConfigVersion.cmake")
+
+    set(_wyvrn_config_text "@PACKAGE_INIT@\n\n")
+
+    if(WYVRN_FIND_PACKAGES OR WYVRN_DEPENDENCIES)
+        string(APPEND _wyvrn_config_text "include(CMakeFindDependencyMacro)\n")
+    endif()
+
+    foreach(_wyvrn_pkg IN LISTS WYVRN_FIND_PACKAGES)
+        string(APPEND _wyvrn_config_text "find_package(${_wyvrn_pkg} CONFIG REQUIRED)\n")
+    endforeach()
+
+    foreach(_wyvrn_dep IN LISTS WYVRN_DEPENDENCIES)
+        string(APPEND _wyvrn_config_text "find_dependency(${_wyvrn_dep} CONFIG REQUIRED)\n")
+    endforeach()
+
+    string(APPEND _wyvrn_config_text "\ninclude(\"\${CMAKE_CURRENT_LIST_DIR}/${WYVRN_EXPORT_FILE}\")\n")
+
+    if(WYVRN_COPY_DLL_TO_OUTPUT AND _wyvrn_enable_dll_copy)
+        if(NOT WYVRN_CONSUMER_DLL_OUTPUT_DIR)
+            set(WYVRN_CONSUMER_DLL_OUTPUT_DIR "\${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/$<CONFIG>")
+        endif()
+
+        string(APPEND _wyvrn_config_text "\nif(WIN32 AND TARGET ${WYVRN_NAMESPACE}${WYVRN_TARGET})\n")
+        string(APPEND _wyvrn_config_text "  if(NOT TARGET ${WYVRN_PACKAGE_NAME}RuntimeCopy)\n")
+        string(APPEND _wyvrn_config_text "    set(_wyvrn_runtime_out \"${WYVRN_CONSUMER_DLL_OUTPUT_DIR}\")\n")
+        string(APPEND _wyvrn_config_text "    if(\"\${_wyvrn_runtime_out}\" STREQUAL \"/$<CONFIG>\")\n")
+        string(APPEND _wyvrn_config_text "      set(_wyvrn_runtime_out \"\${CMAKE_BINARY_DIR}/bin/$<CONFIG>\")\n")
+        string(APPEND _wyvrn_config_text "    endif()\n")
+        string(APPEND _wyvrn_config_text "    add_custom_target(${WYVRN_PACKAGE_NAME}RuntimeCopy ALL\n")
+        string(APPEND _wyvrn_config_text "      COMMAND \${CMAKE_COMMAND} -E make_directory \"\${_wyvrn_runtime_out}\"\n")
+        string(APPEND _wyvrn_config_text "      COMMAND \${CMAKE_COMMAND} -E copy_if_different\n")
+        string(APPEND _wyvrn_config_text "              \"$<TARGET_FILE:${WYVRN_NAMESPACE}${WYVRN_TARGET}>\"\n")
+        string(APPEND _wyvrn_config_text "              \"\${_wyvrn_runtime_out}/\"\n")
+        string(APPEND _wyvrn_config_text "      COMMENT \"Copying runtime DLL for ${WYVRN_NAMESPACE}${WYVRN_TARGET} to \${_wyvrn_runtime_out}\"\n")
+        string(APPEND _wyvrn_config_text "    )\n")
+        string(APPEND _wyvrn_config_text "  endif()\n")
+        string(APPEND _wyvrn_config_text "endif()\n")
+    endif()
+
+    file(WRITE "${_wyvrn_config_in}" "${_wyvrn_config_text}")
+
+    WYVRN_INSTALL_PACKAGE_EXPORT(
+        TARGET ${WYVRN_TARGET}
+        EXPORT_NAME ${WYVRN_EXPORT_NAME}
+        CONFIG_INPUT "${_wyvrn_config_in}"
+        CONFIG_OUTPUT "${_wyvrn_config_out}"
+        VERSION_OUTPUT "${_wyvrn_version_out}"
+        INSTALL_CMAKEDIR "${WYVRN_INSTALL_CMAKEDIR}"
+        NAMESPACE ${WYVRN_NAMESPACE}
+        EXPORT_FILE ${WYVRN_EXPORT_FILE}
+    )
+endfunction()

package/cmake/options.cmake

@@ -0,0 +1,23 @@
+option(WYVRN_ENABLE_ASSERTION     "Enable assertions"                     ON)
+option(WYVRN_ENABLE_LOG           "Enable logging"                        ON)
+option(WYVRN_ENABLE_PROFILER      "Enable profiler"                       OFF)
+option(WYVRN_COMPILE_PROFILER_EXE "Compile the profiler executable"       OFF)
+option(WYVRN_ENABLE_MEMORY_TRACK  "Enable memory tracking"                OFF)
+option(WYVRN_MEMORY_TRACK_VERBOSE "Verbose memory tracking (very slow)"   OFF)
+
+set(WYVRN_OPTIONS 
+    WYVRN_ENABLE_ASSERTION
+    WYVRN_ENABLE_LOG
+    WYVRN_ENABLE_PROFILER
+    WYVRN_COMPILE_PROFILER_EXE
+    WYVRN_ENABLE_MEMORY_TRACK
+    WYVRN_MEMORY_TRACK_VERBOSE)
+
+foreach(opt IN LISTS WYVRN_OPTIONS)
+    if(${opt})
+        add_compile_definitions(${opt}=1)
+        message(STATUS "Enabled option: ${opt}")
+    else()
+        add_compile_definitions(${opt}=0)
+    endif()
+endforeach()

package/cmake/variables.cmake

@@ -0,0 +1,171 @@
+if(MSVC)
+    list(APPEND WYVRN_COMPILER_FLAGS
+        /W3
+        /sdl
+        /permissive-
+        /EHsc
+    )
+else()
+    list(APPEND WYVRN_COMPILER_FLAGS
+        -Wall
+        -Wextra
+    )
+endif()
+
+option(WYVRN_UNICODE "Enable Unicode character set (_UNICODE, UNICODE)" ON)
+if(WYVRN_UNICODE)
+    add_compile_definitions(_UNICODE UNICODE)
+endif()
+
+# MSVC runtime library is controlled by CMAKE_MSVC_RUNTIME_LIBRARY (CMP0091),
+# which the wyvrnpm toolchain sets from the active build profile
+# (compiler.runtime=dynamic|static). CMake emits the correct /MD[d] or /MT[d]
+# automatically; appending the flag here would duplicate or conflict when the
+# profile requests a different runtime than the old default of /MD.
+
+SET(VENDOR_DIR ${PROJECT_SOURCE_DIR}/vendors)
+
+# ── Platform detection ────────────────────────────────────────────────────────
+# Leaf platforms (set exactly one primary leaf; SteamOS is an overlay on Linux)
+#
+#   WYVRN_PLATFORM_WINDOWS   – desktop Windows (Win32/Win64)
+#   WYVRN_PLATFORM_XBOX      – Xbox GDK / XDK  (pass -DWYVRN_XBOX=ON)
+#   WYVRN_PLATFORM_PS4       – PlayStation 4   (CMAKE_SYSTEM_NAME == ORBIS)
+#   WYVRN_PLATFORM_PS5       – PlayStation 5   (CMAKE_SYSTEM_NAME == Prospero)
+#   WYVRN_PLATFORM_LINUX     – generic Linux
+#   WYVRN_PLATFORM_STEAMOS   – SteamOS (overlay; set alongside LINUX)
+#   WYVRN_PLATFORM_ANDROID   – Android NDK
+#   WYVRN_PLATFORM_MACOS     – macOS
+#   WYVRN_PLATFORM_IOS       – iOS / iPadOS
+
+# -- Initialise all leaf variables to FALSE --
+set(WYVRN_PLATFORM_WINDOWS FALSE)
+set(WYVRN_PLATFORM_XBOX    FALSE)
+set(WYVRN_PLATFORM_PS4     FALSE)
+set(WYVRN_PLATFORM_PS5     FALSE)
+set(WYVRN_PLATFORM_LINUX   FALSE)
+set(WYVRN_PLATFORM_STEAMOS FALSE)
+set(WYVRN_PLATFORM_ANDROID FALSE)
+set(WYVRN_PLATFORM_MACOS   FALSE)
+set(WYVRN_PLATFORM_IOS     FALSE)
+
+# -- Detect leaf --
+if(CMAKE_SYSTEM_NAME STREQUAL "ORBIS")
+    set(WYVRN_PLATFORM_PS4 TRUE)
+elseif(CMAKE_SYSTEM_NAME STREQUAL "Prospero")
+    set(WYVRN_PLATFORM_PS5 TRUE)
+elseif(WIN32)
+    if(WYVRN_XBOX OR CHROMA_XBOX)
+        set(WYVRN_PLATFORM_XBOX TRUE)
+    else()
+        set(WYVRN_PLATFORM_WINDOWS TRUE)
+    endif()
+elseif(ANDROID)
+    set(WYVRN_PLATFORM_ANDROID TRUE)
+elseif(APPLE)
+    if(IOS)
+        set(WYVRN_PLATFORM_IOS TRUE)
+    else()
+        set(WYVRN_PLATFORM_MACOS TRUE)
+    endif()
+elseif(UNIX)
+    set(WYVRN_PLATFORM_LINUX TRUE)
+    if(WYVRN_STEAMOS)
+        set(WYVRN_PLATFORM_STEAMOS TRUE)
+    endif()
+endif()
+
+# -- Derived family tier --
+if(WYVRN_PLATFORM_WINDOWS OR WYVRN_PLATFORM_XBOX)
+    set(WYVRN_PLATFORM_MICROSOFT TRUE)
+else()
+    set(WYVRN_PLATFORM_MICROSOFT FALSE)
+endif()
+
+if(WYVRN_PLATFORM_MACOS OR WYVRN_PLATFORM_IOS)
+    set(WYVRN_PLATFORM_DARWIN TRUE)
+else()
+    set(WYVRN_PLATFORM_DARWIN FALSE)
+endif()
+
+if(WYVRN_PLATFORM_PS4 OR WYVRN_PLATFORM_PS5)
+    set(WYVRN_PLATFORM_PLAYSTATION TRUE)
+else()
+    set(WYVRN_PLATFORM_PLAYSTATION FALSE)
+endif()
+
+if(WYVRN_PLATFORM_LINUX OR WYVRN_PLATFORM_ANDROID OR WYVRN_PLATFORM_DARWIN OR WYVRN_PLATFORM_PLAYSTATION)
+    set(WYVRN_PLATFORM_UNIX TRUE)
+else()
+    set(WYVRN_PLATFORM_UNIX FALSE)
+endif()
+
+# -- Derived broad grouping tier --
+if(WYVRN_PLATFORM_WINDOWS OR WYVRN_PLATFORM_MACOS OR WYVRN_PLATFORM_LINUX)
+    set(WYVRN_PLATFORM_DESKTOP TRUE)
+else()
+    set(WYVRN_PLATFORM_DESKTOP FALSE)
+endif()
+
+if(WYVRN_PLATFORM_ANDROID OR WYVRN_PLATFORM_IOS)
+    set(WYVRN_PLATFORM_MOBILE TRUE)
+else()
+    set(WYVRN_PLATFORM_MOBILE FALSE)
+endif()
+
+if(WYVRN_PLATFORM_XBOX OR WYVRN_PLATFORM_PLAYSTATION)
+    set(WYVRN_PLATFORM_CONSOLE TRUE)
+else()
+    set(WYVRN_PLATFORM_CONSOLE FALSE)
+endif()
+
+# -- Emit WYVRN_PLATFORM_* compile definitions (value = 1) --
+foreach(_plat
+    WINDOWS XBOX PS4 PS5 LINUX STEAMOS ANDROID MACOS IOS
+    MICROSOFT DARWIN PLAYSTATION UNIX
+    DESKTOP MOBILE CONSOLE)
+    if(WYVRN_PLATFORM_${_plat})
+        add_compile_definitions(WYVRN_PLATFORM_${_plat}=1)
+    endif()
+endforeach()
+
+# -- Backward-compat CHROMA_* CMake variables and compile definitions --
+set(CHROMA_WINDOWS ${WYVRN_PLATFORM_WINDOWS})
+set(CHROMA_XBOX    ${WYVRN_PLATFORM_XBOX})
+set(CHROMA_LINUX   ${WYVRN_PLATFORM_LINUX})
+set(CHROMA_ANDROID ${WYVRN_PLATFORM_ANDROID})
+set(CHROMA_MACOS   ${WYVRN_PLATFORM_MACOS})
+set(CHROMA_IOS     ${WYVRN_PLATFORM_IOS})
+
+foreach(_plat WINDOWS XBOX LINUX ANDROID MACOS IOS)
+    if(WYVRN_PLATFORM_${_plat})
+        add_compile_definitions(CHROMA_${_plat}=1)
+    endif()
+endforeach()
+
+# Status
+message(STATUS "Platform leaf  : WINDOWS=${WYVRN_PLATFORM_WINDOWS} XBOX=${WYVRN_PLATFORM_XBOX} PS4=${WYVRN_PLATFORM_PS4} PS5=${WYVRN_PLATFORM_PS5} LINUX=${WYVRN_PLATFORM_LINUX} STEAMOS=${WYVRN_PLATFORM_STEAMOS} ANDROID=${WYVRN_PLATFORM_ANDROID} MACOS=${WYVRN_PLATFORM_MACOS} IOS=${WYVRN_PLATFORM_IOS}")
+message(STATUS "Platform family: MICROSOFT=${WYVRN_PLATFORM_MICROSOFT} DARWIN=${WYVRN_PLATFORM_DARWIN} PLAYSTATION=${WYVRN_PLATFORM_PLAYSTATION} UNIX=${WYVRN_PLATFORM_UNIX}")
+message(STATUS "Platform broad : DESKTOP=${WYVRN_PLATFORM_DESKTOP} MOBILE=${WYVRN_PLATFORM_MOBILE} CONSOLE=${WYVRN_PLATFORM_CONSOLE}")
+
+# Arch
+if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+    message(STATUS "Building for x64 (64-bit)")
+    add_definitions(-DWYVRN_64)
+    set(WYVRN_64 TRUE)
+elseif(CMAKE_SIZEOF_VOID_P EQUAL 4)
+    message(STATUS "Building for x86 (32-bit)")
+     add_definitions(-DWYVRN_32)
+    set(WYVRN_32 TRUE)
+else()
+    message(STATUS "Unknown architecture")
+endif()
+
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/output/lib/")
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/output/lib/")
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/output/bin")
+
+add_compile_definitions(
+    $<$<CONFIG:Debug>:WYVRN_DEBUG>
+    $<$<CONFIG:Release>:WYVRN_RELEASE>
+)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wyvrnpm",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "description": "A simple, static-hosting-compatible C++ package manager",
   "keywords": [
     "c++",
@@ -19,6 +19,7 @@
   "files": [
     "bin/",
     "src/",
+    "cmake/",
     "README.md"
   ],
   "scripts": {