Add Chromium-only Blender WebEngine parity work

blender-5.2.0/intern/cycles/kernel/device/cuda/CMakeLists.txt

@@ -0,0 +1,235 @@
+# SPDX-FileCopyrightText: 2011-2026 Blender Foundation
+#
+# SPDX-License-Identifier: Apache-2.0
+
+set(INC
+  ../../..
+)
+
+set(INC_SYS
+
+)
+
+set(SRC_KERNEL_DEVICE_CUDA
+  kernel.cu
+)
+
+set(SRC_KERNEL_DEVICE_CUDA_HEADERS
+  compat.h
+  config.h
+  globals.h
+)
+
+set(LIB
+
+)
+
+function(cuda_get_version out_version)
+  execute_process(COMMAND ${CUDA_NVCC_EXECUTABLE} "--version" OUTPUT_VARIABLE NVCC_OUT)
+  string(REGEX REPLACE ".*release ([0-9]+)\\.([0-9]+).*" "\\1" CUDA_VERSION_MAJOR "${NVCC_OUT}")
+  string(REGEX REPLACE ".*release ([0-9]+)\\.([0-9]+).*" "\\2" CUDA_VERSION_MINOR "${NVCC_OUT}")
+  set(${out_version} "${CUDA_VERSION_MAJOR}${CUDA_VERSION_MINOR}" PARENT_SCOPE)
+endfunction()
+
+function(cuda_add_common_flags cuda_version arch in_flags out_flags)
+  set(flags ${in_flags})
+
+  if(CUDA_HOST_COMPILER)
+    set(flags ${flags} -ccbin="${CUDA_HOST_COMPILER}")
+  endif()
+
+  set(flags ${flags}
+    # Helps with compatibility when using recent clang host compiler.
+    "-std=c++17"
+    --use_fast_math
+    -Wno-deprecated-gpu-targets)
+
+  if(WITH_CYCLES_DEBUG)
+    set(flags ${flags}
+      -D WITH_CYCLES_DEBUG
+      --ptxas-options="-v")
+  endif()
+
+  if(WITH_NANOVDB)
+    set(flags ${flags} -D WITH_NANOVDB)
+  endif()
+
+  if("${cuda_version}" GREATER_EQUAL 123 AND "${arch}" STREQUAL "sm_120")
+    # Enable jump table generation for the SVM switch statement.
+    set(flags ${flags} --jump-table-density 80)
+  endif()
+
+  if(NOT WITH_CYCLES_CUDA_BUILD_SERIAL AND "${cuda_version}" GREATER_EQUAL 129)
+    # Only use split compile with few binaries, to avoid excessive memory usage.
+    # This is mainly helpful for quick local builds for one architecture.
+    list(LENGTH CYCLES_CUDA_BINARIES_ARCH _num_binaries)
+    if(_num_binaries LESS_EQUAL 2)
+      set(flags ${flags} --split-compile=0)
+    endif()
+  endif()
+
+  set(${out_flags} ${flags} PARENT_SCOPE)
+endfunction()
+
+if(WITH_CYCLES_CUDA_BINARIES)
+  # 64 bit only
+  set(CUDA_BITS 64)
+
+  # CUDA version
+  cuda_get_version(CUDA_VERSION)
+
+  # warn for other versions
+  if((CUDA_VERSION STREQUAL "101") OR
+     (CUDA_VERSION STREQUAL "102") OR
+     (CUDA_VERSION_MAJOR STREQUAL "11") OR
+     (CUDA_VERSION_MAJOR STREQUAL "12"))
+  else()
+    message(WARNING
+      "CUDA version ${CUDA_VERSION_MAJOR}.${CUDA_VERSION_MINOR} detected, "
+      "build may succeed but only CUDA 12, 11, 10.2 and 10.1 have been tested")
+  endif()
+
+  # build for each arch
+  set(cuda_sources kernel.cu
+    ${SRC_KERNEL_DEVICE_CUDA_HEADERS}
+    $<TARGET_PROPERTY:cycles_kernel,INTERFACE_SOURCES>
+  )
+  set(cuda_cubins "")
+
+  # Modifies in parent scope:
+  # - `cuda_cubins`: appended with compressed `cubin/ptx` output.
+  function(CYCLES_CUDA_KERNEL_ADD arch prev_arch name flags sources experimental)
+    if(${arch} MATCHES "compute_.*")
+      set(format "ptx")
+    else()
+      set(format "cubin")
+    endif()
+    set(cuda_file ${name}_${arch}.${format})
+    set(cuda_file_compressed ${cuda_file}.zst)
+
+    set(kernel_sources ${sources})
+    if(NOT ${prev_arch} STREQUAL "none")
+      if(${prev_arch} MATCHES "compute_.*")
+        set(kernel_sources ${kernel_sources} ${name}_${prev_arch}.ptx)
+      else()
+        set(kernel_sources ${kernel_sources} ${name}_${prev_arch}.cubin)
+      endif()
+    endif()
+
+    set(cuda_kernel_src "/${name}.cu")
+
+    set(cuda_flags ${flags}
+      -D CCL_NAMESPACE_BEGIN=
+      -D CCL_NAMESPACE_END=
+      -D NVCC
+      -D _ALLOW_COMPILER_AND_STL_VERSION_MISMATCH
+      -m ${CUDA_BITS}
+      -I ${CMAKE_CURRENT_SOURCE_DIR}/../../..
+      -o ${CMAKE_CURRENT_BINARY_DIR}/${cuda_file})
+
+    cuda_add_common_flags(${cuda_version} ${arch} "${cuda_flags}" cuda_flags)
+
+    set(_cuda_nvcc_args
+      -arch=${arch}
+      ${CUDA_NVCC_FLAGS}
+      --${format}
+      ${CMAKE_CURRENT_SOURCE_DIR}${cuda_kernel_src}
+      ${cuda_flags}
+    )
+
+    if(WITH_COMPILER_CCACHE AND CCACHE_PROGRAM)
+      add_custom_command(
+        OUTPUT ${cuda_file}
+        COMMAND ${CCACHE_PROGRAM} ${cuda_nvcc_executable} ${_cuda_nvcc_args}
+        DEPENDS ${kernel_sources})
+    else()
+      add_custom_command(
+        OUTPUT ${cuda_file}
+        COMMAND ${cuda_nvcc_executable} ${_cuda_nvcc_args}
+        DEPENDS ${kernel_sources})
+    endif()
+
+    add_custom_command(
+      OUTPUT ${cuda_file_compressed}
+      COMMAND "$<TARGET_FILE:zstd_compress>" ${cuda_file} ${cuda_file_compressed}
+      DEPENDS ${cuda_file})
+
+    unset(_cuda_nvcc_args)
+    delayed_install("${CMAKE_CURRENT_BINARY_DIR}" "${cuda_file_compressed}" ${CYCLES_INSTALL_PATH}/lib)
+    list(APPEND cuda_cubins ${cuda_file_compressed})
+    set(cuda_cubins "${cuda_cubins}" PARENT_SCOPE)
+  endfunction()
+
+  set(prev_arch "none")
+  foreach(arch ${CYCLES_CUDA_BINARIES_ARCH})
+    if(${arch} MATCHES ".*_3.")
+      message(STATUS "CUDA binaries for ${arch} are no longer supported, skipped.")
+    elseif(${arch} MATCHES "compute_7." AND DEFINED CUDA11_NVCC_EXECUTABLE)
+      # Use CUDA 11 if available for the default PTX kernel. This allows us to
+      # keep the driver requirements for user machines low.
+      set(cuda_nvcc_executable ${CUDA11_NVCC_EXECUTABLE})
+      set(cuda_toolkit_root_dir ${CUDA11_TOOLKIT_ROOT_DIR})
+      set(cuda_version 110)
+    elseif((${arch} MATCHES ".*_5." OR ${arch} MATCHES ".*_6." OR ${arch} MATCHES ".*_70") AND "${CUDA_VERSION}" GREATER_EQUAL 130)
+      # Support for Maxwell, Pascal and Volta was dropped in CUDA 13
+      if(DEFINED CUDA11_NVCC_EXECUTABLE)
+        set(cuda_nvcc_executable ${CUDA11_NVCC_EXECUTABLE})
+        set(cuda_toolkit_root_dir ${CUDA11_TOOLKIT_ROOT_DIR})
+        set(cuda_version 110)
+      else()
+        message(STATUS "CUDA binaries for ${arch} are no longer supported with CUDA 13.0+, skipped.")
+      endif()
+    elseif(${arch} MATCHES ".*_7." AND "${CUDA_VERSION}" LESS 100)
+      message(STATUS "CUDA binaries for ${arch} require CUDA 10.0+, skipped.")
+    elseif(${arch} MATCHES ".*_8.")
+      if("${CUDA_VERSION}" GREATER_EQUAL 111) # Support for sm_86 was introduced in CUDA 11
+        set(cuda_nvcc_executable ${CUDA_NVCC_EXECUTABLE})
+        set(cuda_toolkit_root_dir ${CUDA_TOOLKIT_ROOT_DIR})
+        set(cuda_version ${CUDA_VERSION})
+      elseif(DEFINED CUDA11_NVCC_EXECUTABLE)
+        set(cuda_nvcc_executable ${CUDA11_NVCC_EXECUTABLE})
+        set(cuda_toolkit_root_dir ${CUDA11_TOOLKIT_ROOT_DIR})
+        set(cuda_version 110)
+      else()
+        message(STATUS "CUDA binaries for ${arch} require CUDA 11.1+, skipped.")
+      endif()
+    elseif(${arch} MATCHES ".*_10." OR ${arch} MATCHES ".*_120")
+      if("${CUDA_VERSION}" GREATER_EQUAL 128) # Support for sm_100, sm_101, sm_120 was introduced in CUDA 12.8
+        set(cuda_nvcc_executable ${CUDA_NVCC_EXECUTABLE})
+        set(cuda_toolkit_root_dir ${CUDA_TOOLKIT_ROOT_DIR})
+        set(cuda_version ${CUDA_VERSION})
+      else()
+        message(STATUS "CUDA binaries for ${arch} require CUDA 12.8+, skipped.")
+      endif()
+    else()
+      set(cuda_nvcc_executable ${CUDA_NVCC_EXECUTABLE})
+      set(cuda_toolkit_root_dir ${CUDA_TOOLKIT_ROOT_DIR})
+      set(cuda_version ${CUDA_VERSION})
+    endif()
+    if(DEFINED cuda_nvcc_executable AND DEFINED cuda_toolkit_root_dir)
+      # Compile regular kernel
+      cycles_cuda_kernel_add(${arch} ${prev_arch} kernel "" "${cuda_sources}" FALSE)
+
+      if(WITH_CYCLES_CUDA_BUILD_SERIAL)
+        set(prev_arch ${arch})
+      endif()
+
+      unset(cuda_nvcc_executable)
+      unset(cuda_toolkit_root_dir)
+    endif()
+  endforeach()
+
+  add_custom_target(cycles_kernel_cuda
+    ALL
+    DEPENDS ${cuda_cubins}
+    SOURCES ${SRC_KERNEL_DEVICE_CUDA} ${SRC_KERNEL_DEVICE_CUDA_HEADERS}
+  )
+  cycles_set_solution_folder(cycles_kernel_cuda)
+
+  source_group("device\\cuda" FILES ${SRC_KERNEL_DEVICE_CUDA} ${SRC_KERNEL_DEVICE_CUDA_HEADERS})
+
+  add_dependencies(cycles_kernel cycles_kernel_cuda)
+endif()
+
+delayed_install(${CMAKE_CURRENT_SOURCE_DIR} "${SRC_KERNEL_DEVICE_CUDA}" ${CYCLES_INSTALL_PATH}/source/kernel/device/cuda)
+delayed_install(${CMAKE_CURRENT_SOURCE_DIR} "${SRC_KERNEL_DEVICE_CUDA_HEADERS}" ${CYCLES_INSTALL_PATH}/source/kernel/device/cuda)

