Embed Vulkan SPIR-V into headers

Add build support to embed Vulkan SPIR-V into generated C++ headers and use them at runtime. Introduces src/imiv/embed_spirv_header.cmake and CMake changes to generate header wrappers, a custom imiv_shaders target, and a compile-time IMIV_HAS_EMBEDDED_VULKAN_SHADERS define. Update Vulkan backend sources to prefer embedded shader word arrays (with fallbacks to .spv files) and add helper helpers for creating shader modules/pipelines from embedded data or files. Update docs to mention embedded SPIR-V and adjust source grouping; also include .clang-format tweaks and add a Windows oiio_exe.aps resource file.

Signed-off-by: Vlad (Kuzmin) Erium <libalias@gmail.com>
Signed-off-by: Vlad <shaamaan@gmail.com>

Author: ssh4net

.clang-format

@@ -1,4 +1,4 @@
-Language:        Cpp
+---
 BasedOnStyle:  WebKit
 
 AccessModifierOffset: -4
@@ -121,11 +121,17 @@ SpacesInContainerLiterals: true
 SpacesInCStyleCastParentheses: false
 SpacesInParentheses: false
 SpacesInSquareBrackets: false
-Standard:        c++17
 StatementMacros: 
   - Q_UNUSED
   - QT_REQUIRE_VERSION
 TabWidth:        8
 UseTab:          Never
 #...
 
+---
+Language:        Cpp
+Standard:        c++17
+
+---
+Language:        ObjC
+Standard:        c++17

src/doc/imiv_dev.rst

@@ -811,8 +811,10 @@ Backend-specific shader paths
 
 Vulkan
     uses build-time SPIR-V for the static upload and preview shaders from
-    `src/imiv/shaders/`, with optional runtime shader compilation support for
-    generated OCIO shaders.
+    `src/imiv/shaders/`, embedded into generated headers at build time so the
+    final binary does not depend on external ``.spv`` files at runtime. OCIO
+    preview still uses optional runtime shader compilation support for the
+    generated OCIO fragment shader.
 
 OpenGL
     stays on native GLSL. It uploads supported source formats directly as GL

src/imiv/CMakeLists.txt

