unom/punktfunk
1
0
Fork 0
Code Issues Pull Requests Actions 18 Packages Projects Releases 24 Wiki Activity
Files
767f028bdf05d7ef105b9c8e9c171ff1bb40e69f
punktfunk/crates/pyrowave-sys/vendor/pyrowave/Granite/CMakeLists.txt
T
enricobuehler 4c3b11445c feat(host): vendor PyroWave + minimal Granite subset as crates/pyrowave-sys 
Phase 0 of design/pyrowave-codec-plan.md — the opt-in wired-LAN ultra-low-
latency codec. Vendored at upstream 509e4f88 (API 0.4.0, Granite 44362775,
volk + vulkan-headers pins in PUNKTFUNK-VENDOR.txt), pruned to the 6.6 MB
the standalone no-renderer build needs; scripts/vendor-pyrowave.sh
reproduces the tree (a pin bump is protocol-affecting, plan §4.2).

build.rs drives the wrapper CMakeLists (static archives incl. a static
C-API lib upstream only ships shared) + bindgen over pyrowave.h; Linux and
Windows only, empty stub elsewhere (Apple gets a native Metal port, §4.7).
Offline-safe by construction: no network, no system lib, vendored Vulkan
headers — same model as the opus dep (flatpak builder has no network).

Phase-0 validation on .21 (RTX 5070 Ti, driver 610.43.03):
- upstream pyrowave-c-test + interop test (incl. dmabuf/DRM-modifier
  Vulkan<->Vulkan) pass, from the pristine AND the pruned tree
- GPU kernel times at ~1.6 bpp noise: encode/decode 0.090/0.042 ms @800p,
  0.146/0.067 @1080p, 0.226/0.103 @1440p, 0.477/0.201 @4K — order of
  magnitude under NVENC's 1-2 ms retrieve, CBR lands within ~100 B of
  target
- cargo test -p pyrowave-sys green (static link + API-version pin check)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-15 00:35:10 +02:00

387 lines
15 KiB
CMake
Raw Blame History