blender-5.2.0/intern/cycles/kernel/device/cuda/compat.h

@@ -0,0 +1,119 @@
+/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
+ *
+ * SPDX-License-Identifier: Apache-2.0 */
+
+#pragma once
+
+#define __KERNEL_GPU__
+#define __KERNEL_CUDA__
+#define CCL_NAMESPACE_BEGIN
+#define CCL_NAMESPACE_END
+
+#ifndef ATTR_FALLTHROUGH
+#  define ATTR_FALLTHROUGH
+#endif
+
+/* Manual definitions so we can compile without CUDA toolkit. */
+
+#ifdef __CUDACC_RTC__
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+#else
+#  include <stdint.h>
+#endif
+
+#ifdef CYCLES_CUBIN_CC
+#  define FLT_MIN 1.175494350822287507969e-38f
+#  define FLT_MAX 340282346638528859811704183484516925440.0f
+#  define FLT_EPSILON 1.192092896e-07F
+#endif
+
+/* Qualifiers */
+
+#define ccl_device __device__ __inline__
+#define ccl_device_extern extern "C" __device__
+#define ccl_device_inline __device__ __inline__
+#define ccl_device_forceinline __device__ __forceinline__
+#define ccl_device_noinline __device__ __noinline__
+#define ccl_device_noinline_cpu ccl_device
+#define ccl_device_inline_method ccl_device
+#define ccl_device_template_spec template<> ccl_device_inline
+#define ccl_global
+#define ccl_inline_constant __constant__
+#define ccl_device_constant __constant__ __device__
+#define ccl_static_constexpr static constexpr
+#define ccl_constant const
+#define ccl_gpu_shared __shared__
+#define ccl_private
+#define ccl_ray_data ccl_private
+#define ccl_may_alias
+#define ccl_restrict __restrict__
+#define ccl_align(n) __align__(n)
+#define ccl_optional_struct_init
+#define ccl_attr_maybe_unused [[maybe_unused]]
+
+/* No assert supported for CUDA */
+
+#define kernel_assert(cond)
+
+/* GPU thread, block, grid size and index */
+
+#define ccl_gpu_thread_idx_x (threadIdx.x)
+#define ccl_gpu_block_dim_x (blockDim.x)
+#define ccl_gpu_block_idx_x (blockIdx.x)
+#define ccl_gpu_grid_dim_x (gridDim.x)
+#define ccl_gpu_warp_size (warpSize)
+#define ccl_gpu_thread_mask(thread_warp) uint(0xFFFFFFFF >> (ccl_gpu_warp_size - thread_warp))
+
+#define ccl_gpu_global_id_x() (ccl_gpu_block_idx_x * ccl_gpu_block_dim_x + ccl_gpu_thread_idx_x)
+#define ccl_gpu_global_size_x() (ccl_gpu_grid_dim_x * ccl_gpu_block_dim_x)
+
+/* GPU warp synchronization. */
+
+#define ccl_gpu_syncthreads() __syncthreads()
+#define ccl_gpu_ballot(predicate) __ballot_sync(0xFFFFFFFF, predicate)
+
+/* GPU texture objects */
+
+typedef unsigned long long CUtexObject;
+typedef CUtexObject ccl_gpu_image_object_2D;
+
+template<typename T>
+ccl_device_forceinline T ccl_gpu_image_object_read_2D(const ccl_gpu_image_object_2D texobj,
+                                                      const float x,
+                                                      const float y)
+{
+  return tex2D<T>(texobj, x, y);
+}
+
+/* Use fast math functions */
+
+#define cosf(x) __cosf(((float)(x)))
+#define sinf(x) __sinf(((float)(x)))
+#define powf(x, y) __powf(((float)(x)), ((float)(y)))
+#define tanf(x) __tanf(((float)(x)))
+#define logf(x) __logf(((float)(x)))
+#define expf(x) __expf(((float)(x)))
+
+/* Half */
+
+typedef unsigned short half;
+
+ccl_device_forceinline half __float2half(const float f)
+{
+  half val;
+  asm("{  cvt.rn.f16.f32 %0, %1;}\n" : "=h"(val) : "f"(f));
+  return val;
+}
+
+ccl_device_forceinline float __half2float(const half h)
+{
+  float val;
+  asm("{  cvt.f32.f16 %0, %1;}\n" : "=f"(val) : "h"(h));
+  return val;
+}
+
+/* Types */
+
+#include "util/half.h"
+#include "util/types.h"