@@ -218,7 +218,28 @@ set (_imiv_shader_spv_16f_fp64 "${CMAKE_CURRENT_BINARY_DIR}/imiv_upload_to_rgba1
 set (_imiv_shader_spv_32f_fp64 "${CMAKE_CURRENT_BINARY_DIR}/imiv_upload_to_rgba32f_fp64.comp.spv")
 set (_imiv_preview_vert_spv "${CMAKE_CURRENT_BINARY_DIR}/imiv_preview.vert.spv")
 set (_imiv_preview_frag_spv "${CMAKE_CURRENT_BINARY_DIR}/imiv_preview.frag.spv")
+set (_imiv_shader_hdr_16f "${CMAKE_CURRENT_BINARY_DIR}/imiv_upload_to_rgba16f_spv.h")
+set (_imiv_shader_hdr_32f "${CMAKE_CURRENT_BINARY_DIR}/imiv_upload_to_rgba32f_spv.h")
+set (_imiv_shader_hdr_16f_fp64 "${CMAKE_CURRENT_BINARY_DIR}/imiv_upload_to_rgba16f_fp64_spv.h")
+set (_imiv_shader_hdr_32f_fp64 "${CMAKE_CURRENT_BINARY_DIR}/imiv_upload_to_rgba32f_fp64_spv.h")
+set (_imiv_preview_vert_hdr "${CMAKE_CURRENT_BINARY_DIR}/imiv_preview_vert_spv.h")
+set (_imiv_preview_frag_hdr "${CMAKE_CURRENT_BINARY_DIR}/imiv_preview_frag_spv.h")
 set (_imiv_shader_outputs)
+set (_imiv_embedded_shader_headers)
+
+function (_imiv_add_embedded_spirv_header input_spv output_hdr symbol_name)
+    add_custom_command (
+        OUTPUT "${output_hdr}"
+        COMMAND ${CMAKE_COMMAND}
+                -DINPUT="${input_spv}"
+                -DOUTPUT="${output_hdr}"
+                -DSYMBOL_NAME="${symbol_name}"
+                -P "${CMAKE_CURRENT_SOURCE_DIR}/embed_spirv_header.cmake"
+        DEPENDS
+            "${input_spv}"
+            "${CMAKE_CURRENT_SOURCE_DIR}/embed_spirv_header.cmake"
+        COMMENT "imiv: embedding Vulkan shader ${symbol_name}")
+endfunction ()
 
 if (_imiv_want_vulkan)
     find_program (OIIO_IMIV_GLSLC_EXECUTABLE
@@ -294,14 +315,47 @@ if (_imiv_want_vulkan)
                     -o "${_imiv_preview_frag_spv}"
             DEPENDS "${_imiv_preview_frag_src}"
             COMMENT "imiv: compiling Vulkan preview fragment shader")
+        _imiv_add_embedded_spirv_header (
+            "${_imiv_shader_spv_16f}"
+            "${_imiv_shader_hdr_16f}"
+            "g_imiv_upload_to_rgba16f_spv")
+        _imiv_add_embedded_spirv_header (
+            "${_imiv_shader_spv_32f}"
+            "${_imiv_shader_hdr_32f}"
+            "g_imiv_upload_to_rgba32f_spv")
+        _imiv_add_embedded_spirv_header (
+            "${_imiv_shader_spv_16f_fp64}"
+            "${_imiv_shader_hdr_16f_fp64}"
+            "g_imiv_upload_to_rgba16f_fp64_spv")
+        _imiv_add_embedded_spirv_header (
+            "${_imiv_shader_spv_32f_fp64}"
+            "${_imiv_shader_hdr_32f_fp64}"
+            "g_imiv_upload_to_rgba32f_fp64_spv")
+        _imiv_add_embedded_spirv_header (
+            "${_imiv_preview_vert_spv}"
+            "${_imiv_preview_vert_hdr}"
+            "g_imiv_preview_vert_spv")
+        _imiv_add_embedded_spirv_header (
+            "${_imiv_preview_frag_spv}"
+            "${_imiv_preview_frag_hdr}"
+            "g_imiv_preview_frag_spv")
         set (_imiv_shader_outputs
              "${_imiv_shader_spv_16f}"
              "${_imiv_shader_spv_32f}"
              "${_imiv_shader_spv_16f_fp64}"
              "${_imiv_shader_spv_32f_fp64}"
              "${_imiv_preview_vert_spv}"
              "${_imiv_preview_frag_spv}")
-        add_custom_target (imiv_shaders DEPENDS ${_imiv_shader_outputs})
+        set (_imiv_embedded_shader_headers
+             "${_imiv_shader_hdr_16f}"
+             "${_imiv_shader_hdr_32f}"
+             "${_imiv_shader_hdr_16f_fp64}"
+             "${_imiv_shader_hdr_32f_fp64}"
+             "${_imiv_preview_vert_hdr}"
+             "${_imiv_preview_frag_hdr}")
+        add_custom_target (imiv_shaders DEPENDS
+                           ${_imiv_shader_outputs}
+                           ${_imiv_embedded_shader_headers})
     else ()
         message (STATUS
                  "imiv: glslc not found; Vulkan compute upload shader generation disabled")
@@ -857,14 +911,14 @@ source_group ("imgui_te" FILES
               ${_imiv_test_engine_sources}
               ${_imiv_test_engine_integration_sources}
               "${CMAKE_CURRENT_SOURCE_DIR}/imiv_test_engine.h")
-source_group ("imiv\\shared" FILES ${_imiv_shared_sources})
-source_group ("imiv\\platform\\glfw" FILES ${_imiv_platform_glfw_sources})
-source_group ("imiv\\renderer\\vulkan" FILES ${_imiv_renderer_vulkan_sources})
+source_group ("Source Files" FILES ${_imiv_shared_sources})
+source_group ("Source Files\\platform\\glfw" FILES ${_imiv_platform_glfw_sources})
+source_group ("Source Files\\renderer\\vulkan" FILES ${_imiv_renderer_vulkan_sources})
 if (_imiv_renderer_metal_sources)
-    source_group ("imiv\\renderer\\metal" FILES ${_imiv_renderer_metal_sources})
+    source_group ("Source Files\\renderer\\metal" FILES ${_imiv_renderer_metal_sources})
 endif ()
 if (_imiv_renderer_opengl_sources)
-    source_group ("imiv\\renderer\\opengl" FILES ${_imiv_renderer_opengl_sources})
+    source_group ("Source Files\\renderer\\opengl" FILES ${_imiv_renderer_opengl_sources})
 endif ()
 
 if (TARGET imiv)
@@ -876,6 +930,11 @@ if (TARGET imiv)
     else ()
         target_compile_definitions (imiv PRIVATE IMIV_HAS_COMPUTE_UPLOAD_SHADERS=0)
     endif ()
+    if (_imiv_embedded_shader_headers)
+        target_compile_definitions (imiv PRIVATE IMIV_HAS_EMBEDDED_VULKAN_SHADERS=1)
+    else ()
+        target_compile_definitions (imiv PRIVATE IMIV_HAS_EMBEDDED_VULKAN_SHADERS=0)
+    endif ()
     if (_imiv_renderer_is_vulkan)
         target_compile_definitions (imiv PRIVATE IMIV_BACKEND_VULKAN_GLFW=1
                                                   $<$<CONFIG:Debug>:IMIV_VULKAN_VALIDATION=1>)

src/imiv/embed_spirv_header.cmake

@@ -0,0 +1,60 @@
+if (NOT DEFINED INPUT OR NOT DEFINED OUTPUT OR NOT DEFINED SYMBOL_NAME)
+    message (FATAL_ERROR
+             "embed_spirv_header.cmake requires INPUT, OUTPUT, and SYMBOL_NAME")
+endif ()
+
+get_filename_component (_embed_output_dir "${OUTPUT}" DIRECTORY)
+file (MAKE_DIRECTORY "${_embed_output_dir}")
+file (READ "${INPUT}" _embed_hex HEX)
+string (LENGTH "${_embed_hex}" _embed_hex_length)
+if (_embed_hex_length EQUAL 0)
+    message (FATAL_ERROR "SPIR-V input '${INPUT}' is empty")
+endif ()
+
+math (EXPR _embed_remainder "${_embed_hex_length} % 8")
+if (NOT _embed_remainder EQUAL 0)
+    message (FATAL_ERROR
+             "SPIR-V input '${INPUT}' has invalid size ${_embed_hex_length}")
+endif ()
+
+math (EXPR _embed_word_count "${_embed_hex_length} / 8")
+math (EXPR _embed_last_index "${_embed_word_count} - 1")
+
+file (WRITE "${OUTPUT}" "// Generated by embed_spirv_header.cmake. Do not edit.\n")
+file (APPEND "${OUTPUT}" "#pragma once\n\n")
+file (APPEND "${OUTPUT}" "#include <cstddef>\n")
+file (APPEND "${OUTPUT}" "#include <cstdint>\n\n")
+file (APPEND "${OUTPUT}" "namespace Imiv {\n\n")
+file (APPEND "${OUTPUT}" "static const uint32_t ${SYMBOL_NAME}[] = {\n")
+
+set (_embed_line "    ")
+set (_embed_items_on_line 0)
+foreach (_embed_word_index RANGE 0 ${_embed_last_index})
+    math (EXPR _embed_offset "${_embed_word_index} * 8")
+    math (EXPR _embed_offset_1 "${_embed_offset} + 2")
+    math (EXPR _embed_offset_2 "${_embed_offset} + 4")
+    math (EXPR _embed_offset_3 "${_embed_offset} + 6")
+    string (SUBSTRING "${_embed_hex}" ${_embed_offset} 2 _embed_b0)
+    string (SUBSTRING "${_embed_hex}" ${_embed_offset_1} 2 _embed_b1)
+    string (SUBSTRING "${_embed_hex}" ${_embed_offset_2} 2 _embed_b2)
+    string (SUBSTRING "${_embed_hex}" ${_embed_offset_3} 2 _embed_b3)
+
+    string (APPEND _embed_line
+            "0x${_embed_b3}${_embed_b2}${_embed_b1}${_embed_b0}u")
+    if (NOT _embed_word_index EQUAL _embed_last_index)
+        string (APPEND _embed_line ", ")
+    endif ()
+
+    math (EXPR _embed_items_on_line "${_embed_items_on_line} + 1")
+    if (_embed_items_on_line EQUAL 4 OR _embed_word_index EQUAL _embed_last_index)
+        string (APPEND _embed_line "\n")
+        file (APPEND "${OUTPUT}" "${_embed_line}")
+        set (_embed_line "    ")
+        set (_embed_items_on_line 0)
+    endif ()
+endforeach ()
+
+file (APPEND "${OUTPUT}" "};\n")
+file (APPEND "${OUTPUT}"
+      "static constexpr std::size_t ${SYMBOL_NAME}_word_count = sizeof(${SYMBOL_NAME}) / sizeof(${SYMBOL_NAME}[0]);\n\n")
+file (APPEND "${OUTPUT}" "}  // namespace Imiv\n")

src/imiv/imiv_backends.md

@@ -109,7 +109,8 @@ Implementation:
 Constraints:
 
 - uses runtime shader compilation for OCIO
-- uses Vulkan SPIR-V pipelines
+- uses Vulkan SPIR-V pipelines embedded into the binary at build time for the
+  static upload/preview stages
 - remains the canonical backend for feature parity and regressions
 
 Notes:

src/imiv/imiv_vulkan_ocio.cpp

@@ -15,6 +15,12 @@
 #include <string>
 #include <vector>
 
+#if defined(IMIV_WITH_VULKAN) \
+    && defined(IMIV_HAS_EMBEDDED_VULKAN_SHADERS) \
+    && IMIV_HAS_EMBEDDED_VULKAN_SHADERS
+#    include "imiv_preview_vert_spv.h"
+#endif
+
 namespace Imiv {
 
 #if defined(IMIV_WITH_VULKAN)
@@ -98,6 +104,21 @@ namespace {
                                                error_message, path.c_str());
     }
 
+    bool create_shader_module_from_embedded_or_file(
+        VkDevice device, VkAllocationCallbacks* allocator,
+        const uint32_t* words, size_t word_count, const std::string& path,
+        const char* debug_name, VkShaderModule& shader_module,
+        std::string& error_message)
+    {
+        if (words != nullptr && word_count != 0) {
+            return create_shader_module_from_words(
+                device, allocator, words, word_count, shader_module,
+                error_message, debug_name);
+        }
+        return create_shader_module_from_file(device, allocator, path,
+                                              shader_module, error_message);
+    }
+
     void destroy_ocio_texture(VulkanState& vk_state, OcioVulkanTexture& texture)
     {
         if (texture.sampler != VK_NULL_HANDLE) {
@@ -626,9 +647,19 @@ namespace {
 
         const std::string shader_vert = std::string(IMIV_SHADER_DIR)
                                         + "/imiv_preview.vert.spv";
-        if (!create_shader_module_from_file(vk_state.device, vk_state.allocator,
-                                            shader_vert, vert_module,
-                                            error_message)) {
+#    if defined(IMIV_HAS_EMBEDDED_VULKAN_SHADERS) \
+        && IMIV_HAS_EMBEDDED_VULKAN_SHADERS
+        const uint32_t* shader_vert_words = g_imiv_preview_vert_spv;
+        const size_t shader_vert_word_count
+            = g_imiv_preview_vert_spv_word_count;
+#    else
+        const uint32_t* shader_vert_words = nullptr;
+        const size_t shader_vert_word_count = 0;
+#    endif
+        if (!create_shader_module_from_embedded_or_file(
+                vk_state.device, vk_state.allocator, shader_vert_words,
+                shader_vert_word_count, shader_vert, "imiv.preview.vert",
+                vert_module, error_message)) {
             return false;
         }
         if (!create_shader_module_from_words(