cmake_minimum_required(VERSION 3.6)
set(CMAKE_CXX_STANDARD 14)
set(CMAKE_C_STANDARD 99)
project(Granite LANGUAGES CXX C)
if (CMAKE_COMPILER_IS_GNUCXX OR (${CMAKE_CXX_COMPILER_ID} MATCHES "Clang"))
set(GRANITE_CXX_FLAGS -Wshadow -Wall -Wextra -Wno-comment -Wno-missing-field-initializers -Wno-empty-body)
if (${CMAKE_CXX_COMPILER_ID} MATCHES "Clang")
set(GRANITE_CXX_FLAGS ${GRANITE_CXX_FLAGS} -Wno-backslash-newline-escape)
endif()
if (NOT (${CMAKE_BUILD_TYPE} MATCHES "Release"))
message("Enabling frame pointer for profiling/debug.")
set(GRANITE_CXX_FLAGS ${GRANITE_CXX_FLAGS} -fno-omit-frame-pointer)
endif()
if (CMAKE_SYSTEM_PROCESSOR MATCHES "(x86)|(X86)|(amd64)|(AMD64)")
message("Enabling SSE3 support.")
set(GRANITE_CXX_FLAGS ${GRANITE_CXX_FLAGS} -msse3)
endif()
elseif (MSVC)
set(GRANITE_CXX_FLAGS /D_CRT_SECURE_NO_WARNINGS /wd4267 /wd4244 /wd4309 /wd4005 /MP)
endif()
include(GNUInstallDirs)
option(GRANITE_SHARED "Build Granite as a shared library." OFF)
option(GRANITE_ISPC_TEXTURE_COMPRESSION "Enable ISPC texture compression" OFF)
option(GRANITE_ASTC_ENCODER_COMPRESSION "Enable astc-encoder texture compression" OFF)
option(GRANITE_TOOLS "Build Granite tools." ON)
option(GRANITE_KHR_DISPLAY_ACQUIRE_XLIB "Try to acquire Xlib display when using VK_KHR_display." OFF)
option(GRANITE_ANDROID_APK_FILESYSTEM "Use APK file system for assets and builtin files." ON)
option(GRANITE_ANDROID_SWAPPY "Use swappy on Android." OFF)
option(GRANITE_SHADER_COMPILER_OPTIMIZE "Optimize SPIR-V." ON)
option(GRANITE_VULKAN_SYSTEM_HANDLES "Add system handle support to Vulkan backend." ON)
option(GRANITE_RENDERER "Add higher level rendering functionality." ON)
option(GRANITE_VULKAN_SPIRV_CROSS "Add reflection support to Vulkan backend." ON)
option(GRANITE_VULKAN_SHADER_MANAGER_RUNTIME_COMPILER "Enable Vulkan GLSL runtime compiler." ON)
option(GRANITE_VULKAN_FOSSILIZE "Enable support for Fossilize." ON)
option(GRANITE_VULKAN_PROFILES "Enable profiles support." OFF)
option(GRANITE_VULKAN_DXGI_INTEROP "Enable DXGI interop when running on Windows." ON)
option(GRANITE_VULKAN_POST_MORTEM "Add extra support for port-mortem debug." OFF)
option(GRANITE_AUDIO "Enable Audio support." OFF)
option(GRANITE_PLATFORM "Granite Platform" "SDL")
option(GRANITE_HIDDEN "Declare symbols as hidden by default. Useful if you build Granite as a static library and you link to it in your shared library." OFF)
option(GRANITE_SANITIZE_ADDRESS "Sanitize address" OFF)
option(GRANITE_SANITIZE_THREADS "Sanitize threads" OFF)
option(GRANITE_SANITIZE_MEMORY "Sanitize memory" OFF)
option(GRANITE_TARGET_NATIVE "Target native arch (-march=native)" OFF)
option(GRANITE_BULLET "Enable Bullet support." OFF)
option(GRANITE_RENDERDOC_CAPTURE "Enable support for RenderDoc capture from API." ON)
option(GRANITE_INSTALL_TARGETS "Add install targets." ON)
option(GRANITE_INSTALL_EXE_TARGETS "Add executable install targets." OFF)
option(GRANITE_FFMPEG "Enable FFmpeg." OFF)
option(GRANITE_FFMPEG_VULKAN "Enable experimental Vulkan HW decode support in FFmpeg." OFF)
option(GRANITE_FAST_MATH "Enable fast math." OFF)
option(GRANITE_SHIPPING "Disable code paths not related to development." OFF)
option(GRANITE_SYSTEM_SDL "Use system SDL3 instead of vendored submodule." OFF)
if (GRANITE_FAST_MATH)
message("Enabling fast math.")
if (CMAKE_COMPILER_IS_GNUCXX OR (${CMAKE_CXX_COMPILER_ID} MATCHES "Clang"))
set(GRANITE_CXX_FLAGS ${GRANITE_CXX_FLAGS} -ffast-math)
elseif (MSVC)
set(GRANITE_CXX_FLAGS ${GRANITE_CXX_FLAGS} /fp:fast)
endif()
else()
message("Enabling precise math.")
if (MSVC)
set(GRANITE_CXX_FLAGS ${GRANITE_CXX_FLAGS} /fp:precise)
endif()
endif()
if (NOT GRANITE_PLATFORM)
set(GRANITE_PLATFORM "SDL")
endif()
if (GRANITE_HIDDEN)
if (CMAKE_COMPILER_IS_GNUCXX OR (${CMAKE_CXX_COMPILER_ID} MATCHES "Clang"))
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden")
endif()
elseif(${GRANITE_PLATFORM} MATCHES "libretro")
if (NOT GRANITE_SHARED)
if (CMAKE_COMPILER_IS_GNUCXX OR (${CMAKE_CXX_COMPILER_ID} MATCHES "Clang"))
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden")
endif()
endif()
endif()
if (GRANITE_TARGET_NATIVE)
if (CMAKE_COMPILER_IS_GNUCXX OR (${CMAKE_CXX_COMPILER_ID} MATCHES "Clang"))
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=native")
endif()
endif()
set(GRANITE_LINK_FLAGS)
if (${CMAKE_VERSION} GREATER "3.13")
# Executable targets are not stripped in release mode on Android, do it explicitly.
add_link_options($<$<AND:$<PLATFORM_ID:Android>,$<CONFIG:RELEASE>>:-s>)
endif()
if (GRANITE_SANITIZE_ADDRESS)
set(GRANITE_CXX_FLAGS ${GRANITE_CXX_FLAGS} -fsanitize=address)
set(GRANITE_LINK_FLAGS "${GRANITE_LINK_FLAGS} -fsanitize=address")
endif()
if (GRANITE_SANITIZE_THREADS)
set(GRANITE_CXX_FLAGS ${GRANITE_CXX_FLAGS} -fsanitize=thread)
set(GRANITE_LINK_FLAGS "${GRANITE_LINK_FLAGS} -fsanitize=thread")
endif()
if (GRANITE_SANITIZE_MEMORY)
set(GRANITE_CXX_FLAGS ${GRANITE_CXX_FLAGS} -fsanitize=memory)
set(GRANITE_LINK_FLAGS "${GRANITE_LINK_FLAGS} -fsanitize=memory")
endif()
if (ANDROID)
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
endif()
if (GRANITE_SHARED)
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
endif()
if (GRANITE_SHARED)
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
else()
if (${GRANITE_PLATFORM} MATCHES "libretro")
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
elseif (GRANITE_POSITION_INDEPENDENT)
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
elseif (ANDROID)
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
else()
set(CMAKE_POSITION_INDEPENDENT_CODE OFF)
endif()
endif()
set(GRANITE_VERSION_MAJOR 0)
set(GRANITE_VERSION_MINOR 0)
set(GRANITE_VERSION_PATCH 0)
# Make sure .dlls are placed next to .exe, since there is no RPATH.
if (WIN32)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
endif()
function(granite_install_executable NAME)
install(TARGETS ${NAME} LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
if (NOT WIN32)
set_target_properties(${NAME} PROPERTIES INSTALL_RPATH "\$ORIGIN/../lib")
endif()
endfunction()
macro(granite_setup_default_link_libraries NAME)
if (NOT WIN32)
target_link_libraries(${NAME} PRIVATE -pthread dl m)
find_library(LIBRT_LIBRARY rt)
if (EXISTS ${LIBRT_LIBRARY})
target_link_libraries(${NAME} PUBLIC rt)
endif()
endif()
if (WIN32 AND CMAKE_COMPILER_IS_GNUCXX)
target_link_libraries(${NAME} PRIVATE -static gcc stdc++ winpthread)
endif()
endmacro()
function(add_granite_third_party_lib NAME)
if (GRANITE_SHARED)
add_library(${NAME} SHARED ${ARGN})
if (GRANITE_INSTALL_TARGETS)
if (WIN32)
install(TARGETS ${NAME} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
else()
install(TARGETS ${NAME} DESTINATION ${CMAKE_INSTALL_LIBDIR})
set_target_properties(${NAME} PROPERTIES INSTALL_RPATH "\$ORIGIN/")
set_target_properties(${NAME} PROPERTIES
VERSION ${GRANITE_VERSION_MAJOR}.${GRANITE_VERSION_MINOR}.${GRANITE_VERSION_PATCH}
SOVERSION ${GRANITE_VERSION_MAJOR})
endif()
endif()
granite_setup_default_link_libraries(${NAME})
if (CMAKE_COMPILER_IS_GNUCXX OR (${CMAKE_CXX_COMPILER_ID} MATCHES "Clang"))
set_target_properties(${NAME} PROPERTIES LINK_FLAGS "-Wl,--no-undefined")
endif()
if (MSVC)
set_target_properties(${NAME} PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON)
endif()
else()
add_library(${NAME} STATIC ${ARGN})
if (MSVC)
set_target_properties(${NAME} PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS OFF)
endif()
endif()
endfunction()
function(add_granite_internal_lib NAME)
add_granite_third_party_lib(${NAME} ${ARGN})
target_compile_options(${NAME} PRIVATE ${GRANITE_CXX_FLAGS})
if (GRANITE_SHARED AND MSVC)
set_target_properties(${NAME} PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON)
endif()
endfunction()
function(add_granite_internal_static_lib NAME)
add_library(${NAME} STATIC ${ARGN})
target_compile_options(${NAME} PRIVATE ${GRANITE_CXX_FLAGS})
endfunction()
add_subdirectory(third_party)
add_subdirectory(util)
add_subdirectory(path)
add_subdirectory(math)
add_subdirectory(threading)
add_subdirectory(compiler)
add_subdirectory(filesystem)
add_subdirectory(vulkan)
add_subdirectory(ecs)
add_subdirectory(event)
if (GRANITE_VULKAN_SYSTEM_HANDLES AND GRANITE_RENDERER)
add_subdirectory(renderer)
add_subdirectory(ui)
add_subdirectory(scene-export)
endif()
if (GRANITE_FFMPEG)
add_subdirectory(video)
endif()
add_subdirectory(application)
if (GRANITE_AUDIO)
add_subdirectory(audio)
endif()
if (GRANITE_BULLET)
add_subdirectory(physics)
endif()
add_library(granite-base INTERFACE)
target_link_libraries(granite-base INTERFACE granite-util granite-path granite-application granite-vulkan)
if (TARGET granite-renderer)
target_link_libraries(granite-base INTERFACE granite-renderer granite-ui)
endif()
function(add_granite_executable NAME)
if (ANDROID)
add_library(${NAME} SHARED ${ARGN})
target_link_libraries(${NAME} PRIVATE log android)
elseif(${GRANITE_PLATFORM} MATCHES "libretro")
add_library(${NAME} SHARED ${ARGN})
if (CMAKE_COMPILER_IS_GNUCXX OR (${CMAKE_CXX_COMPILER_ID} MATCHES "Clang"))
set_target_properties(${NAME} PROPERTIES LINK_FLAGS "-Wl,--no-undefined")
endif()
else()
add_executable(${NAME} ${ARGN})
endif()
# Need this for some reason on OSX.
if (APPLE)
set_target_properties(${NAME} PROPERTIES LINK_FLAGS "-Wl,-all_load")
endif()
target_link_libraries(${NAME} PRIVATE granite-base granite-application-global-init)
target_compile_options(${NAME} PRIVATE ${GRANITE_CXX_FLAGS})
granite_setup_default_link_libraries(${NAME})
if (GRANITE_SANITIZE_ADDRESS OR GRANITE_SANITIZE_THREADS OR GRANITE_SANITIZE_MEMORY)
set_target_properties(${NAME} PROPERTIES LINK_FLAGS "${GRANITE_LINK_FLAGS}")
endif()
endfunction()
function(add_granite_application TARGET_NAME)
if (WIN32 AND (NOT ${GRANITE_PLATFORM} MATCHES "libretro"))
add_granite_executable(${TARGET_NAME} WIN32 ${ARGN})
else()
add_granite_executable(${TARGET_NAME} ${ARGN})
endif()
if (ANDROID)
target_link_libraries(${TARGET_NAME} PRIVATE granite-base granite-platform)
elseif (${GRANITE_PLATFORM} MATCHES "libretro")
target_link_libraries(${TARGET_NAME} PRIVATE granite-base granite-platform)
else()
target_link_libraries(${TARGET_NAME} PRIVATE granite-application-entry)
endif()
granite_setup_default_link_libraries(${TARGET_NAME})
if (GRANITE_INSTALL_EXE_TARGETS)
granite_install_executable(${TARGET_NAME})
endif()
endfunction()
function(add_granite_headless_application TARGET_NAME)
add_executable(${TARGET_NAME} ${ARGN})
target_compile_options(${TARGET_NAME} PRIVATE ${GRANITE_CXX_FLAGS})
if (GRANITE_SANITIZE_ADDRESS OR GRANITE_SANITIZE_THREADS OR GRANITE_SANITIZE_MEMORY)
set_target_properties(${TARGET_NAME} PROPERTIES LINK_FLAGS "${GRANITE_LINK_FLAGS}")
endif()
if (ANDROID)
target_link_libraries(${TARGET_NAME} PRIVATE log android)
endif()
target_link_libraries(${TARGET_NAME} PRIVATE granite-base granite-application-entry-headless)
granite_setup_default_link_libraries(${TARGET_NAME})
if (GRANITE_INSTALL_EXE_TARGETS)
granite_install_executable(${TARGET_NAME})
endif()
endfunction()
function(add_granite_offline_tool NAME)
add_executable(${NAME} ${ARGN})
target_compile_options(${NAME} PRIVATE ${GRANITE_CXX_FLAGS})
# Need this for some reason on OSX.
if (APPLE)
set_target_properties(${NAME} PROPERTIES LINK_FLAGS "-Wl,-all_load")
endif()
target_link_libraries(${NAME} PRIVATE granite-base granite-application-global-init)
target_compile_options(${NAME} PRIVATE ${GRANITE_CXX_FLAGS})
if (GRANITE_SANITIZE_ADDRESS OR GRANITE_SANITIZE_THREADS OR GRANITE_SANITIZE_MEMORY)
set_target_properties(${NAME} PROPERTIES LINK_FLAGS "${GRANITE_LINK_FLAGS}")
endif()
granite_setup_default_link_libraries(${NAME})
if (GRANITE_INSTALL_EXE_TARGETS)
granite_install_executable(${NAME})
endif()
endfunction()
if ("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_SOURCE_DIR}")
set(GRANITE_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
else()
set(GRANITE_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}" PARENT_SCOPE)
set(GRANITE_CXX_FLAGS ${GRANITE_CXX_FLAGS} PARENT_SCOPE)
set(GRANITE_LINK_FLAGS ${GRANITE_LINK_FLAGS} PARENT_SCOPE)
endif()
function(add_blob_archive_target TARGET_NAME BLOB_NAME)
find_package(Python3 REQUIRED)
set_source_files_properties(
${CMAKE_BINARY_DIR}/${BLOB_NAME}.h
${CMAKE_BINARY_DIR}/${BLOB_NAME}.c
PROPERTIES GENERATED ON)
add_library(${TARGET_NAME} STATIC
${CMAKE_BINARY_DIR}/${BLOB_NAME}.h
${CMAKE_BINARY_DIR}/${BLOB_NAME}.c)
target_include_directories(${TARGET_NAME} PUBLIC ${CMAKE_BINARY_DIR})
# ... CMake, y u gotta be like this.
set(_arg_list)
set(_arg_counter 0)
foreach(_arg IN LISTS ARGN)
math(EXPR _arg_counter_mod "${_arg_counter} % 2")
if (NOT ${_arg_counter_mod})
list(APPEND _arg_list --input)
endif()
list(APPEND _arg_list ${_arg})
math(EXPR _arg_counter "${_arg_counter} + 1")
endforeach()
add_custom_command(OUTPUT
${CMAKE_BINARY_DIR}/${BLOB_NAME}.h
${CMAKE_BINARY_DIR}/${BLOB_NAME}.c
COMMAND ${Python3_EXECUTABLE}
${GRANITE_SOURCE_DIR}/tools/blobify.py
--output ${CMAKE_BINARY_DIR}/${BLOB_NAME}.blob
${_arg_list}
COMMAND ${Python3_EXECUTABLE}
${GRANITE_SOURCE_DIR}/tools/bin_to_text.py
--output ${CMAKE_BINARY_DIR}/${BLOB_NAME}
--blob-name ${BLOB_NAME}
${CMAKE_BINARY_DIR}/${BLOB_NAME}.blob
BYPRODUCTS
${CMAKE_BINARY_DIR}/${BLOB_NAME}.blob)
endfunction()
if (TARGET granite-renderer)
add_subdirectory(tests)
add_subdirectory(viewer)
if (GRANITE_TOOLS)
add_subdirectory(tools)
add_subdirectory(renderer/fft/test)
endif()
endif()
if (GRANITE_TOOLS AND GRANITE_VULKAN_SPIRV_CROSS AND GRANITE_VULKAN_SHADER_MANAGER_RUNTIME_COMPILER)
add_subdirectory(slangmosh)
endif()
Reference in New Issue View Git Blame Copy Permalink