Add ios support

.gitmodules

@@ -10,3 +10,6 @@
 [submodule "contrib/D3D12MemoryAllocator"]
 	path = contrib/D3D12MemoryAllocator
 	url = https://github.com/GPUOpen-LibrariesAndSDKs/D3D12MemoryAllocator
+[submodule "contrib/ios-cmake"]
+	path = contrib/ios-cmake
+	url = https://github.com/leetal/ios-cmake

CMakeLists.txt

@@ -21,6 +21,7 @@ cmake_dependent_option(PLUME_SDL_VULKAN_ENABLED "Enable SDL Vulkan integration"
 cmake_dependent_option(PLUME_D3D12_AGILITY_SDK_ENABLED "Enable D3D12 Agility SDK" OFF WIN32 OFF)
 cmake_dependent_option(PLUME_APPLE_RETINA_ENABLED "Enable Apple Retina display support" ON APPLE ON)
 option(PLUME_BUILD_EXAMPLES "Build example applications" OFF)
+cmake_dependent_option(PLUME_XCODE_TEAM_ID "Xcode team ID for code signing (e.g., ABCDE12345)" "" APPLE OFF)
 
 # Windows-specific definitions
 if(WIN32)
@@ -29,7 +30,7 @@ endif()
 
 # Enable SDL Vulkan support
 if(PLUME_SDL_VULKAN_ENABLED)
-    if (NOT TARGET SDL2::SDL2)
+    if(NOT TARGET SDL2::SDL2)
         find_package(SDL2 REQUIRED)
     else()
         set(SDL2_INCLUDE_DIRS "$<TARGET_PROPERTY:SDL2::SDL2,INTERFACE_INCLUDE_DIRECTORIES>")
@@ -50,6 +51,16 @@ message(STATUS "Plume - SDL Vulkan integration: ${PLUME_SDL_VULKAN_ENABLED}")
 message(STATUS "Plume - D3D12 Agility SDK: ${PLUME_D3D12_AGILITY_SDK_ENABLED}")
 message(STATUS "Plume - Building examples: ${PLUME_BUILD_EXAMPLES}")
 
+if(APPLE AND PLUME_BUILD_EXAMPLES)
+    message(STATUS "Plume - Xcode examples configured with automatic code signing")
+
+    if(PLUME_XCODE_TEAM_ID)
+        message(STATUS "Plume - Xcode Team ID: ${PLUME_XCODE_TEAM_ID}")
+    else()
+        message(STATUS "Plume - To set your Xcode Team ID, use: -DPLUME_XCODE_TEAM_ID=<your-team-id>")
+    endif()
+endif()
+
 # Basic source files that are always included
 set(PLUME_SOURCES
     plume_vulkan.cpp

examples/CMakeLists.txt

@@ -13,6 +13,17 @@ plume_find_sdl2()
 include(${CMAKE_SOURCE_DIR}/examples/cmake/PlumeShaders.cmake)
 plume_shaders_init()
 
+# Load Xcode configuration helper for team ID and code signing
+if(APPLE)
+    include(${CMAKE_SOURCE_DIR}/examples/cmake/modules/PlumeXcodeConfig.cmake)
+endif()
+
 # Add example subdirectories
 add_subdirectory(triangle)
 add_subdirectory(cube)
+
+# Apply Xcode configuration to example targets
+if(APPLE)
+    plume_apply_xcode_config(plume_triangle)
+    plume_apply_xcode_config(plume_cube)
+endif()

examples/cmake/PlumeShaders.cmake

@@ -15,13 +15,14 @@ include("${CMAKE_CURRENT_LIST_DIR}/modules/PlumeSpirvCross.cmake")
 
 function(_plume_embed TARGET_NAME INPUT_FILE VAR_NAME OUTPUT_C OUTPUT_H)
     plume_build_file_to_c()
+    plume_get_file_to_c_command(FILE_TO_C_CMD)
 
     get_filename_component(OUT_DIR "${OUTPUT_C}" DIRECTORY)
     file(MAKE_DIRECTORY "${OUT_DIR}")
 
     add_custom_command(
         OUTPUT "${OUTPUT_C}" "${OUTPUT_H}"
-        COMMAND plume_file_to_c "${INPUT_FILE}" "${VAR_NAME}" "${OUTPUT_C}" "${OUTPUT_H}"
+        COMMAND ${FILE_TO_C_CMD} "${INPUT_FILE}" "${VAR_NAME}" "${OUTPUT_C}" "${OUTPUT_H}"
         DEPENDS "${INPUT_FILE}" plume_file_to_c
         COMMENT "Embedding ${VAR_NAME} from ${INPUT_FILE}"
         VERBATIM
@@ -62,6 +63,7 @@ function(_plume_compile_hlsl_impl TARGET_NAME SHADER_SOURCE SHADER_TYPE OUTPUT_N
     endif()
 
     set(SHADER_MODEL "6_0")
+
     if(ARG_SHADER_MODEL)
         set(SHADER_MODEL "${ARG_SHADER_MODEL}")
     endif()
@@ -71,10 +73,12 @@ function(_plume_compile_hlsl_impl TARGET_NAME SHADER_SOURCE SHADER_TYPE OUTPUT_N
     else()
         set(OUT_DIR "${CMAKE_BINARY_DIR}/shaders")
     endif()
+
     file(MAKE_DIRECTORY "${OUT_DIR}")
 
     set(PROFILE "")
     set(DXC_TYPE_ARGS "")
+
     if(SHADER_TYPE STREQUAL "vertex")
         set(PROFILE "vs_${SHADER_MODEL}")
         set(DXC_TYPE_ARGS "-fvk-invert-y")
@@ -91,6 +95,7 @@ function(_plume_compile_hlsl_impl TARGET_NAME SHADER_SOURCE SHADER_TYPE OUTPUT_N
     endif()
 
     set(INCLUDE_FLAGS "")
+
     foreach(DIR ${ARG_INCLUDE_DIRS})
         list(APPEND INCLUDE_FLAGS "-I${DIR}")
     endforeach()
@@ -126,12 +131,14 @@ endfunction()
 
 function(_plume_compile_spirv_to_metal_impl TARGET_NAME SPIRV_FILE OUTPUT_NAME)
     cmake_parse_arguments(PARSE_ARGV 3 ARG "" "OUTPUT_DIR" "")
+    plume_get_spirv_cross_msl_command(SPIRV_CROSS_MSL_CMD)
 
     if(ARG_OUTPUT_DIR)
         set(OUT_DIR "${ARG_OUTPUT_DIR}")
     else()
         set(OUT_DIR "${CMAKE_BINARY_DIR}/shaders")
     endif()
+
     file(MAKE_DIRECTORY "${OUT_DIR}")
 
     set(METAL_SOURCE "${OUT_DIR}/${OUTPUT_NAME}.hlsl.metal")
@@ -148,7 +155,7 @@ function(_plume_compile_spirv_to_metal_impl TARGET_NAME SPIRV_FILE OUTPUT_NAME)
 
     add_custom_command(
         OUTPUT "${METAL_SOURCE}"
-        COMMAND plume_spirv_cross_msl "${SPIRV_FILE}" "${METAL_SOURCE}"
+        COMMAND ${SPIRV_CROSS_MSL_CMD} "${SPIRV_FILE}" "${METAL_SOURCE}"
         DEPENDS "${SPIRV_FILE}" plume_spirv_cross_msl
         COMMENT "SPIRV-Cross: ${SPIRV_FILE} -> Metal source"
         VERBATIM
@@ -175,6 +182,8 @@ function(_plume_compile_spirv_to_metal_impl TARGET_NAME SPIRV_FILE OUTPUT_NAME)
 endfunction()
 
 function(_plume_compile_metal_impl TARGET_NAME SHADER_SOURCE OUTPUT_NAME)
+    plume_get_file_to_c_command(FILE_TO_C_CMD)
+
     set(IR_OUTPUT "${CMAKE_BINARY_DIR}/shaders/${OUTPUT_NAME}.ir")
     set(METALLIB_OUTPUT "${CMAKE_BINARY_DIR}/shaders/${OUTPUT_NAME}.metallib")
     set(C_OUTPUT "${CMAKE_BINARY_DIR}/shaders/${OUTPUT_NAME}.metal.c")
@@ -204,7 +213,7 @@ function(_plume_compile_metal_impl TARGET_NAME SHADER_SOURCE OUTPUT_NAME)
 
     add_custom_command(
         OUTPUT "${C_OUTPUT}" "${H_OUTPUT}"
-        COMMAND plume_file_to_c "${METALLIB_OUTPUT}" "${OUTPUT_NAME}BlobMSL" "${C_OUTPUT}" "${H_OUTPUT}"
+        COMMAND ${FILE_TO_C_CMD} "${METALLIB_OUTPUT}" "${OUTPUT_NAME}BlobMSL" "${C_OUTPUT}" "${H_OUTPUT}"
         DEPENDS "${METALLIB_OUTPUT}" plume_file_to_c
         COMMENT "Generating C header for Metal shader ${OUTPUT_NAME}"
         VERBATIM
@@ -215,7 +224,6 @@ function(_plume_compile_metal_impl TARGET_NAME SHADER_SOURCE OUTPUT_NAME)
 endfunction()
 
 # Public API
-
 function(plume_compile_shader TARGET_NAME SHADER_SOURCE SHADER_TYPE OUTPUT_NAME ENTRY_POINT)
     cmake_parse_arguments(ARG "SPEC_CONSTANTS" "SHADER_MODEL;OUTPUT_DIR" "INCLUDE_DIRS;EXTRA_ARGS" ${ARGN})
 
@@ -227,15 +235,19 @@ function(plume_compile_shader TARGET_NAME SHADER_SOURCE SHADER_TYPE OUTPUT_NAME
         endif()
     elseif(SHADER_EXT MATCHES "\\.hlsl$")
         set(IMPL_ARGS "")
+
         if(ARG_SHADER_MODEL)
             list(APPEND IMPL_ARGS SHADER_MODEL "${ARG_SHADER_MODEL}")
         endif()
+
         if(ARG_INCLUDE_DIRS)
             list(APPEND IMPL_ARGS INCLUDE_DIRS ${ARG_INCLUDE_DIRS})
         endif()
+
         if(ARG_EXTRA_ARGS)
             list(APPEND IMPL_ARGS EXTRA_ARGS ${ARG_EXTRA_ARGS})
         endif()
+
         if(ARG_OUTPUT_DIR)
             list(APPEND IMPL_ARGS OUTPUT_DIR "${ARG_OUTPUT_DIR}")
             set(OUT_DIR "${ARG_OUTPUT_DIR}")

examples/cmake/modules/PlumeDXC.cmake

@@ -3,6 +3,24 @@
 
 include(FetchContent)
 
+function(_plume_get_dxc_host_arch OUT_VAR)
+    if(CMAKE_CROSSCOMPILING)
+        set(_plume_arch "${CMAKE_HOST_SYSTEM_PROCESSOR}")
+    else()
+        set(_plume_arch "${CMAKE_SYSTEM_PROCESSOR}")
+    endif()
+
+    string(TOLOWER "${_plume_arch}" _plume_arch_lower)
+
+    if(_plume_arch_lower MATCHES "^(x86_64|amd64)$")
+        set(${OUT_VAR} "x64" PARENT_SCOPE)
+    elseif(_plume_arch_lower MATCHES "^(arm64|aarch64)$")
+        set(${OUT_VAR} "arm64" PARENT_SCOPE)
+    else()
+        message(FATAL_ERROR "Unsupported host architecture for DXC: ${_plume_arch}")
+    endif()
+endfunction()
+
 # Set up common DXC options (called regardless of fetch)
 function(_plume_setup_dxc_options)
     if(DEFINED PLUME_DXC_COMMON_OPTS)
@@ -29,6 +47,8 @@ function(plume_fetch_dxc)
     )
     FetchContent_MakeAvailable(plume_dxc)
 
+    _plume_get_dxc_host_arch(PLUME_DXC_HOST_ARCH)
+
     # Set up DXC paths based on platform
     if(WIN32)
         set(PLUME_DXC_EXECUTABLE "${plume_dxc_SOURCE_DIR}/bin/x64/dxc.exe" CACHE INTERNAL "DXC executable")
@@ -38,17 +58,13 @@ function(plume_fetch_dxc)
         if(EXISTS "${plume_dxc_SOURCE_DIR}/bin/x64/dxcompiler.dll")
             configure_file("${plume_dxc_SOURCE_DIR}/bin/x64/dxcompiler.dll" "${CMAKE_BINARY_DIR}/bin/dxcompiler.dll" COPYONLY)
         endif()
+
         if(EXISTS "${plume_dxc_SOURCE_DIR}/bin/x64/dxil.dll")
             configure_file("${plume_dxc_SOURCE_DIR}/bin/x64/dxil.dll" "${CMAKE_BINARY_DIR}/bin/dxil.dll" COPYONLY)
         endif()
     elseif(APPLE)
-        if(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
-            set(PLUME_DXC_EXECUTABLE "${plume_dxc_SOURCE_DIR}/bin/x64/dxc-macos" CACHE INTERNAL "DXC executable")
-            set(PLUME_DXC_LIB_DIR "${plume_dxc_SOURCE_DIR}/lib/x64" CACHE INTERNAL "DXC library directory")
-        else()
-            set(PLUME_DXC_EXECUTABLE "${plume_dxc_SOURCE_DIR}/bin/arm64/dxc-macos" CACHE INTERNAL "DXC executable")
-            set(PLUME_DXC_LIB_DIR "${plume_dxc_SOURCE_DIR}/lib/arm64" CACHE INTERNAL "DXC library directory")
-        endif()
+        set(PLUME_DXC_EXECUTABLE "${plume_dxc_SOURCE_DIR}/bin/${PLUME_DXC_HOST_ARCH}/dxc-macos" CACHE INTERNAL "DXC executable")
+        set(PLUME_DXC_LIB_DIR "${plume_dxc_SOURCE_DIR}/lib/${PLUME_DXC_HOST_ARCH}" CACHE INTERNAL "DXC library directory")
 
         # Ensure executable permission
         if(EXISTS "${PLUME_DXC_EXECUTABLE}")
@@ -58,13 +74,8 @@ function(plume_fetch_dxc)
         endif()
     else()
         # Linux
-        if(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
-            set(PLUME_DXC_EXECUTABLE "${plume_dxc_SOURCE_DIR}/bin/x64/dxc-linux" CACHE INTERNAL "DXC executable")
-            set(PLUME_DXC_LIB_DIR "${plume_dxc_SOURCE_DIR}/lib/x64" CACHE INTERNAL "DXC library directory")
-        else()
-            set(PLUME_DXC_EXECUTABLE "${plume_dxc_SOURCE_DIR}/bin/arm64/dxc-linux" CACHE INTERNAL "DXC executable")
-            set(PLUME_DXC_LIB_DIR "${plume_dxc_SOURCE_DIR}/lib/arm64" CACHE INTERNAL "DXC library directory")
-        endif()
+        set(PLUME_DXC_EXECUTABLE "${plume_dxc_SOURCE_DIR}/bin/${PLUME_DXC_HOST_ARCH}/dxc-linux" CACHE INTERNAL "DXC executable")
+        set(PLUME_DXC_LIB_DIR "${plume_dxc_SOURCE_DIR}/lib/${PLUME_DXC_HOST_ARCH}" CACHE INTERNAL "DXC library directory")
 
         # Ensure executable permission
         if(EXISTS "${PLUME_DXC_EXECUTABLE}")

examples/cmake/modules/PlumeFileToC.cmake

@@ -1,6 +1,8 @@
 # PlumeFileToC.cmake
 # Builds the file_to_c tool for embedding binary files as C arrays
 
+include(${CMAKE_CURRENT_LIST_DIR}/PlumeHostTool.cmake)
+
 # Build the file_to_c tool for the host system
 function(plume_build_file_to_c)
     if(TARGET plume_file_to_c)
@@ -14,31 +16,67 @@ function(plume_build_file_to_c)
         message(FATAL_ERROR "plume file_to_c.cpp not found at ${FILE_TO_C_SOURCE}")
     endif()
 
-    add_executable(plume_file_to_c ${FILE_TO_C_SOURCE})
-    set_target_properties(plume_file_to_c PROPERTIES
-        RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/plume_tools"
-        CXX_STANDARD 17
-        CXX_STANDARD_REQUIRED ON
-    )
+    if(IOS)
+        message(STATUS "Plume - Building file_to_c as HOST tool")
+
+        set(HOST_PROJECT_DIR "${CMAKE_BINARY_DIR}/host-tools/file_to_c-src")
+        set(HOST_BUILD_DIR "${CMAKE_BINARY_DIR}/host-tools/file_to_c-build")
+        set(HOST_INSTALL_DIR "${CMAKE_BINARY_DIR}/host-tools/install")
+
+        set(_host_file_to_c_cmake [=[
+cmake_minimum_required(VERSION 3.16)
+project(plume_host_file_to_c LANGUAGES CXX)
+
+add_executable(plume_file_to_c "@FILE_TO_C_SOURCE@")
+set_target_properties(plume_file_to_c PROPERTIES
+    CXX_STANDARD 17
+    CXX_STANDARD_REQUIRED ON
+)
+install(TARGETS plume_file_to_c RUNTIME DESTINATION bin)
+]=])
+        string(REPLACE "@FILE_TO_C_SOURCE@" "${FILE_TO_C_SOURCE}" _host_file_to_c_cmake "${_host_file_to_c_cmake}")
+        file(WRITE "${HOST_PROJECT_DIR}/CMakeLists.txt" "${_host_file_to_c_cmake}")
+        plume_add_host_tool(HOST_FILE_TO_C_BIN plume_file_to_c "${FILE_TO_C_SOURCE}" "${HOST_PROJECT_DIR}" "${HOST_BUILD_DIR}" "${HOST_INSTALL_DIR}")
 
-    if(APPLE)
+        set(PLUME_FILE_TO_C_EXECUTABLE "${HOST_FILE_TO_C_BIN}" CACHE INTERNAL "Path to host file_to_c executable")
+    else()
+        message(STATUS "Plume - Building file_to_c")
+        add_executable(plume_file_to_c ${FILE_TO_C_SOURCE})
         set_target_properties(plume_file_to_c PROPERTIES
-            XCODE_ATTRIBUTE_CODE_SIGN_IDENTITY "-"
+            RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/plume_tools"
+            CXX_STANDARD 17
+            CXX_STANDARD_REQUIRED ON
         )
+        set(PLUME_FILE_TO_C_EXECUTABLE "$<TARGET_FILE:plume_file_to_c>" CACHE INTERNAL "Path to file_to_c executable")
+
+        if(APPLE AND TARGET plume_file_to_c)
+            set_target_properties(plume_file_to_c PROPERTIES
+                XCODE_ATTRIBUTE_CODE_SIGN_IDENTITY "-"
+            )
+        endif()
     endif()
 endfunction()
 
+function(plume_get_file_to_c_command OUT_VAR)
+    if(NOT DEFINED PLUME_FILE_TO_C_EXECUTABLE)
+        message(FATAL_ERROR "PLUME_FILE_TO_C_EXECUTABLE not set. Call plume_build_file_to_c() first.")
+    endif()
+
+    set(${OUT_VAR} "${PLUME_FILE_TO_C_EXECUTABLE}" PARENT_SCOPE)
+endfunction()
+
 # Convert a binary file to a C header
 # Usage: plume_file_to_c_header(INPUT_FILE OUTPUT_C OUTPUT_H VARIABLE_NAME)
 function(plume_file_to_c_header INPUT_FILE VARIABLE_NAME OUTPUT_C OUTPUT_H)
     plume_build_file_to_c()
+    plume_get_file_to_c_command(FILE_TO_C_CMD)
 
     get_filename_component(OUTPUT_DIR "${OUTPUT_C}" DIRECTORY)
     file(MAKE_DIRECTORY "${OUTPUT_DIR}")
 
     add_custom_command(
         OUTPUT "${OUTPUT_C}" "${OUTPUT_H}"
-        COMMAND plume_file_to_c "${INPUT_FILE}" "${VARIABLE_NAME}" "${OUTPUT_C}" "${OUTPUT_H}"
+        COMMAND ${FILE_TO_C_CMD} "${INPUT_FILE}" "${VARIABLE_NAME}" "${OUTPUT_C}" "${OUTPUT_H}"
         DEPENDS "${INPUT_FILE}" plume_file_to_c
         COMMENT "Generating C header for ${VARIABLE_NAME}"
         VERBATIM

examples/cmake/modules/PlumeHostTool.cmake

@@ -0,0 +1,61 @@
+# Shared helpers for building host tools from an iOS cross-compile
+
+function(_plume_get_host_build_type OUT_VAR)
+    if(CMAKE_BUILD_TYPE)
+        set(${OUT_VAR} "${CMAKE_BUILD_TYPE}" PARENT_SCOPE)
+    else()
+        set(${OUT_VAR} "Release" PARENT_SCOPE)
+    endif()
+endfunction()
+
+function(_plume_host_tool_env_prefix OUT_VAR)
+    set(${OUT_VAR}
+        ${CMAKE_COMMAND} -E env
+        --unset=SDKROOT
+        --unset=ARCHS
+        --unset=IPHONEOS_DEPLOYMENT_TARGET
+        --unset=MACOSX_DEPLOYMENT_TARGET
+        --unset=PLATFORM_NAME
+        --unset=EFFECTIVE_PLATFORM_NAME
+        --unset=CC
+        --unset=CXX
+        --unset=CFLAGS
+        --unset=CXXFLAGS
+        --unset=LDFLAGS
+        PARENT_SCOPE
+    )
+endfunction()
+
+function(plume_add_host_tool OUT_HOST_OUTPUT_BIN TARGET_NAME TOOL_SOURCE HOST_PROJECT_DIR HOST_BUILD_DIR HOST_INSTALL_DIR)
+    _plume_get_host_build_type(HOST_BUILD_TYPE)
+    _plume_host_tool_env_prefix(HOST_ENV_PREFIX)
+
+    file(MAKE_DIRECTORY "${HOST_PROJECT_DIR}")
+
+    if(CMAKE_HOST_WIN32)
+        set(HOST_EXE_SUFFIX ".exe")
+    else()
+        set(HOST_EXE_SUFFIX "")
+    endif()
+
+    set(HOST_OUTPUT_PATH "${HOST_INSTALL_DIR}/bin/${TARGET_NAME}${HOST_EXE_SUFFIX}")
+
+    add_custom_command(OUTPUT "${HOST_OUTPUT_PATH}"
+        COMMAND ${HOST_ENV_PREFIX}
+        ${CMAKE_COMMAND} -S "${HOST_PROJECT_DIR}" -B "${HOST_BUILD_DIR}" -G "Unix Makefiles"
+        -DCMAKE_BUILD_TYPE=${HOST_BUILD_TYPE}
+        -DCMAKE_OSX_SYSROOT=macosx
+        -DCMAKE_OSX_ARCHITECTURES=${CMAKE_HOST_SYSTEM_PROCESSOR}
+        COMMAND ${HOST_ENV_PREFIX}
+        ${CMAKE_COMMAND} --build "${HOST_BUILD_DIR}" --config ${HOST_BUILD_TYPE} --target ${TARGET_NAME}
+        COMMAND ${CMAKE_COMMAND} --install "${HOST_BUILD_DIR}" --config ${HOST_BUILD_TYPE} --prefix "${HOST_INSTALL_DIR}"
+        DEPENDS "${TOOL_SOURCE}"
+        COMMENT "Building host ${TARGET_NAME} tool"
+        USES_TERMINAL
+        VERBATIM
+    )
+
+    add_custom_target(${TARGET_NAME} DEPENDS "${HOST_OUTPUT_PATH}")
+
+    set(${OUT_HOST_OUTPUT_BIN} "${HOST_OUTPUT_PATH}" PARENT_SCOPE)
+endfunction()