Add Chromium-only Blender WebEngine parity work

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

@@ -0,0 +1,126 @@
+# SPDX-FileCopyrightText: 2011-2026 Blender Foundation
+#
+# SPDX-License-Identifier: Apache-2.0
+
+set(INC
+  ../../..
+)
+
+set(INC_SYS
+
+)
+
+set(SRC_KERNEL_DEVICE_HIP
+  kernel.cpp
+)
+
+set(SRC_KERNEL_DEVICE_HIP_HEADERS
+  compat.h
+  config.h
+  globals.h
+)
+
+set(LIB
+
+)
+
+if(WITH_CYCLES_HIP_BINARIES AND WITH_CYCLES_DEVICE_HIP)
+  # build for each arch
+  set(hip_sources
+    kernel.cpp
+    ${SRC_KERNEL_DEVICE_HIP_HEADERS}
+    $<TARGET_PROPERTY:cycles_kernel,INTERFACE_SOURCES>
+  )
+  set(hip_fatbins "")
+
+  # Modifies in parent scope:
+  # - `hip_fatbins`: appended with compressed `fatbin` output.
+  function(CYCLES_HIP_KERNEL_ADD arch name flags sources experimental)
+    set(format "fatbin")
+    set(hip_file ${name}_${arch}.${format})
+    set(hip_file_compressed ${hip_file}.zst)
+    set(kernel_sources ${sources})
+
+    set(hip_kernel_src "/${name}.cpp")
+
+    if(WIN32)
+      set(hip_command ${CMAKE_COMMAND})
+      set(hip_flags
+        -E env "HIP_PATH=${HIP_ROOT_DIR}"
+        ${HIP_HIPCC_EXECUTABLE})
+    else()
+      set(hip_command ${HIP_HIPCC_EXECUTABLE})
+      set(hip_flags "")
+    endif()
+
+    # There's a few bugs in the HIP compiler causing some scenes to fail to render,
+    # or render improperly with specific combinations of device and/or compiler.
+    # - Vega (gfx90x) fails to render some scenes
+    # - Other GPUs (E.g. RDNA3) render volumes improperly with HIP 6.1.40252
+    # A workaround is to set -O1 opt level during kernel compilation for these
+    # configurations.
+    if(WIN32 AND ((${arch} MATCHES "gfx90[a-z0-9]+") OR (${HIP_VERSION} STREQUAL "6.1.40252")))
+      set(hip_opt_flags "-O1")
+    else()
+      set(hip_opt_flags "")
+    endif()
+
+    set(hip_flags
+      ${hip_flags}
+      --offload-arch=${arch}
+      ${HIP_HIPCC_FLAGS}
+      --genco
+      ${CMAKE_CURRENT_SOURCE_DIR}${hip_kernel_src}
+      ${flags}
+      -D CCL_NAMESPACE_BEGIN=
+      -D CCL_NAMESPACE_END=
+      -D HIPCC
+      -I ${CMAKE_CURRENT_SOURCE_DIR}/../../..
+      -Wno-parentheses-equality
+      -Wno-unused-value
+      -ffast-math
+      -std=c++17
+      ${hip_opt_flags}
+      -o ${CMAKE_CURRENT_BINARY_DIR}/${hip_file})
+
+    if(WITH_NANOVDB)
+      set(hip_flags ${hip_flags}
+        -D WITH_NANOVDB)
+    endif()
+
+    if(WITH_CYCLES_DEBUG)
+      set(hip_flags ${hip_flags} -D WITH_CYCLES_DEBUG)
+    endif()
+
+    add_custom_command(
+      OUTPUT ${hip_file}
+      COMMAND ${hip_command} ${hip_flags}
+      DEPENDS ${kernel_sources})
+    add_custom_command(
+      OUTPUT ${hip_file_compressed}
+      COMMAND "$<TARGET_FILE:zstd_compress>" ${hip_file} ${hip_file_compressed}
+      DEPENDS ${hip_file})
+    delayed_install("${CMAKE_CURRENT_BINARY_DIR}" "${hip_file_compressed}" ${CYCLES_INSTALL_PATH}/lib)
+    list(APPEND hip_fatbins ${hip_file_compressed})
+    set(hip_fatbins "${hip_fatbins}" PARENT_SCOPE)
+  endfunction()
+
+  foreach(arch ${CYCLES_HIP_BINARIES_ARCH})
+    # Compile regular kernel
+    cycles_hip_kernel_add(${arch} kernel "" "${hip_sources}" FALSE)
+  endforeach()
+
+  add_custom_target(cycles_kernel_hip
+    ALL
+    DEPENDS ${hip_fatbins}
+    SOURCES ${SRC_KERNEL_DEVICE_HIP} ${SRC_KERNEL_DEVICE_HIP_HEADERS}
+  )
+  cycles_set_solution_folder(cycles_kernel_hip)
+
+  source_group("device\\hip" FILES ${SRC_KERNEL_DEVICE_HIP} ${SRC_KERNEL_DEVICE_HIP_HEADERS})
+
+  add_dependencies(cycles_kernel cycles_kernel_hip)
+endif()
+
+delayed_install(${CMAKE_CURRENT_SOURCE_DIR} "${SRC_KERNEL_DEVICE_HIP}" ${CYCLES_INSTALL_PATH}/source/kernel/device/hip)
+delayed_install(${CMAKE_CURRENT_SOURCE_DIR} "${SRC_KERNEL_DEVICE_HIP_HEADERS}" ${CYCLES_INSTALL_PATH}/source/kernel/device/hip)

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

