More simplification

Author: MichealReed

CMakeLists.txt

@@ -1,3 +1,5 @@
+# This only builds a shared lib, see cmake/example.cmake
+# and cmake/gpu.cmake for more details
 cmake_minimum_required(VERSION 3.28)
 project(gpu)
 

cmake/example.cmake

@@ -1,67 +1,45 @@
-set(CMAKE_EXPORT_COMPILE_COMMANDS ON) # export compile_commands.json to use with
-                                      # LSP
-set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
+# Getting Started with CMAKE
+# Each example includes this and sets PROJECT_NAME
+# cd examples/hello_world
+# cmake -S . build/ -DCMAKE_BUILD_TYPE=Release
+# cmake --build build/ --config Release
+# ./build/hello_world
+
+if(NOT MSVC)
+    set(CMAKE_CXX_STANDARD 17)
+else()
+    set(CMAKE_CXX_STANDARD 20)
+endif()
 
+# Path finding logic to find our root recipes from nested folders
 get_filename_component(PROJECT_ROOT ${CMAKE_CURRENT_SOURCE_DIR} DIRECTORY)
 get_filename_component(PROJECT_ROOT ${PROJECT_ROOT} DIRECTORY)
 
-# Construct potential paths
-set(FILEPATH_CURRENT_DIR "${DIRECTORY}/")
-set(FILEPATH_PROJECT_ROOT "${PROJECT_ROOT}/")
-
-# Include file finding utility script
-include("${FILEPATH_PROJECT_ROOT}/cmake/find_gpu.cmake")
-
-# Check if the file exists in the current directory
-find_project_root(${CMAKE_CURRENT_SOURCE_DIR} ${FILENAME}
-                  TARGET_FILE_PATH)
-if("${TARGET_FILE_PATH}" STREQUAL "")
-    find_project_root(${FILEPATH_CURRENT_DIR} ${FILENAME}
-                      TARGET_FILE_PATH)
-    if("${TARGET_FILE_PATH}" STREQUAL "")
-        message(
-            FATAL_ERROR
-                "File ${FILENAME} not found in either ${CMAKE_CURRENT_SOURCE_DIR} or ${CMAKE_CURRENT_SOURCE_DIR}/../../"
-        )
-    endif()
-endif()
-
 # Ensure the build type is set
 if(NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE
         Release
         CACHE STRING "Choose the type of build: Debug or Release" FORCE)
 endif()
 
-# Define architecture and build type directories or file names
-if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-    set(ARCH "x64")
-else()
-    set(ARCH "x86")
-endif()
-
-if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-    set(BUILD_TYPE "Debug")
-else()
-    set(BUILD_TYPE "Release")
-endif()
+# Include the gpu.cpp + Dawn library
+include("${PROJECT_ROOT}/cmake/gpu.cmake")
 
-if(NOT TARGET gpu)
-    message(STATUS "GPU_LIB not found")
-    include("${TARGET_FILE_PATH}/cmake/gpu.cmake")
-endif()
+# Create the executable
 add_executable(${PROJECT_NAME} run.cpp)
+
+# Link gpu + dawn library
 target_link_libraries(${PROJECT_NAME} PRIVATE gpu)
-target_link_libraries(${PROJECT_NAME} PRIVATE ${WEBGPU_DAWN})
 
+# Certain platforms need to copy the library files to the build directory
 if(MSVC)
-# Copy webgpu_dawn.dll to the build directory
+    # Copy webgpu_dawn.dll to the build directory
+    # CMake multigenerators like MSVC need --config Release on
+    # the cmake --build command or they will output to /Debug
     add_custom_command(
         TARGET ${PROJECT_NAME} POST_BUILD
         COMMAND ${CMAKE_COMMAND} -E copy
                 ${DAWN_INSTALL_PREFIX}/${CMAKE_BUILD_TYPE}/webgpu_dawn.dll
-                $<TARGET_FILE_DIR:${PROJECT_NAME}>
-    )
+                $<TARGET_FILE_DIR:${PROJECT_NAME}>)
 endif()
 

cmake/find_gpu.cmake

@@ -1,44 +1,46 @@
 set(FILENAME "gpu.hpp")
 
+# Setup project root here.
 if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${FILENAME}")
-    set(FILEPATH_PROJECT_ROOT "${CMAKE_CURRENT_SOURCE_DIR}")
+    set(PROJECT_ROOT "${CMAKE_CURRENT_SOURCE_DIR}")
 else()
     get_filename_component(PROJECT_ROOT ${CMAKE_CURRENT_SOURCE_DIR} DIRECTORY)
     get_filename_component(PROJECT_ROOT ${PROJECT_ROOT} DIRECTORY)
