Flatten main CMakeLists

Author: Coldwings

CMake/build-from-src.cmake

@@ -313,8 +313,8 @@ function(build_from_src dep)
                 COMMAND ${CMAKE_COMMAND} -E copy <SOURCE_DIR>/ikcp.h ${BINARY_DIR}/include/
         )
         ExternalProject_Get_Property(kcp SOURCE_DIR)
-        set(kcp_SOURCE_DIR ${SOURCE_DIR} PARENT_SCOPE)
-        set(kcp_static ${BINARY_DIR}/lib/libikcp.a PARENT_SCOPE)
+        set(KCP_INCLUDE_DIRS ${SOURCE_DIR} PARENT_SCOPE)
+        set(KCP_LIBRARIES ${BINARY_DIR}/lib/libikcp.a PARENT_SCOPE)
 
     endif ()
 

CMake/photon-deps.cmake

@@ -0,0 +1,40 @@
+## Central registry that exposes each resolved dependency as an internal target
+## Photon::<name>, so include dirs / definitions / link libraries propagate
+## through the target graph instead of loose <DEP>_INCLUDE_DIRS / <DEP>_LIBRARIES
+## variables.
+##
+## Both dependency acquisition paths -- find_package (the Find<pkg>.cmake modules)
+## and build_from_src (ExternalProject) -- publish the same conventional
+## variables. The top-level dependency loop feeds those into photon_declare_dep(),
+## so a dependency looks identical to consumers regardless of where it came from.
+##
+## Note: targets carry compile usage requirements (include dirs, definitions) plus
+## the dependency's link libraries. Photon's own libraries still assemble their
+## final link line manually (whole-archive re-export cannot be expressed with
+## targets under CMake 3.14), so the link libraries recorded here are informative
+## for consumers rather than the source Photon itself links from.
+include_guard(GLOBAL)
+
+# photon_declare_dep(<name> [INCLUDES <dir>...] [LIBRARIES <lib>...] [DEFINITIONS <def>...])
+#
+#   Creates the INTERFACE library _photon_dep_<name> holding the usage
+#   requirements and exposes it as the alias Photon::<name>. All keyword groups
+#   are optional; empty groups are ignored, so it is safe to call with whatever
+#   the acquisition path happened to publish.
+function(photon_declare_dep name)
+    cmake_parse_arguments(_dep "" "" "INCLUDES;LIBRARIES;DEFINITIONS" ${ARGN})
+    set(_tgt _photon_dep_${name})
+    if (NOT TARGET ${_tgt})
+        add_library(${_tgt} INTERFACE)
+        add_library(Photon::${name} ALIAS ${_tgt})
+    endif ()
+    if (_dep_INCLUDES)
+        target_include_directories(${_tgt} INTERFACE ${_dep_INCLUDES})
+    endif ()
+    if (_dep_LIBRARIES)
+        target_link_libraries(${_tgt} INTERFACE ${_dep_LIBRARIES})
+    endif ()
+    if (_dep_DEFINITIONS)
+        target_compile_definitions(${_tgt} INTERFACE ${_dep_DEFINITIONS})
+    endif ()
+endfunction()

CMake/photon-helpers.cmake

@@ -0,0 +1,72 @@
+# Declarative helpers that replace the repetitive option / source-URL / feature
+# / dependency if-chains in the top-level CMakeLists.txt with one readable line
+# each. Behavior is intentionally identical to the hand-written blocks they
+# supersede; they only remove boilerplate.
+
+# A user-facing cache knob, declared with one uniform form instead of mixing
+# option() (booleans) with set(... CACHE STRING) (string values).
+#   photon_option(<name> BOOL|STRING <default> <help>)
+# option(X "help" OFF) is exactly set(X OFF CACHE BOOL "help"), so BOOL knobs
+# behave identically to the option() they replace.
+macro(photon_option name type default help)
+    set(${name} ${default} CACHE ${type} "${help}")
+endmacro ()
+
+# A build-from-source download location, collapsing the repetitive
+# set(PHOTON_..._SOURCE "url" CACHE STRING "") table into one line each.
+# <key> carries the suffix (SOURCE or GIT) so the resulting cache variable name
+# (PHOTON_<key>) matches the existing convention.
+macro(photon_source key url)
+    set(PHOTON_${key} "${url}" CACHE STRING "")
+endmacro ()
+
+# Append <name> to the `dependencies` list. Any trailing arguments form a
+# condition evaluated by if(); with no condition the dependency is
+# unconditional. Keeps each dependency on a single declarative line with its
+# enabling condition inline, in place of a long if() / list(APPEND) chain.
+macro(photon_dependency name)
+    if (${ARGC} GREATER 1)
+        if (${ARGN})
+            list(APPEND dependencies ${name})
+        endif ()
+    else ()
+        list(APPEND dependencies ${name})
+    endif ()
+endmacro ()
+
+# target_compile_definitions(photon_features INTERFACE <defs>), guarded by a
+# condition:
+#   photon_feature(IF <cond...> DEFS <defs...>)
+# <cond...> is any expression if() accepts; the definitions are added only when
+# it holds. Mirrors the per-feature if() blocks with one line each.
+function(photon_feature)
+    cmake_parse_arguments(_pf "" "" "IF;DEFS" ${ARGN})
+    if (${_pf_IF})
+        target_compile_definitions(photon_features INTERFACE ${_pf_DEFS})
+    endif ()
+endfunction ()
+
+# list(APPEND <list> <items...>), guarded by a condition:
+#   photon_append_if(<list> IF <cond...> ITEMS <items...>)
+# The items (possibly empty, e.g. an unset *_LIBRARIES) are appended only when
+# <cond...> holds. Replaces the if() / list(APPEND) blocks that assemble the
+# link-time dependency lists while preserving their append order.
+function(photon_append_if listvar)
+    cmake_parse_arguments(_pa "" "" "IF;ITEMS" ${ARGN})
+    if (${_pa_IF})
+        list(APPEND ${listvar} ${_pa_ITEMS})
+        set(${listvar} "${${listvar}}" PARENT_SCOPE)
+    endif ()
+endfunction ()
+
+# list(REMOVE_ITEM <list> <items...>), guarded by a condition -- the opt-out
+# counterpart of photon_append_if:
+#   photon_remove_if(<list> IF <cond...> ITEMS <items...>)
+# Used where a file is globbed in by default and dropped when a feature is off.
+function(photon_remove_if listvar)
+    cmake_parse_arguments(_pr "" "" "IF;ITEMS" ${ARGN})
+    if (${_pr_IF})
+        list(REMOVE_ITEM ${listvar} ${_pr_ITEMS})
+        set(${listvar} "${${listvar}}" PARENT_SCOPE)
+    endif ()
+endfunction ()