oak-team/oak-editor
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
d57c812fa6be312c6e300272cf604fd9c5f1032b
oak-editor/engine/CMakeLists.txt
T
Mike-Solar d57c812fa6 ci: fix three platform-specific build failures 
- Linux: Qt6 metatype static_assert requires complete types; declare
  OakEngineBlock with Q_DECLARE_OPAQUE_POINTER in the public header
  (outside extern "C")
- Windows: gtest discovery runs the freshly linked test exe at build
  time and it cannot find the DLLs (0xc0000135); copy oakcore/oakengine/
  ffmpeg_bridge DLLs next to the test binaries on WIN32
- macOS: Imath header mixing between otio-install's stale bundled Imath
  and Homebrew's Imath broke ImathBox.h (V2h undeclared); bump the OTIO
  cache to v2 and drop bundled Imath headers so the system one is the
  only set in play
2026-08-02 16:24:16 +08:00

528 lines
22 KiB
CMake
Raw Blame History

# Oak - Non-Linear Video Editor
# Copyright (C) 2026 Oak Team
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# Add version object
add_library(olive-version-obj
OBJECT
version.cpp
version.h
)
target_link_libraries(olive-version-obj PRIVATE Qt${QT_VERSION_MAJOR}::Core)
target_compile_options(olive-version-obj PRIVATE -DAPPVERSION="${PROJECT_VERSION}" -DAPPVERSIONLONG="${PROJECT_LONG_VERSION}")
# Engine library (liboakengine): the node graph, render pipeline, codecs,
# timeline, task system and engine services, independent of the editor UI.
# The editor (app/) and the render worker (worker/) both link against it.
set(OLIVE_SOURCES
coreengine.h
coreengine.cpp
)
add_subdirectory(audio)
add_subdirectory(cli)
add_subdirectory(codec)
add_subdirectory(config)
add_subdirectory(node)
add_subdirectory(render)
add_subdirectory(shaders)
add_subdirectory(task)
add_subdirectory(timeline)
add_subdirectory(tool)
add_subdirectory(ui)
add_subdirectory(undo)
add_subdirectory(src/capi)
# Object library: compiled once, consumed by both the shared library (with
# version-script restrictions) and internal test executables (unrestricted).
add_library(oakengine-obj OBJECT
${OLIVE_SOURCES}
${OLIVE_RESOURCES}
)
add_library(oakengine SHARED $<TARGET_OBJECTS:oakengine-obj>)
if (COMMAND oak_copy_otio_runtime)
oak_copy_otio_runtime(oakengine)
endif()
# macOS: hides the render worker's dock icon; called from the worker main in
# src/capi/worker.cpp (declared there as a plain C++ symbol).
if (APPLE)
target_sources(oakengine-obj PRIVATE src/worker_dockicon_mac.mm)
target_link_libraries(oakengine PRIVATE "-framework Cocoa")
endif ()
add_subdirectory(common)
add_subdirectory(pluginSupport)
target_compile_features(oakengine-obj PUBLIC cxx_std_23)
set_target_properties(oakengine-obj PROPERTIES
POSITION_INDEPENDENT_CODE ON
)
set_target_properties(oakengine PROPERTIES
OUTPUT_NAME oakengine
)
# Consumers resolve engine headers ("node/...", "render/...", "coreengine.h",
# "tool/tool.h") from the engine root, and the public C
# API ("oakengine/ipc.h") from include/. The library itself builds against its
# internal implementation headers under src/oliveimpl, included with an
# "oliveimpl/"-prefixed path resolved from src/ (mirrors the src/oliveimpl
# comment in core/CMakeLists.txt). A plain include-order trick like core's
# cannot work here: CMAKE_INCLUDE_CURRENT_DIR puts the engine root ahead of
# every target-level directory, so the prefixed paths are what keep internal
# sources from ever picking up a consumer wrapper header by accident.
target_include_directories(oakengine-obj
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}
PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include
PRIVATE ${CMAKE_SOURCE_DIR}/third_party/openfx/include
${CMAKE_SOURCE_DIR}/third_party/openfx/HostSupport/include
${OLIVE_INCLUDE_DIRS}
)
target_link_libraries(oakengine-obj PUBLIC ${OLIVE_LIBRARIES} OfxHost)
target_link_libraries(oakengine PRIVATE oakengine-obj)
# Propagate engine header paths to consumers of the shared library
# (the OBJECT lib's PUBLIC includes don't transit through a PRIVATE link).
target_include_directories(oakengine
PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}
PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include
)
# Consumers also need the third-party link deps (Qt, FFmpeg, etc.)
target_link_libraries(oakengine PUBLIC ${OLIVE_LIBRARIES} OfxHost)
# OAKENGINE_BUILD marks the library side of the C ABI export macros (dllexport)
target_compile_definitions(oakengine-obj PRIVATE ${OLIVE_DEFINITIONS} OAKENGINE_BUILD)
target_compile_options(oakengine-obj PRIVATE ${OLIVE_COMPILE_OPTIONS})
# Version script: only oakengine_* + render-backend plugin ABI are exported;
# all other C++ internals are hidden (local: *).
if (UNIX AND NOT APPLE)
target_link_options(oakengine PRIVATE
"LINKER:--version-script,${CMAKE_CURRENT_SOURCE_DIR}/oakengine.ver")
set_target_properties(oakengine PROPERTIES LINK_DEPENDS
${CMAKE_CURRENT_SOURCE_DIR}/oakengine.ver)
endif ()
# olive::k_app_version is intentionally left undefined in the shared library
# and provided by the final executable via olive-version-obj (see
# worker/CMakeLists.txt). ELF allows undefined symbols in shared libraries by
# default; the macOS linker does not, so whitelist that one symbol.
if (APPLE)
target_link_options(oakengine PRIVATE "LINKER:-U,__ZN5olive13k_app_versionE")
endif ()
# Install into the platform's standard library directory (/usr/lib,
# /usr/lib64 or the Debian multiarch path); Windows DLLs go next to the
# executables in bin.
include(GNUInstallDirs)
if (WIN32)
install(TARGETS oakengine
RUNTIME DESTINATION bin
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
else ()
install(TARGETS oakengine
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
endif ()
if (UNIX AND NOT APPLE)
set_target_properties(oakengine PROPERTIES INSTALL_RPATH "$ORIGIN")
endif ()
# Dynamic render backends (OpenGL/Vulkan) are engine plugins loaded via
# dlopen; they share this engine library instead of embedding a static
# render-core subset.
option(OAK_ENABLE_DYNAMIC_RENDER_BACKEND
"Build OpenGL/Vulkan render backends as dlopen plugins (oakgl/oakvulkan)" ON)
if (OAK_ENABLE_DYNAMIC_RENDER_BACKEND)
target_compile_definitions(oakengine-obj PRIVATE OAK_ENABLE_DYNAMIC_RENDER_BACKEND)
foreach (target olivecore kddockwidgets)
if (TARGET ${target})
set_target_properties(${target} PROPERTIES POSITION_INDEPENDENT_CODE ON)
endif ()
endforeach ()
add_library(oakgl SHARED
render/opengl/openglbackend_c.cpp
render/opengl/openglrenderer.cpp
render/opengl/openglrenderer.h
)
target_link_libraries(oakgl PRIVATE oakengine)
if (COMMAND oak_copy_otio_runtime)
oak_copy_otio_runtime(oakgl)
endif()
target_include_directories(oakgl PRIVATE ${OLIVE_INCLUDE_DIRS})
target_compile_definitions(oakgl PRIVATE OAK_RENDER_BACKEND_PLUGIN)
set_target_properties(oakgl PROPERTIES
OUTPUT_NAME oakgl
LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
)
if (WIN32)
set_target_properties(oakgl PROPERTIES PREFIX "")
endif ()
install(TARGETS oakgl
RUNTIME DESTINATION bin
LIBRARY DESTINATION lib
ARCHIVE DESTINATION lib
)
if (Vulkan_FOUND)
add_library(oakvulkan SHARED
render/vulkan/vulkanbackend_c.cpp
render/vulkan/vulkanrenderer.cpp
render/vulkan/vulkanrenderer.h
)
target_link_libraries(oakvulkan PRIVATE oakengine)
if (COMMAND oak_copy_otio_runtime)
oak_copy_otio_runtime(oakvulkan)
endif()
target_include_directories(oakvulkan PRIVATE ${OLIVE_INCLUDE_DIRS})
target_link_libraries(oakvulkan PRIVATE Vulkan::Vulkan)
target_compile_definitions(oakvulkan PRIVATE OAK_HAS_VULKAN)
if (SHADERC_FOUND)
target_link_libraries(oakvulkan PRIVATE ${SHADERC_LIBRARIES})
target_include_directories(oakvulkan PRIVATE ${SHADERC_INCLUDE_DIRS})
target_compile_definitions(oakvulkan PRIVATE OAK_HAS_SHADERC)
endif ()
set_target_properties(oakvulkan PROPERTIES
OUTPUT_NAME oakvulkan
LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
)
if (WIN32)
set_target_properties(oakvulkan PROPERTIES PREFIX "")
endif ()
install(TARGETS oakvulkan
RUNTIME DESTINATION bin
LIBRARY DESTINATION lib
ARCHIVE DESTINATION lib
)
endif ()
add_library(oakgl-cabi-check OBJECT
render/opengl/openglbackend_c.cpp
)
target_include_directories(oakgl-cabi-check PRIVATE
${CMAKE_SOURCE_DIR}/app
${CMAKE_SOURCE_DIR}/third_party/openfx/include
${CMAKE_SOURCE_DIR}/third_party/openfx/HostSupport/include
${OLIVE_INCLUDE_DIRS}
)
target_link_libraries(oakgl-cabi-check PRIVATE ${OLIVE_LIBRARIES} OfxHost)
target_compile_definitions(oakgl-cabi-check PRIVATE ${OLIVE_DEFINITIONS})
target_compile_options(oakgl-cabi-check PRIVATE ${OLIVE_COMPILE_OPTIONS})
if (Vulkan_FOUND)
add_library(oakvulkan-cabi-check OBJECT
render/vulkan/vulkanbackend_c.cpp
render/vulkan/vulkanrenderer.cpp
render/vulkan/vulkanrenderer.h
)
target_include_directories(oakvulkan-cabi-check PRIVATE
${CMAKE_SOURCE_DIR}/app
${CMAKE_SOURCE_DIR}/third_party/openfx/include
${CMAKE_SOURCE_DIR}/third_party/openfx/HostSupport/include
${OLIVE_INCLUDE_DIRS}
)
target_link_libraries(oakvulkan-cabi-check PRIVATE Qt${QT_VERSION_MAJOR}::Core Qt${QT_VERSION_MAJOR}::Gui Qt${QT_VERSION_MAJOR}::Widgets)
target_link_libraries(oakvulkan-cabi-check PRIVATE Vulkan::Vulkan)
target_compile_definitions(oakvulkan-cabi-check PRIVATE OAK_HAS_VULKAN)
if (SHADERC_FOUND)
target_link_libraries(oakvulkan-cabi-check PRIVATE ${SHADERC_LIBRARIES})
target_include_directories(oakvulkan-cabi-check PRIVATE ${SHADERC_INCLUDE_DIRS})
target_compile_definitions(oakvulkan-cabi-check PRIVATE OAK_HAS_SHADERC)
endif ()
target_compile_definitions(oakvulkan-cabi-check PRIVATE ${OLIVE_DEFINITIONS})
target_compile_options(oakvulkan-cabi-check PRIVATE ${OLIVE_COMPILE_OPTIONS})
endif ()
endif ()
# Pure C ABI tests for the liboakengine public interface (mirrors the
# make_test pattern in core/CMakeLists.txt). They link only against oakengine
# and must not depend on OpenGL/Vulkan.
if (BUILD_TESTS)
enable_testing()
include(GoogleTest)
function(make_oakengine_gtest name)
# oakengine leaves olive::k_app_version to the final executable; the
# version object library provides it (same as worker/CMakeLists.txt).
# Each facade test keeps its own binary because the tests have
# heterogeneous oakengine_init() flag requirements; the shared
# gtest_main.cpp only bootstraps Google Test (RUN_ALL_TESTS).
add_executable(${name}
tests/${name}.cpp
tests/gtest_main.cpp
$<TARGET_OBJECTS:olive-version-obj>
)
if (COMMAND oak_copy_otio_runtime)
oak_copy_otio_runtime(${name})
endif()
# Link the object library directly to bypass the version-script
# restrictions on liboakengine.so (tests are internal consumers).
target_link_libraries(${name} PRIVATE oakengine-obj GTest::gtest)
target_include_directories(${name} PRIVATE
"${CMAKE_CURRENT_SOURCE_DIR}/include"
)
# -rdynamic exports the test executable's symbols so that dlopen'd
# render backend plugins (oakgl/oakvulkan) can resolve the embedded
# engine objects (Renderer base class, etc.).
if (UNIX AND NOT APPLE)
target_link_options(${name} PRIVATE "LINKER:--export-dynamic")
endif ()
# Freshly linked binaries can exceed the 5s default discovery
# timeout on first run (dyld cold cache + Qt/OCIO init)
gtest_discover_tests(${name} DISCOVERY_TIMEOUT 60)
if (WIN32)
# gtest discovery executes the binary at build time; it needs
# the engine DLLs next to it
add_custom_command(TARGET ${name} POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy_if_different
$<TARGET_FILE:oakengine> $<TARGET_FILE_DIR:${name}>
COMMAND ${CMAKE_COMMAND} -E copy_if_different
$<TARGET_FILE:olivecore> $<TARGET_FILE_DIR:${name}>
COMMAND ${CMAKE_COMMAND} -E copy_if_different
$<TARGET_FILE:ffmpeg_bridge> $<TARGET_FILE_DIR:${name}>)
endif ()
endfunction()
make_oakengine_gtest(oakengine_ipc_test)
make_oakengine_gtest(oakengine_worker_test)
make_oakengine_gtest(oakengine_init_test)
make_oakengine_gtest(oakengine_app_test)
# Resolves the real test assets (tests/demo.mp4, the footage fixture
# project) relative to the repository root, like tests/gtest does.
target_compile_definitions(oakengine_init_test PRIVATE
OAK_TEST_SOURCE_DIR="${CMAKE_SOURCE_DIR}"
)
make_oakengine_gtest(oakengine_task_test)
# The task test creates temporary projects and imports non-existent files,
# so it only needs the headless engine services.
make_oakengine_gtest(oakengine_config_test)
# The config test exercises the QSettings-backed key/value store through
# the C ABI; it is headless and does not touch the disk cache.
make_oakengine_gtest(oakengine_audio_test)
# The audio test exercises the AudioManager instance lifecycle, device
# get/set round-trips and the output_params_changed event. It is headless
# and only needs PortAudio initialization.
make_oakengine_gtest(oakengine_disk_test)
# The disk test exercises the DiskManager instance lifecycle, default cache
# path queries, cache clearing, settings handler dispatch and default path
# mutation. It is headless and only touches temporary directories.
make_oakengine_gtest(oakengine_proxy_test)
# The proxy test exercises proxy parameter defaults, state string
# round-trips and the ProxyManager singleton lifecycle. It is headless.
make_oakengine_gtest(oakengine_lut_test)
# The LUT test exercises directory/file list queries and the
# set_directories round-trip. It is headless.
make_oakengine_gtest(oakengine_serializer_test)
# The serializer test exercises compressed-project detection, clipboard
# create/free/copy and empty-node copy. It is headless.
make_oakengine_gtest(oakengine_renderer_test)
# The renderer test builds sequence content through the engine C++ API
# (allowed for engine-internal tests) and probes the dynamic render
# backend the same way the gtest harness does, so it needs the internal
# include paths and backend definitions (mirrors tests/gtest).
target_include_directories(oakengine_renderer_test PRIVATE
${CMAKE_SOURCE_DIR}/third_party/openfx/include
${CMAKE_SOURCE_DIR}/third_party/openfx/HostSupport/include
${OLIVE_INCLUDE_DIRS}
)
target_compile_definitions(oakengine_renderer_test PRIVATE
${OLIVE_DEFINITIONS}
OAK_TEST_SOURCE_DIR="${CMAKE_SOURCE_DIR}"
)
target_compile_options(oakengine_renderer_test PRIVATE
${OLIVE_COMPILE_OPTIONS}
)
if (OAK_ENABLE_DYNAMIC_RENDER_BACKEND)
target_compile_definitions(oakengine_renderer_test PRIVATE
OAK_ENABLE_DYNAMIC_RENDER_BACKEND)
add_dependencies(oakengine_renderer_test oakgl)
if (TARGET oakvulkan)
add_dependencies(oakengine_renderer_test oakvulkan)
endif ()
endif ()
# render_frame goes through the render worker pool; make sure the worker
# binary in the build tree is up to date.
if (TARGET olive-render-worker)
add_dependencies(oakengine_renderer_test olive-render-worker)
endif ()
make_oakengine_gtest(oakengine_footage_test)
target_compile_definitions(oakengine_footage_test PRIVATE
OAK_TEST_SOURCE_DIR="${CMAKE_SOURCE_DIR}"
)
make_oakengine_gtest(oakengine_timeline_edit_test)
target_compile_definitions(oakengine_timeline_edit_test PRIVATE
OAK_TEST_SOURCE_DIR="${CMAKE_SOURCE_DIR}"
)
make_oakengine_gtest(oakengine_events_test)
target_compile_definitions(oakengine_events_test PRIVATE
OAK_TEST_SOURCE_DIR="${CMAKE_SOURCE_DIR}"
)
make_oakengine_gtest(oakengine_encoding_test)
make_oakengine_gtest(oakengine_color_test)
make_oakengine_gtest(oakengine_export_test)
# The export test builds sequence content through the engine C++ API and
# probes the dynamic render backend like oakengine_renderer_test does.
target_include_directories(oakengine_export_test PRIVATE
${CMAKE_SOURCE_DIR}/third_party/openfx/include
${CMAKE_SOURCE_DIR}/third_party/openfx/HostSupport/include
${OLIVE_INCLUDE_DIRS}
)
target_compile_definitions(oakengine_export_test PRIVATE
${OLIVE_DEFINITIONS}
OAK_TEST_SOURCE_DIR="${CMAKE_SOURCE_DIR}"
)
target_compile_options(oakengine_export_test PRIVATE
${OLIVE_COMPILE_OPTIONS}
)
if (OAK_ENABLE_DYNAMIC_RENDER_BACKEND)
target_compile_definitions(oakengine_export_test PRIVATE
OAK_ENABLE_DYNAMIC_RENDER_BACKEND)
add_dependencies(oakengine_export_test oakgl)
if (TARGET oakvulkan)
add_dependencies(oakengine_export_test oakvulkan)
endif ()
endif ()
if (TARGET olive-render-worker)
add_dependencies(oakengine_export_test olive-render-worker)
endif ()
make_oakengine_gtest(oakengine_node_test)
make_oakengine_gtest(oakengine_nodevalue_test)
target_compile_definitions(oakengine_node_test PRIVATE
OAK_TEST_SOURCE_DIR="${CMAKE_SOURCE_DIR}"
)
make_oakengine_gtest(oakengine_keyframe_test)
target_compile_definitions(oakengine_keyframe_test PRIVATE
OAK_TEST_SOURCE_DIR="${CMAKE_SOURCE_DIR}"
)
make_oakengine_gtest(oakengine_viewer_test)
target_compile_definitions(oakengine_viewer_test PRIVATE
OAK_TEST_SOURCE_DIR="${CMAKE_SOURCE_DIR}"
)
make_oakengine_gtest(oakengine_traverse_test)
target_compile_definitions(oakengine_traverse_test PRIVATE
OAK_TEST_SOURCE_DIR="${CMAKE_SOURCE_DIR}"
)
make_oakengine_gtest(oakengine_preview_test)
# The preview test needs audio rendering (RenderManager + workers).
target_include_directories(oakengine_preview_test PRIVATE
${CMAKE_SOURCE_DIR}/third_party/openfx/include
${CMAKE_SOURCE_DIR}/third_party/openfx/HostSupport/include
${OLIVE_INCLUDE_DIRS}
)
target_compile_definitions(oakengine_preview_test PRIVATE
${OLIVE_DEFINITIONS}
OAK_TEST_SOURCE_DIR="${CMAKE_SOURCE_DIR}"
)
target_compile_options(oakengine_preview_test PRIVATE
${OLIVE_COMPILE_OPTIONS}
)
if (OAK_ENABLE_DYNAMIC_RENDER_BACKEND)
target_compile_definitions(oakengine_preview_test PRIVATE
OAK_ENABLE_DYNAMIC_RENDER_BACKEND)
add_dependencies(oakengine_preview_test oakgl)
endif ()
if (TARGET olive-render-worker)
add_dependencies(oakengine_preview_test olive-render-worker)
endif ()
make_oakengine_gtest(oakengine_playback_test)
# The playback test builds sequence content through the engine C++ API
# and pulls frames through the render worker pool (same needs as
# oakengine_renderer_test).
target_include_directories(oakengine_playback_test PRIVATE
${CMAKE_SOURCE_DIR}/third_party/openfx/include
${CMAKE_SOURCE_DIR}/third_party/openfx/HostSupport/include
${OLIVE_INCLUDE_DIRS}
)
target_compile_definitions(oakengine_playback_test PRIVATE
${OLIVE_DEFINITIONS}
OAK_TEST_SOURCE_DIR="${CMAKE_SOURCE_DIR}"
)
target_compile_options(oakengine_playback_test PRIVATE
${OLIVE_COMPILE_OPTIONS}
)
if (OAK_ENABLE_DYNAMIC_RENDER_BACKEND)
target_compile_definitions(oakengine_playback_test PRIVATE
OAK_ENABLE_DYNAMIC_RENDER_BACKEND)
add_dependencies(oakengine_playback_test oakgl)
if (TARGET oakvulkan)
add_dependencies(oakengine_playback_test oakvulkan)
endif ()
endif ()
if (TARGET olive-render-worker)
add_dependencies(oakengine_playback_test olive-render-worker)
endif ()
make_oakengine_gtest(oakengine_sync_test)
# The sync test renders the clips' audio through the worker pool (same
# needs as oakengine_playback_test).
target_include_directories(oakengine_sync_test PRIVATE
${CMAKE_SOURCE_DIR}/third_party/openfx/include
${CMAKE_SOURCE_DIR}/third_party/openfx/HostSupport/include
${OLIVE_INCLUDE_DIRS}
)
target_compile_definitions(oakengine_sync_test PRIVATE
${OLIVE_DEFINITIONS}
OAK_TEST_SOURCE_DIR="${CMAKE_SOURCE_DIR}"
)
target_compile_options(oakengine_sync_test PRIVATE
${OLIVE_COMPILE_OPTIONS}
)
if (OAK_ENABLE_DYNAMIC_RENDER_BACKEND)
target_compile_definitions(oakengine_sync_test PRIVATE
OAK_ENABLE_DYNAMIC_RENDER_BACKEND)
add_dependencies(oakengine_sync_test oakgl)
if (TARGET oakvulkan)
add_dependencies(oakengine_sync_test oakvulkan)
endif ()
endif ()
if (TARGET olive-render-worker)
add_dependencies(oakengine_sync_test olive-render-worker)
endif ()
endif ()
Reference in New Issue View Git Blame Copy Permalink