-    
-    set(FILEPATH_PROJECT_ROOT "${PROJECT_ROOT}/")
+
+    set(PROJECT_ROOT "${PROJECT_ROOT}/")
 endif()
 
+message(STATUS "PROJECT_ROOT: ${PROJECT_ROOT}")
+
 
 include(FetchContent)
 
-set(FETCHCONTENT_BASE_DIR "${FILEPATH_PROJECT_ROOT}/third_party/fetchcontent/_deps")
+set(FETCHCONTENT_BASE_DIR "${PROJECT_ROOT}/third_party/fetchcontent/_deps")
 set(DAWN_INSTALL_PREFIX "${FETCHCONTENT_BASE_DIR}/dawn-build/out/${CMAKE_BUILD_TYPE}" CACHE INTERNAL "Dawn install location" FORCE)
 
 
 # Before fetching, set configuration options for Dawn.
-# These CMake variables are “global” (cached INTERNAL) so that Dawn’s own CMakeLists.txt
-# will pick them up. Adjust them as needed.
-set(DAWN_BUILD_TYPE          ${CMAKE_BUILD_TYPE} CACHE INTERNAL "Dawn build type" FORCE)
 set(DCMAKE_INSTALL_PREFIX   ${DAWN_INSTALL_PREFIX} CACHE INTERNAL "Dawn install location" FORCE)
+set(CMAKE_CONFIGURATION_TYPES ${CMAKE_BUILD_TYPE} CACHE INTERNAL "Dawn configuration types" FORCE)
 
-# Dawn options
-set(DAWN_FETCH_DEPENDENCIES ON  CACHE INTERNAL "Fetch Dawn dependencies" FORCE)
-set(DAWN_ENABLE_INSTALL      ON  CACHE INTERNAL "Enable Dawn installation" FORCE)
-set(DAWN_BUILD_MONOLITHIC_LIBRARY OFF CACHE INTERNAL "Build Dawn monolithically" FORCE)
+# Dawn options for more,
+# see https://dawn.googlesource.com/dawn/+/refs/heads/main/CMakeLists.txt
+set(DAWN_ALWAYS_ASSERT     OFF CACHE INTERNAL "Always assert in Dawn" FORCE)
+set(DAWN_BUILD_MONOLITHIC_LIBRARY ON CACHE INTERNAL "Build Dawn monolithically" FORCE)
 set(DAWN_BUILD_EXAMPLES      OFF CACHE INTERNAL "Build Dawn examples" FORCE)
 set(DAWN_BUILD_SAMPLES      OFF CACHE INTERNAL "Build Dawn samples" FORCE)
 set(DAWN_BUILD_TESTS         OFF CACHE INTERNAL "Build Dawn tests" FORCE)
-set(DAWN_BUILD_UTILS         OFF CACHE INTERNAL "Build Dawn utilities" FORCE)
+set(DAWN_ENABLE_INSTALL      ON  CACHE INTERNAL "Enable Dawn installation" FORCE)
+set(DAWN_FETCH_DEPENDENCIES ON  CACHE INTERNAL "Fetch Dawn dependencies" FORCE)
+
 set(TINT_BUILD_TESTS        OFF CACHE INTERNAL "Build Tint Tests" FORCE)
 set(TINT_BUILD_IR_BINARY    OFF CACHE INTERNAL "Build Tint IR binary" FORCE)
 set(TINT_BUILD_CMD_TOOLS   OFF CACHE INTERNAL "Build Tint command line tools" FORCE)
-set(BUILD_SHARED_LIBS       OFF CACHE INTERNAL "Build shared libraries" FORCE)
-
 