blender-5.2.0/intern/cycles/kernel/device/cuda/config.h

@@ -0,0 +1,88 @@
+/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
+ *
+ * SPDX-License-Identifier: Apache-2.0 */
+
+/* Device data taken from CUDA occupancy calculator.
+ *
+ * Terminology
+ * - CUDA GPUs have multiple streaming multiprocessors
+ * - Each multiprocessor executes multiple thread blocks
+ * - Each thread block contains a number of threads, also known as the block size
+ * - Multiprocessors have a fixed number of registers, and the amount of registers
+ *   used by each threads limits the number of threads per block.
+ */
+
+/* 5.x, 6.x */
+#if __CUDA_ARCH__ <= 699
+#  define GPU_MULTIPRESSOR_MAX_REGISTERS 65536
+#  define GPU_MULTIPROCESSOR_MAX_BLOCKS 32
+#  define GPU_BLOCK_MAX_THREADS 1024
+#  define GPU_THREAD_MAX_REGISTERS 255
+
+/* tunable parameters */
+#  define GPU_KERNEL_BLOCK_NUM_THREADS 256
+/* CUDA 9.0 seems to cause slowdowns on high-end Pascal cards unless we increase the number of
+ * registers */
+#  if __CUDACC_VER_MAJOR__ >= 9 && __CUDA_ARCH__ >= 600
+#    define GPU_KERNEL_MAX_REGISTERS 64
+#  else
+#    define GPU_KERNEL_MAX_REGISTERS 48
+#  endif
+
+/* 7.x, 8.x, 12.x */
+#elif __CUDA_ARCH__ <= 1299
+#  define GPU_MULTIPRESSOR_MAX_REGISTERS 65536
+#  define GPU_MULTIPROCESSOR_MAX_BLOCKS 32
+#  define GPU_BLOCK_MAX_THREADS 1024
+#  define GPU_THREAD_MAX_REGISTERS 255
+
+/* tunable parameters */
+#  define GPU_KERNEL_BLOCK_NUM_THREADS 384
+#  define GPU_KERNEL_MAX_REGISTERS 168
+
+/* unknown architecture */
+#else
+#  error "Unknown or unsupported CUDA architecture, can't determine launch bounds"
+#endif
+
+/* Compute number of threads per block and minimum blocks per multiprocessor
+ * given the maximum number of registers per thread. */
+#define ccl_gpu_kernel(block_num_threads, thread_num_registers) \
+  extern "C" __global__ void __launch_bounds__(block_num_threads, \
+                                               GPU_MULTIPRESSOR_MAX_REGISTERS / \
+                                                   (block_num_threads * thread_num_registers))
+
+#define ccl_gpu_kernel_threads(block_num_threads) \
+  extern "C" __global__ void __launch_bounds__(block_num_threads)
+
+#define ccl_gpu_kernel_signature(name, ...) kernel_gpu_##name(__VA_ARGS__)
+#define ccl_gpu_kernel_postfix
+
+#define ccl_gpu_kernel_call(x) x
+#define ccl_gpu_kernel_within_bounds(i, n) ((i) < (n))
+
+/* Define a function object where "func" is the lambda body, and additional parameters are used to
+ * specify captured state  */
+#define ccl_gpu_kernel_lambda(func, ...) \
+  struct KernelLambda { \
+    __VA_ARGS__; \
+    __device__ int operator()(const int state) \
+    { \
+      return (func); \
+    } \
+  } ccl_gpu_kernel_lambda_pass
+
+/* sanity checks */
+
+#if GPU_KERNEL_BLOCK_NUM_THREADS > GPU_BLOCK_MAX_THREADS
+#  error "Maximum number of threads per block exceeded"
+#endif
+
+#if GPU_MULTIPRESSOR_MAX_REGISTERS / (GPU_KERNEL_BLOCK_NUM_THREADS * GPU_KERNEL_MAX_REGISTERS) > \
+    GPU_MULTIPROCESSOR_MAX_BLOCKS
+#  error "Maximum number of blocks per multiprocessor exceeded"
+#endif
+
+#if GPU_KERNEL_MAX_REGISTERS > GPU_THREAD_MAX_REGISTERS
+#  error "Maximum number of registers per thread exceeded"
+#endif