@@ -0,0 +1,103 @@
+/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
+ *
+ * SPDX-License-Identifier: Apache-2.0 */
+
+#pragma once
+
+#define __KERNEL_GPU__
+#define __KERNEL_HIP__
+#define CCL_NAMESPACE_BEGIN
+#define CCL_NAMESPACE_END
+
+#ifndef ATTR_FALLTHROUGH
+#  define ATTR_FALLTHROUGH
+#endif
+
+#ifdef __HIPCC_RTC__
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+#else
+#  include <stdint.h>
+#endif
+
+#ifdef CYCLES_HIPBIN_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]]
+
+#define kernel_assert(cond)
+
+/* Types */
+#ifdef __HIP__
+#  include "hip/hip_fp16.h"
+#  include "hip/hip_runtime.h"
+#endif
+
+#ifdef _MSC_VER
+#  include <immintrin.h>
+#endif
+
+#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) uint64_t((1ull << thread_warp) - 1)
+
+#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(predicate)
+
+/* GPU texture objects */
+typedef hipTextureObject_t 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)))
+
+/* Types */
+
+#include "util/half.h"
+#include "util/types.h"

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

@@ -0,0 +1,68 @@
+/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
+ *
+ * SPDX-License-Identifier: Apache-2.0 */
+
+/* Device data taken from HIP occupancy calculator.
+ *
+ * Terminology
+ * - HIP 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.
+ */
+
+/* Launch Bound Definitions */
+#define GPU_MULTIPRESSOR_MAX_REGISTERS 65536
+#define GPU_MULTIPROCESSOR_MAX_BLOCKS 64
+#define GPU_BLOCK_MAX_THREADS 1024
+#define GPU_THREAD_MAX_REGISTERS 255
+
+#define GPU_KERNEL_BLOCK_NUM_THREADS 1024
+#define GPU_KERNEL_MAX_REGISTERS 64
+
+/* For performance tuning of HIPRT kernels we might have to change the number
+ * that's why we don't use GPU_KERNEL_BLOCK_NUM_THREADS. */
+#define GPU_HIPRT_KERNEL_BLOCK_NUM_THREADS 1024
+
+/* 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/hip/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 KernelParamsHIP {
+  /* 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__ KernelParamsHIP 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/hip/kernel.cpp

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