-# Set up an install location for Dawn – you can change this to a specific location.
+set(BUILD_SHARED_LIBS       OFF CACHE INTERNAL "Build shared libraries" FORCE)
 
 
+# Fetch Setup
 FetchContent_Declare(
     dawn
     DOWNLOAD_COMMAND
@@ -49,67 +51,56 @@ FetchContent_Declare(
 )
 
 
-# This call will download the repository and add it as a subdirectory.
+# Download the repository and add it as a subdirectory.
 FetchContent_MakeAvailable(dawn)
 
 
-# At this point, assuming Dawn’s CMakeLists.txt is written so that an install step is available,
-# we trigger a build of its install target. This custom target will build (and install) Dawn
-# into ${DAWN_INSTALL_PREFIX}. (If Dawn already adds an install target, you may simply depend on it.)
-add_custom_target(build_dawn_config ALL
+# Since we require Dawn to be built before linking against it, we need to configure it now.
+execute_process(
     COMMAND ${CMAKE_COMMAND} ${FETCHCONTENT_BASE_DIR}/dawn-src 
         -B ${DAWN_INSTALL_PREFIX}
         -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
-        -DDAWN_FETCH_DEPENDENCIES=ON
-        -DDAWN_ENABLE_INSTALL=ON
-        -DDAWN_BUILD_MONOLITHIC_LIBRARY=OFF
-        -DDAWN_BUILD_EXAMPLES=OFF
-        -DDAWN_BUILD_SAMPLES=OFF
-        -DDAWN_BUILD_TESTS=OFF
-        -DDAWN_BUILD_UTILS=OFF
-        -DTINT_BUILD_TESTS=OFF
-        -DTINT_BUILD_IR_BINARY=OFF
-        -DTINT_BUILD_CMD_TOOLS=OFF
-        -DBUILD_SHARED_LIBS=OFF
         -G "${CMAKE_GENERATOR}"
-    COMMENT "Configuring Dawn build with custom options in ${DAWN_INSTALL_PREFIX}"
 )
 
-add_custom_target(build_dawn_install ALL
-    COMMAND ${CMAKE_COMMAND} --build ${DAWN_INSTALL_PREFIX} --target install
-    COMMENT "Installing Dawn into ${DAWN_INSTALL_PREFIX}"
+# Build Dawn
+execute_process(
+    WORKING_DIRECTORY ${FETCHCONTENT_BASE_DIR}/dawn-src
+    COMMAND ${CMAKE_COMMAND} --build ${DAWN_INSTALL_PREFIX} --config ${CMAKE_BUILD_TYPE}
 )
 
-include(${FETCHCONTENT_BASE_DIR}/dawn-build/cmake/DawnTargets.cmake)
-
+# Add sources
 set(GPU_SOURCES
-    "${FILEPATH_PROJECT_ROOT}/gpu.cpp"
-    "${FILEPATH_PROJECT_ROOT}/numeric_types/half.cpp"
+    "${PROJECT_ROOT}/gpu.cpp"
+    "${PROJECT_ROOT}/numeric_types/half.cpp"
 )
 
+# Add headers
 set(GPU_HEADERS
-    "${FILEPATH_PROJECT_ROOT}/gpu.hpp"
-    "${FILEPATH_PROJECT_ROOT}/utils/logging.hpp"
-    "${FILEPATH_PROJECT_ROOT}/utils/array_utils.hpp"
-    "${FILEPATH_PROJECT_ROOT}/numeric_types/half.hpp"
+    "${PROJECT_ROOT}/gpu.hpp"
+    "${PROJECT_ROOT}/utils/logging.hpp"
+    "${PROJECT_ROOT}/utils/array_utils.hpp"
+    "${PROJECT_ROOT}/numeric_types/half.hpp"
 )
 
+# Emscripten includes a header automatically
 if(EMSCRIPTEN)
-    file(REMOVE "${FILEPATH_PROJECT_ROOT}/webgpu/webgpu.h")
+    file(REMOVE "${PROJECT_ROOT}/webgpu/webgpu.h")
 else()
-    list(APPEND GPU_HEADERS "${DAWN_INSTALL_PREFIX}/gen/webgpu-headers/webgpu.h")
+    list(APPEND GPU_HEADERS "${PROJECT_ROOT}/third_party/headers/webgpu/webgpu.h")
 endif()
 
 
-# Create the INTERFACE library ‘gpu’
+# Create the STATIC library for gpu
 add_library(gpu STATIC ${GPU_SOURCES} ${GPU_HEADERS})
-target_include_directories(gpu PUBLIC "${FILEPATH_PROJECT_ROOT}")
-target_include_directories(gpu PUBLIC "${FILEPATH_PROJECT_ROOT}/third_party/headers")
+target_include_directories(gpu PUBLIC "${PROJECT_ROOT}")
+target_include_directories(gpu PUBLIC "${PROJECT_ROOT}/third_party/headers")
 
-# Ensure that the gpu target is built only after Dawn has been installed.
-add_dependencies(gpu build_dawn_install)
-
-find_library(WEBGPU_DAWN
+# Find the monolithic library for Dawn
+find_library(WEBGPU_DAWN_MONOLITHIC
     NAMES webgpu_dawn
-    HINTS "${DAWN_INSTALL_PREFIX}/src/dawn/native/Debug/"
-)
+    HINTS "${DAWN_INSTALL_PREFIX}/src/dawn/native/${CMAKE_BUILD_TYPE}"
+)
+
+# Link the monolithic library
+target_link_libraries(gpu PRIVATE ${WEBGPU_DAWN_MONOLITHIC})