blender-5.2.0/intern/cycles/kernel/device/cuda/globals.h

@@ -0,0 +1,48 @@
+/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
+ *
+ * SPDX-License-Identifier: Apache-2.0 */
+
+/* Constant Globals */
+
+#pragma once
+
+#include "kernel/types.h"
+
+#include "kernel/integrator/state.h"
+#include "kernel/util/profiler.h"
+
+#include "util/color.h"
+#include "util/types_image.h"
+
+CCL_NAMESPACE_BEGIN
+
+/* Not actually used, just a nullptr pointer that gets passed everywhere, which we
+ * hope gets optimized out by the compiler. */
+struct KernelGlobalsGPU {
+  int unused[1];
+};
+using KernelGlobals = const ccl_global KernelGlobalsGPU *ccl_restrict;
+
+struct KernelParamsCUDA {
+  /* Global scene data and textures */
+  KernelData data;
+#define KERNEL_DATA_ARRAY(type, name) const type *name;
+#define KERNEL_DATA_ARRAY_WRITABLE(type, name) type *name;
+#include "kernel/data_arrays.h"
+
+  /* Integrator state */
+  IntegratorStateGPU integrator_state;
+};
+
+#ifdef __KERNEL_GPU__
+__constant__ KernelParamsCUDA kernel_params;
+#endif
+
+/* Abstraction macros */
+#define kernel_data kernel_params.data
+#define kernel_data_fetch(name, index) kernel_params.name[(index)]
+#define kernel_data_write(name, index, value) kernel_params.name[(index)] = (value)
+#define kernel_data_array(name) (kernel_params.name)
+#define kernel_integrator_state kernel_params.integrator_state
+
+CCL_NAMESPACE_END

blender-5.2.0/intern/cycles/kernel/device/cuda/kernel.cu

@@ -0,0 +1,16 @@
+/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
+ *
+ * SPDX-License-Identifier: Apache-2.0 */
+
+/* CUDA kernel entry points */
+
+#ifdef __CUDA_ARCH__
+
+#  include "kernel/device/cuda/compat.h"
+#  include "kernel/device/cuda/config.h"
+#  include "kernel/device/cuda/globals.h"
+
+#  include "kernel/device/gpu/image.h"
+#  include "kernel/device/gpu/kernel.h"
+
+#endif