temp-sculpt-colors: remove unrelated icons

Caused by oversight in 0e38002dd5. Constant x/y value was used to
calculate transition instead of pixel x/y coords.

CMakeLists.txt

@@ -256,7 +256,7 @@ endif()
 
 if(UNIX AND NOT APPLE)
   option(WITH_SYSTEM_GLEW "Use GLEW OpenGL wrapper library provided by the operating system" OFF)
-  option(WITH_SYSTEM_GLEW "Use GLEW OpenGL wrapper library provided by the operating system" OFF)
+  option(WITH_SYSTEM_GLES "Use OpenGL ES library provided by the operating system"           ON)
   option(WITH_SYSTEM_FREETYPE "Use the freetype library provided by the operating system" OFF)
 else()
   # not an option for other OS's
@@ -284,6 +284,7 @@ option(WITH_IMAGE_TIFF          "Enable LibTIFF Support" ON)
 option(WITH_IMAGE_DDS           "Enable DDS Image Support" ON)
 option(WITH_IMAGE_CINEON        "Enable CINEON and DPX Image Support" ON)
 option(WITH_IMAGE_HDR           "Enable HDR Image Support" ON)
+option(WITH_IMAGE_WEBP          "Enable WebP Image Support" OFF)
 
 # Audio/Video format support
 option(WITH_CODEC_AVI           "Enable Blenders own AVI file support (raw/jpeg)" ON)
@@ -408,6 +409,8 @@ option(WITH_CYCLES_DEBUG             "Build Cycles with options useful for debug
 option(WITH_CYCLES_STANDALONE        "Build Cycles standalone application" OFF)
 option(WITH_CYCLES_STANDALONE_GUI    "Build Cycles standalone with GUI" OFF)
 
+option(WITH_CYCLES_HYDRA_RENDER_DELEGATE "Build Cycles Hydra render delegate" OFF)
+
 option(WITH_CYCLES_DEBUG_NAN         "Build Cycles with additional asserts for detecting NaNs and invalid values" OFF)
 option(WITH_CYCLES_NATIVE_ONLY       "Build Cycles with native kernel only (which fits current CPU, use for development only)" OFF)
 option(WITH_CYCLES_KERNEL_ASAN       "Build Cycles kernels with address sanitizer when WITH_COMPILER_ASAN is on, even if it's very slow" OFF)
@@ -443,7 +446,7 @@ if(NOT APPLE)
   endif()
 
   option(WITH_CYCLES_HIP_BINARIES      "Build Cycles AMD HIP binaries" OFF)
-  set(CYCLES_HIP_BINARIES_ARCH gfx1010 gfx1011 gfx1012 gfx1030 gfx1031 gfx1032 gfx1034 CACHE STRING "AMD HIP architectures to build binaries for")
+  set(CYCLES_HIP_BINARIES_ARCH gfx900 gfx906 gfx1010 gfx1011 gfx1012 gfx1030 gfx1031 gfx1032 gfx1034 CACHE STRING "AMD HIP architectures to build binaries for")
   mark_as_advanced(WITH_CYCLES_DEVICE_HIP)
   mark_as_advanced(CYCLES_HIP_BINARIES_ARCH)
 endif()
@@ -502,7 +505,7 @@ else()
   set(WITH_EXPERIMENTAL_FEATURES OFF)
 endif()
 
-# Unit testsing
+# Unit testing
 option(WITH_GTESTS "Enable GTest unit testing" OFF)
 option(WITH_OPENGL_RENDER_TESTS "Enable OpenGL render related unit testing (Experimental)" OFF)
 option(WITH_OPENGL_DRAW_TESTS "Enable OpenGL UI drawing related unit testing (Experimental)" OFF)
@@ -531,6 +534,19 @@ mark_as_advanced(
   WITH_GPU_SHADER_BUILDER
 )
 
+# Metal
+
+if (APPLE)
+  option(WITH_METAL_BACKEND "Use Metal for graphics instead of (or as well as) OpenGL on macOS." OFF)
+  mark_as_advanced(WITH_METAL_BACKEND)
+else()
+  set(WITH_METAL_BACKEND OFF)
+endif()
+
+if (WITH_METAL_BACKEND)
+  set(CMAKE_OSX_DEPLOYMENT_TARGET "10.15" CACHE STRING "Minimum OS X deployment version" FORCE)
+endif()
+
 if(WIN32)
   option(WITH_GL_ANGLE "Link with the ANGLE library, an OpenGL ES 2.0 implementation based on Direct3D, instead of the system OpenGL library." OFF)
   mark_as_advanced(WITH_GL_ANGLE)
@@ -729,9 +745,10 @@ endif()
 #-----------------------------------------------------------------------------
 # Check for conflicting/unsupported configurations
 
-if(NOT WITH_BLENDER AND NOT WITH_CYCLES_STANDALONE)
+if(NOT WITH_BLENDER AND NOT WITH_CYCLES_STANDALONE AND NOT WITH_CYCLES_HYDRA_RENDER_DELEGATE)
   message(FATAL_ERROR
     "At least one of WITH_BLENDER or WITH_CYCLES_STANDALONE "
+    "or WITH_CYCLES_HYDRA_RENDER_DELEGATE "
     "must be enabled, nothing to do!"
   )
 endif()
@@ -1274,6 +1291,16 @@ else()
   list(APPEND GL_DEFINITIONS -DWITH_GL_PROFILE_CORE)
 endif()
 
+#-----------------------------------------------------------------------------
+# Configure Metal.
+if (WITH_METAL_BACKEND)
+  add_definitions(-DWITH_METAL_BACKEND)
+
+  # No need to add frameworks here, all the ones we need for Metal and
+  # Metal-OpenGL Interop are already being added by
+  # build_files/cmake/platform/platform_apple.cmake
+endif()
+
 #-----------------------------------------------------------------------------
 # Configure OpenMP.
 if(WITH_OPENMP)
@@ -1668,6 +1695,8 @@ elseif(CMAKE_C_COMPILER_ID MATCHES "Clang")
   ADD_CHECK_C_COMPILER_FLAG(C_REMOVE_STRICT_FLAGS C_WARN_NO_DUPLICATE_ENUM -Wno-duplicate-enum)
   ADD_CHECK_C_COMPILER_FLAG(C_REMOVE_STRICT_FLAGS C_WARN_NO_UNDEF -Wno-undef)
   ADD_CHECK_C_COMPILER_FLAG(C_REMOVE_STRICT_FLAGS C_WARN_NO_MISSING_NORETURN -Wno-missing-noreturn)
+  ADD_CHECK_C_COMPILER_FLAG(C_REMOVE_STRICT_FLAGS C_WARN_NO_UNUSED_BUT_SET_VARIABLE -Wno-unused-but-set-variable)
+  ADD_CHECK_C_COMPILER_FLAG(C_REMOVE_STRICT_FLAGS C_WARN_NO_DEPRECATED_DECLARATIONS -Wno-deprecated-declarations)
 
   ADD_CHECK_CXX_COMPILER_FLAG(CXX_REMOVE_STRICT_FLAGS CXX_WARN_NO_UNUSED_PARAMETER -Wno-unused-parameter)
   ADD_CHECK_CXX_COMPILER_FLAG(CXX_REMOVE_STRICT_FLAGS CXX_WARN_NO_UNUSED_PRIVATE_FIELD -Wno-unused-private-field)
@@ -1882,14 +1911,13 @@ if(WITH_BLENDER)
   # source after intern and extern to gather all
   # internal and external library information first, for test linking
   add_subdirectory(source)
-elseif(WITH_CYCLES_STANDALONE)
+elseif(WITH_CYCLES_STANDALONE OR WITH_CYCLES_HYDRA_RENDER_DELEGATE)
   add_subdirectory(intern/glew-mx)
   add_subdirectory(intern/guardedalloc)
   add_subdirectory(intern/libc_compat)
   add_subdirectory(intern/sky)
 
   add_subdirectory(intern/cycles)
-  add_subdirectory(extern/clew)
   if(WITH_CYCLES_LOGGING)
     if(NOT WITH_SYSTEM_GFLAGS)
       add_subdirectory(extern/gflags)
@@ -1946,7 +1974,7 @@ if(FIRST_RUN)
 
     set(_msg "  - ${_setting}")
     string(LENGTH "${_msg}" _len)
-    while("32" GREATER "${_len}")
+    while("36" GREATER "${_len}")
       string(APPEND _msg " ")
       math(EXPR _len "${_len} + 1")
     endwhile()

GNUmakefile

@@ -32,7 +32,7 @@ Other Convenience Targets
    * config:        Run cmake configuration tool to set build options.
    * deps:          Build library dependencies (intended only for platform maintainers).
 
-                    The existance of locally build dependencies overrides the pre-built dependencies from subversion.
+                    The existence of locally build dependencies overrides the pre-built dependencies from subversion.
                     These must be manually removed from '../lib/' to go back to using the pre-compiled libraries.
 
 Project Files

build_files/build_environment/cmake/download.cmake

@@ -1,11 +1,16 @@
 # SPDX-License-Identifier: GPL-2.0-or-later
 
+## Update and uncomment this in the release branch
+# set(BLENDER_VERSION 3.1)
+
 function(download_source dep)
   set(TARGET_FILE ${${dep}_FILE})
   set(TARGET_HASH_TYPE ${${dep}_HASH_TYPE})
   set(TARGET_HASH ${${dep}_HASH})
   if(PACKAGE_USE_UPSTREAM_SOURCES)
     set(TARGET_URI  ${${dep}_URI})
+  elseif(BLENDER_VERSION)
+    set(TARGET_URI  https://svn.blender.org/svnroot/bf-blender/tags/blender-${BLENDER_VERSION}-release/lib/packages/${TARGET_FILE})
   else()
     set(TARGET_URI  https://svn.blender.org/svnroot/bf-blender/trunk/lib/packages/${TARGET_FILE})
   endif()

build_files/build_environment/cmake/usd.cmake

@@ -52,6 +52,14 @@ add_dependencies(
   external_boost
 )
 
+# Since USD 21.11 the libraries are prefixed with "usd_", i.e. "libusd_m.a" became "libusd_usd_m.a".
+# See https://github.com/PixarAnimationStudios/USD/blob/release/CHANGELOG.md#2111---2021-11-01
+if (USD_VERSION VERSION_LESS 21.11)
+  set(PXR_LIB_PREFIX "")
+else()
+  set(PXR_LIB_PREFIX "usd_")
+endif()
+
 if(WIN32)
   # USD currently demands python be available at build time
   # and then proceeds not to use it, but still checks that the
@@ -65,14 +73,14 @@ if(WIN32)
   if(BUILD_MODE STREQUAL Release)
     ExternalProject_Add_Step(external_usd after_install
       COMMAND ${CMAKE_COMMAND} -E copy_directory ${LIBDIR}/usd/ ${HARVEST_TARGET}/usd
-      COMMAND ${CMAKE_COMMAND} -E copy ${BUILD_DIR}/usd/src/external_usd-build/pxr/Release/usd_m.lib ${HARVEST_TARGET}/usd/lib/libusd_m.lib
+      COMMAND ${CMAKE_COMMAND} -E copy ${BUILD_DIR}/usd/src/external_usd-build/pxr/Release/${PXR_LIB_PREFIX}usd_m.lib ${HARVEST_TARGET}/usd/lib/lib${PXR_LIB_PREFIX}usd_m.lib
       DEPENDEES install
     )
   endif()
   if(BUILD_MODE STREQUAL Debug)
     ExternalProject_Add_Step(external_usd after_install
       COMMAND ${CMAKE_COMMAND} -E copy_directory ${LIBDIR}/usd/lib ${HARVEST_TARGET}/usd/lib
-      COMMAND ${CMAKE_COMMAND} -E copy ${BUILD_DIR}/usd/src/external_usd-build/pxr/Debug/usd_m_d.lib ${HARVEST_TARGET}/usd/lib/libusd_m_d.lib
+      COMMAND ${CMAKE_COMMAND} -E copy ${BUILD_DIR}/usd/src/external_usd-build/pxr/Debug/${PXR_LIB_PREFIX}usd_m_d.lib ${HARVEST_TARGET}/usd/lib/lib${PXR_LIB_PREFIX}usd_m_d.lib
       DEPENDEES install
     )
   endif()
@@ -84,7 +92,7 @@ else()
   # case (only the shared library). As a result, we need to grab the `libusd_m.a`
   # file from the build directory instead of from the install directory.
   ExternalProject_Add_Step(external_usd after_install
-    COMMAND ${CMAKE_COMMAND} -E copy ${BUILD_DIR}/usd/src/external_usd-build/pxr/libusd_m.a ${HARVEST_TARGET}/usd/lib/libusd_m.a
+    COMMAND ${CMAKE_COMMAND} -E copy ${BUILD_DIR}/usd/src/external_usd-build/pxr/lib${PXR_LIB_PREFIX}usd_m.a ${HARVEST_TARGET}/usd/lib/lib${PXR_LIB_PREFIX}usd_m.a
     DEPENDEES install
   )
 endif()

build_files/cmake/Modules/FindUSD.cmake

@@ -32,9 +32,12 @@ FIND_PATH(USD_INCLUDE_DIR
   DOC "Universal Scene Description (USD) header files"
 )
 
+# Since USD 21.11 the libraries are prefixed with "usd_", i.e. "libusd_m.a" became "libusd_usd_m.a".
+# See https://github.com/PixarAnimationStudios/USD/blob/release/CHANGELOG.md#2111---2021-11-01
 FIND_LIBRARY(USD_LIBRARY
   NAMES
-    usd_m usd_ms
+    usd_usd_m usd_usd_ms usd_m usd_ms
+    ${PXR_LIB_PREFIX}usd
   NAMES_PER_DIR
   HINTS
     ${_usd_SEARCH_DIRS}

build_files/cmake/Modules/FindWebP.cmake

@@ -0,0 +1,77 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright 2022 Blender Foundation.
+
+# - Find WebP library
+# Find the native WebP includes and library
+# This module defines
+#  WEBP_INCLUDE_DIRS, where to find WebP headers, Set when WebP is found.
+#  WEBP_LIBRARIES, libraries to link against to use WebP.
+#  WEBP_ROOT_DIR, The base directory to search for WebP.
+#                 This can also be an environment variable.
+#  WEBP_FOUND, If false, do not try to use WebP.
+#
+# also defined, but not for general use are
+#  WEBP_LIBRARY, where to find the WEBP library.
+
+# If WEBP_ROOT_DIR was defined in the environment, use it.
+IF(NOT WEBP_ROOT_DIR AND NOT $ENV{WEBP_ROOT_DIR} STREQUAL "")
+  SET(WEBP_ROOT_DIR $ENV{WEBP_ROOT_DIR})
+ENDIF()
+
+SET(_webp_SEARCH_DIRS
+  ${WEBP_ROOT_DIR}
+  /opt/lib/webp
+)
+
+FIND_PATH(WEBP_INCLUDE_DIR
+  NAMES
+    webp/types.h
+  HINTS
+    ${_webp_SEARCH_DIRS}
+  PATH_SUFFIXES
+    include
+)
+
+SET(_webp_FIND_COMPONENTS
+  webp
+  webpmux
+  webpdemux
+)
+
+SET(_webp_LIBRARIES)
+FOREACH(COMPONENT ${_webp_FIND_COMPONENTS})
+  STRING(TOUPPER ${COMPONENT} UPPERCOMPONENT)
+
+  FIND_LIBRARY(WEBP_${UPPERCOMPONENT}_LIBRARY
+    NAMES
+      ${COMPONENT}
+    NAMES_PER_DIR
+    HINTS
+      ${_webp_SEARCH_DIRS}
+    PATH_SUFFIXES
+      lib64 lib lib/static
+    )
+  LIST(APPEND _webp_LIBRARIES "${WEBP_${UPPERCOMPONENT}_LIBRARY}")
+ENDFOREACH()
+
+IF(${WEBP_WEBP_LIBRARY_NOTFOUND})
+  set(WEBP_FOUND FALSE)
+ELSE()
+  # handle the QUIETLY and REQUIRED arguments and set WEBP_FOUND to TRUE if
+  # all listed variables are TRUE
+  INCLUDE(FindPackageHandleStandardArgs)
+  FIND_PACKAGE_HANDLE_STANDARD_ARGS(WebP DEFAULT_MSG _webp_LIBRARIES WEBP_INCLUDE_DIR)
+
+  IF(WEBP_FOUND)
+    get_filename_component(WEBP_LIBRARY_DIR ${WEBP_WEBP_LIBRARY} DIRECTORY)
+    SET(WEBP_INCLUDE_DIRS ${WEBP_INCLUDE_DIR})
+    SET(WEBP_LIBRARIES ${_webp_LIBRARIES})
+  ELSE()
+    SET(WEBPL_PUGIXML_FOUND FALSE)
+  ENDIF()
+ENDIF()
+
+MARK_AS_ADVANCED(
+  WEBP_INCLUDE_DIR
+  WEBP_LIBRARY_DIR
+)

build_files/cmake/macros.cmake

@@ -879,7 +879,7 @@ function(delayed_install
   destination)
 
   foreach(f ${files})
-    if(IS_ABSOLUTE ${f})
+    if(IS_ABSOLUTE ${f} OR "${base}" STREQUAL "")
       set_property(GLOBAL APPEND PROPERTY DELAYED_INSTALL_FILES ${f})
     else()
       set_property(GLOBAL APPEND PROPERTY DELAYED_INSTALL_FILES ${base}/${f})

build_files/cmake/packaging.cmake

@@ -106,8 +106,8 @@ if(WIN32)
   set(CPACK_WIX_LIGHT_EXTRA_FLAGS -dcl:medium)
 endif()
 
-set(CPACK_PACKAGE_EXECUTABLES "blender-launcher" "blender")
-set(CPACK_CREATE_DESKTOP_LINKS "blender-launcher" "blender")
+set(CPACK_PACKAGE_EXECUTABLES "blender-launcher" "Blender")
+set(CPACK_CREATE_DESKTOP_LINKS "blender-launcher" "Blender")
 
 include(CPack)
 

build_files/cmake/platform/platform_apple.cmake

@@ -232,6 +232,15 @@ if(WITH_IMAGE_TIFF)
   endif()
 endif()
 
+if(WITH_IMAGE_WEBP)
+  set(WEBP_ROOT_DIR ${LIBDIR}/webp)
+  find_package(WebP)
+  if(NOT WEBP_FOUND)
+    message(WARNING "WebP not found, disabling WITH_IMAGE_WEBP")
+    set(WITH_IMAGE_WEBP OFF)
+  endif()
+endif()
+
 if(WITH_BOOST)
   set(Boost_NO_BOOST_CMAKE ON)
   set(BOOST_ROOT ${LIBDIR}/boost)

build_files/cmake/platform/platform_unix.cmake

@@ -368,6 +368,14 @@ if(WITH_PUGIXML)
   endif()
 endif()
 
+if(WITH_IMAGE_WEBP)
+  set(WEBP_ROOT_DIR ${LIBDIR}/webp)
+  find_package_wrapper(WebP)
+  if(NOT WEBP_FOUND)
+    set(WITH_IMAGE_WEBP OFF)
+  endif()
+endif()
+
 if(WITH_OPENIMAGEIO)
   find_package_wrapper(OpenImageIO)
   set(OPENIMAGEIO_LIBRARIES
@@ -858,7 +866,7 @@ endif()
 # If atomic operations are possible without libatomic then linker flags are left as-is.
 function(CONFIGURE_ATOMIC_LIB_IF_NEEDED)
   # Source which is used to enforce situation when software emulation of atomics is required.
-  # Assume that using 64bit integer gives a definitive asnwer (as in, if 64bit atomic operations
+  # Assume that using 64bit integer gives a definitive answer (as in, if 64bit atomic operations
   # are possible using assembly/intrinsics 8, 16, and 32 bit operations will also be possible.
   set(_source
       "#include <atomic>

build_files/cmake/platform/platform_win32.cmake

@@ -39,12 +39,12 @@ if(CMAKE_C_COMPILER_ID MATCHES "Clang")
     set(WITH_WINDOWS_STRIPPED_PDB OFF)
   endif()
 else()
-  if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.28.29921) # MSVC 2019 16.9.16
+  if(WITH_BLENDER AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.28.29921) # MSVC 2019 16.9.16
     message(FATAL_ERROR "Compiler is unsupported, MSVC 2019 16.9.16 or newer is required for building blender.")
   endif()
 endif()
 
-if(NOT WITH_PYTHON_MODULE)
+if(WITH_BLENDER AND NOT WITH_PYTHON_MODULE)
   set_property(DIRECTORY PROPERTY VS_STARTUP_PROJECT blender)
 endif()
 
@@ -238,7 +238,6 @@ else()
 endif()
 
 if(NOT DEFINED LIBDIR)
-
   # Setup 64bit and 64bit windows systems
   if(CMAKE_CL_64)
     message(STATUS "64 bit compiler detected.")
@@ -252,6 +251,9 @@ if(NOT DEFINED LIBDIR)
   elseif(MSVC_VERSION GREATER 1919)
     message(STATUS "Visual Studio 2019 detected.")
     set(LIBDIR ${CMAKE_SOURCE_DIR}/../lib/${LIBDIR_BASE}_vc15)
+  elseif(MSVC_VERSION GREATER 1909)
+    message(STATUS "Visual Studio 2017 detected.")
+    set(LIBDIR ${CMAKE_SOURCE_DIR}/../lib/${LIBDIR_BASE}_vc15)
   endif()
 else()
   message(STATUS "Using pre-compiled LIBDIR: ${LIBDIR}")
@@ -300,9 +302,8 @@ set(ZLIB_INCLUDE_DIR ${LIBDIR}/zlib/include)
 set(ZLIB_LIBRARY ${LIBDIR}/zlib/lib/libz_st.lib)
 set(ZLIB_DIR ${LIBDIR}/zlib)
 
-windows_find_package(zlib) # we want to find before finding things that depend on it like png
-windows_find_package(png)
-
+windows_find_package(ZLIB) # we want to find before finding things that depend on it like png
+windows_find_package(PNG)
 if(NOT PNG_FOUND)
   warn_hardcoded_paths(libpng)
   set(PNG_PNG_INCLUDE_DIR ${LIBDIR}/png/include)
@@ -313,9 +314,9 @@ if(NOT PNG_FOUND)
 endif()
 
 set(JPEG_NAMES ${JPEG_NAMES} libjpeg)
-windows_find_package(jpeg REQUIRED)
+windows_find_package(JPEG REQUIRED)
 if(NOT JPEG_FOUND)
-  warn_hardcoded_paths(jpeg)
+  warn_hardcoded_paths(libjpeg)
   set(JPEG_INCLUDE_DIR ${LIBDIR}/jpeg/include)
   set(JPEG_LIBRARIES ${LIBDIR}/jpeg/lib/libjpeg.lib)
 endif()
@@ -333,7 +334,7 @@ set(FREETYPE_LIBRARIES
   ${LIBDIR}/brotli/lib/brotlidec-static.lib
   ${LIBDIR}/brotli/lib/brotlicommon-static.lib
 )
-windows_find_package(freetype REQUIRED)
+windows_find_package(Freetype REQUIRED)
 
 if(WITH_FFTW3)
   set(FFTW3 ${LIBDIR}/fftw3)
@@ -342,6 +343,16 @@ if(WITH_FFTW3)
   set(FFTW3_LIBPATH ${FFTW3}/lib)
 endif()
 
+windows_find_package(WebP)
+if(NOT WEBP_FOUND)
+  if(EXISTS ${LIBDIR}/webp)
+    set(WEBP_INCLUDE_DIRS ${LIBDIR}/webp/include)
+    set(WEBP_ROOT_DIR ${LIBDIR}/webp)
+    set(WEBP_LIBRARIES ${LIBDIR}/webp/lib/webp.lib ${LIBDIR}/webp/lib/webpdemux.lib ${LIBDIR}/webp/lib/webpmux.lib)
+    set(WEBP_FOUND ON)
+  endif()
+endif()
+
 if(WITH_OPENCOLLADA)
   set(OPENCOLLADA ${LIBDIR}/opencollada)
 
@@ -389,9 +400,9 @@ if(WITH_CODEC_FFMPEG)
     ${LIBDIR}/ffmpeg/include
     ${LIBDIR}/ffmpeg/include/msvc
   )
-  windows_find_package(FFMPEG)
+  windows_find_package(FFmpeg)
   if(NOT FFMPEG_FOUND)
-    warn_hardcoded_paths(ffmpeg)
+    warn_hardcoded_paths(FFmpeg)
     set(FFMPEG_LIBRARIES
       ${LIBDIR}/ffmpeg/lib/avcodec.lib
       ${LIBDIR}/ffmpeg/lib/avformat.lib
@@ -403,10 +414,10 @@ if(WITH_CODEC_FFMPEG)
 endif()
 
 if(WITH_IMAGE_OPENEXR)
-  set(OPENEXR_ROOT_DIR ${LIBDIR}/openexr)
-  set(OPENEXR_VERSION "2.1")
-  windows_find_package(OPENEXR REQUIRED)
+  windows_find_package(OpenEXR REQUIRED)
   if(NOT OPENEXR_FOUND)
+    set(OPENEXR_ROOT_DIR ${LIBDIR}/openexr)
+    set(OPENEXR_VERSION "2.1")
     warn_hardcoded_paths(OpenEXR)
     set(OPENEXR ${LIBDIR}/openexr)
     set(OPENEXR_INCLUDE_DIR ${OPENEXR}/include)
@@ -624,21 +635,23 @@ if(WITH_IMAGE_OPENJPEG)
 endif()
 
 if(WITH_OPENSUBDIV)
-  set(OPENSUBDIV_INCLUDE_DIRS ${LIBDIR}/opensubdiv/include)
-  set(OPENSUBDIV_LIBPATH ${LIBDIR}/opensubdiv/lib)
-  set(OPENSUBDIV_LIBRARIES
-    optimized ${OPENSUBDIV_LIBPATH}/osdCPU.lib
-    optimized ${OPENSUBDIV_LIBPATH}/osdGPU.lib
-    debug ${OPENSUBDIV_LIBPATH}/osdCPU_d.lib
-    debug ${OPENSUBDIV_LIBPATH}/osdGPU_d.lib
-  )
-  set(OPENSUBDIV_HAS_OPENMP TRUE)
-  set(OPENSUBDIV_HAS_TBB FALSE)
-  set(OPENSUBDIV_HAS_OPENCL TRUE)
-  set(OPENSUBDIV_HAS_CUDA FALSE)
-  set(OPENSUBDIV_HAS_GLSL_TRANSFORM_FEEDBACK TRUE)
-  set(OPENSUBDIV_HAS_GLSL_COMPUTE TRUE)
   windows_find_package(OpenSubdiv)
+  if (NOT OpenSubdiv_FOUND)
+    set(OPENSUBDIV_INCLUDE_DIRS ${LIBDIR}/opensubdiv/include)
+    set(OPENSUBDIV_LIBPATH ${LIBDIR}/opensubdiv/lib)
+    set(OPENSUBDIV_LIBRARIES
+      optimized ${OPENSUBDIV_LIBPATH}/osdCPU.lib
+      optimized ${OPENSUBDIV_LIBPATH}/osdGPU.lib
+      debug ${OPENSUBDIV_LIBPATH}/osdCPU_d.lib
+      debug ${OPENSUBDIV_LIBPATH}/osdGPU_d.lib
+    )
+    set(OPENSUBDIV_HAS_OPENMP TRUE)
+    set(OPENSUBDIV_HAS_TBB FALSE)
+    set(OPENSUBDIV_HAS_OPENCL TRUE)
+    set(OPENSUBDIV_HAS_CUDA FALSE)
+    set(OPENSUBDIV_HAS_GLSL_TRANSFORM_FEEDBACK TRUE)
+    set(OPENSUBDIV_HAS_GLSL_COMPUTE TRUE)
+  endif()
 endif()
 
 if(WITH_SDL)
@@ -659,12 +672,15 @@ if(WITH_SYSTEM_AUDASPACE)
 endif()
 
 if(WITH_TBB)
-  set(TBB_LIBRARIES optimized ${LIBDIR}/tbb/lib/tbb.lib debug ${LIBDIR}/tbb/lib/tbb_debug.lib)
-  set(TBB_INCLUDE_DIR ${LIBDIR}/tbb/include)
-  set(TBB_INCLUDE_DIRS ${TBB_INCLUDE_DIR})
-  if(WITH_TBB_MALLOC_PROXY)
-    set(TBB_MALLOC_LIBRARIES optimized ${LIBDIR}/tbb/lib/tbbmalloc.lib debug ${LIBDIR}/tbb/lib/tbbmalloc_debug.lib)
-    add_definitions(-DWITH_TBB_MALLOC)
+  windows_find_package(TBB)
+  if (NOT TBB_FOUND)
+    set(TBB_LIBRARIES optimized ${LIBDIR}/tbb/lib/tbb.lib debug ${LIBDIR}/tbb/lib/tbb_debug.lib)
+    set(TBB_INCLUDE_DIR ${LIBDIR}/tbb/include)
+    set(TBB_INCLUDE_DIRS ${TBB_INCLUDE_DIR})
+    if(WITH_TBB_MALLOC_PROXY)
+      set(TBB_MALLOC_LIBRARIES optimized ${LIBDIR}/tbb/lib/tbbmalloc.lib debug ${LIBDIR}/tbb/lib/tbbmalloc_debug.lib)
+      add_definitions(-DWITH_TBB_MALLOC)
+    endif()
   endif()
 endif()
 

build_files/windows/find_dependencies.cmd

@@ -5,7 +5,7 @@ for %%X in (ctest.exe) do (set CTEST=%%~$PATH:X)
 for %%X in (git.exe) do (set GIT=%%~$PATH:X)
 REM For python, default on 39 but if that does not exist also check
 REM the 310,311 and 312 folders to see if those are there, it checks
-REM this far ahead to ensure good lib folder compatiblity in the future.
+REM this far ahead to ensure good lib folder compatibility in the future.
 set PYTHON=%BLENDER_DIR%\..\lib\win64_vc15\python\39\bin\python.exe
 if EXIST %PYTHON% (
 	goto detect_python_done

doc/license/LGPL2.1-license.txt

@@ -0,0 +1,502 @@
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!

doc/license/SPDX-license-identifiers.txt

@@ -5,5 +5,6 @@ BSD-2-Clause              BSD-2-Clause-license.txt  https://spdx.org/licenses/BS
 BSD-3-Clause              BSD-3-Clause-license.txt  https://spdx.org/licenses/BSD-3-Clause.html
 GPL-2.0-or-later          GPL-license.txt           https://spdx.org/licenses/GPL-2.0-or-later.html
 GPL-3.0-or-later          GPL3-license.txt          https://spdx.org/licenses/GPL-3.0-or-later.html
+LGPL-2.1-or-later         LGPL2.1-license.txt       https://spdx.org/licenses/LGPL-2.1-or-later.html
 MIT                       MIT-license.txt           https://spdx.org/licenses/MIT.html
 Zlib                      Zlib-license.txt          https://spdx.org/licenses/Zlib.html

doc/manpage/blender.1.py

@@ -16,7 +16,6 @@ and <output-filename> is where to write the generated man page.
 import argparse
 import os
 import subprocess
-import sys
 import time
 
 from typing import (

extern/fmtlib/LICENSE.rst

@@ -0,0 +1,27 @@
+Copyright (c) 2012 - present, Victor Zverovich
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+--- Optional exception to the license ---
+
+As an exception, if, as a result of your compiling your source code, portions
+of this Software are embedded into a machine-executable object form of such
+source code, you may redistribute such embedded portions in such object form
+without including the above copyright and permission notices.

extern/fmtlib/README.blender

@@ -0,0 +1,8 @@
+Project: {fmt}
+URL: https://github.com/fmtlib/fmt
+License: MIT
+Upstream version: 8.1.1 (b6f4cea)
+Local modifications:
+
+- Took only files needed for Blender: LICENSE, README and include/fmt
+  folder's core.h, format-inl.h, format.h

extern/fmtlib/README.rst

@@ -0,0 +1,528 @@
+{fmt}
+=====
+
+.. image:: https://github.com/fmtlib/fmt/workflows/linux/badge.svg
+   :target: https://github.com/fmtlib/fmt/actions?query=workflow%3Alinux
+
+.. image:: https://github.com/fmtlib/fmt/workflows/macos/badge.svg
+   :target: https://github.com/fmtlib/fmt/actions?query=workflow%3Amacos
+
+.. image:: https://github.com/fmtlib/fmt/workflows/windows/badge.svg
+   :target: https://github.com/fmtlib/fmt/actions?query=workflow%3Awindows
+
+.. image:: https://ci.appveyor.com/api/projects/status/ehjkiefde6gucy1v?svg=true
+   :target: https://ci.appveyor.com/project/vitaut/fmt
+
+.. image:: https://oss-fuzz-build-logs.storage.googleapis.com/badges/fmt.svg
+   :alt: fmt is continuously fuzzed at oss-fuzz
+   :target: https://bugs.chromium.org/p/oss-fuzz/issues/list?\
+            colspec=ID%20Type%20Component%20Status%20Proj%20Reported%20Owner%20\
+            Summary&q=proj%3Dfmt&can=1
+
+.. image:: https://img.shields.io/badge/stackoverflow-fmt-blue.svg
+   :alt: Ask questions at StackOverflow with the tag fmt
+   :target: https://stackoverflow.com/questions/tagged/fmt
+
+**{fmt}** is an open-source formatting library providing a fast and safe
+alternative to C stdio and C++ iostreams.
+
+If you like this project, please consider donating to the BYSOL
+Foundation that helps victims of political repressions in Belarus:
+https://bysol.org/en/bs/general/.
+
+`Documentation <https://fmt.dev>`__
+
+Q&A: ask questions on `StackOverflow with the tag fmt
+<https://stackoverflow.com/questions/tagged/fmt>`_.
+
+Try {fmt} in `Compiler Explorer <https://godbolt.org/z/Eq5763>`_.
+
+Features
+--------
+
+* Simple `format API <https://fmt.dev/latest/api.html>`_ with positional arguments
+  for localization
+* Implementation of `C++20 std::format
+  <https://en.cppreference.com/w/cpp/utility/format>`__
+* `Format string syntax <https://fmt.dev/latest/syntax.html>`_ similar to Python's
+  `format <https://docs.python.org/3/library/stdtypes.html#str.format>`_
+* Fast IEEE 754 floating-point formatter with correct rounding, shortness and
+  round-trip guarantees
+* Safe `printf implementation
+  <https://fmt.dev/latest/api.html#printf-formatting>`_ including the POSIX
+  extension for positional arguments
+* Extensibility: `support for user-defined types
+  <https://fmt.dev/latest/api.html#formatting-user-defined-types>`_
+* High performance: faster than common standard library implementations of
+  ``(s)printf``, iostreams, ``to_string`` and ``to_chars``, see `Speed tests`_
+  and `Converting a hundred million integers to strings per second
+  <http://www.zverovich.net/2020/06/13/fast-int-to-string-revisited.html>`_
+* Small code size both in terms of source code with the minimum configuration
+  consisting of just three files, ``core.h``, ``format.h`` and ``format-inl.h``,
+  and compiled code; see `Compile time and code bloat`_
+* Reliability: the library has an extensive set of `tests
+  <https://github.com/fmtlib/fmt/tree/master/test>`_ and is `continuously fuzzed
+  <https://bugs.chromium.org/p/oss-fuzz/issues/list?colspec=ID%20Type%20
+  Component%20Status%20Proj%20Reported%20Owner%20Summary&q=proj%3Dfmt&can=1>`_
+* Safety: the library is fully type safe, errors in format strings can be
+  reported at compile time, automatic memory management prevents buffer overflow
+  errors
+* Ease of use: small self-contained code base, no external dependencies,
+  permissive MIT `license
+  <https://github.com/fmtlib/fmt/blob/master/LICENSE.rst>`_
+* `Portability <https://fmt.dev/latest/index.html#portability>`_ with
+  consistent output across platforms and support for older compilers
+* Clean warning-free codebase even on high warning levels such as
+  ``-Wall -Wextra -pedantic``
+* Locale-independence by default
+* Optional header-only configuration enabled with the ``FMT_HEADER_ONLY`` macro
+
+See the `documentation <https://fmt.dev>`_ for more details.
+
+Examples
+--------
+
+**Print to stdout** (`run <https://godbolt.org/z/Tevcjh>`_)
+
+.. code:: c++
+
+    #include <fmt/core.h>
+    
+    int main() {
+      fmt::print("Hello, world!\n");
+    }
+
+**Format a string** (`run <https://godbolt.org/z/oK8h33>`_)
+
+.. code:: c++
+
+    std::string s = fmt::format("The answer is {}.", 42);
+    // s == "The answer is 42."
+
+**Format a string using positional arguments** (`run <https://godbolt.org/z/Yn7Txe>`_)
+
+.. code:: c++
+
+    std::string s = fmt::format("I'd rather be {1} than {0}.", "right", "happy");
+    // s == "I'd rather be happy than right."
+
+**Print chrono durations** (`run <https://godbolt.org/z/K8s4Mc>`_)
+
+.. code:: c++
+
+    #include <fmt/chrono.h>
+
+    int main() {
+      using namespace std::literals::chrono_literals;
+      fmt::print("Default format: {} {}\n", 42s, 100ms);
+      fmt::print("strftime-like format: {:%H:%M:%S}\n", 3h + 15min + 30s);
+    }
+
+Output::
+
+    Default format: 42s 100ms
+    strftime-like format: 03:15:30
+
+**Print a container** (`run <https://godbolt.org/z/MjsY7c>`_)
+
+.. code:: c++
+
+    #include <vector>
+    #include <fmt/ranges.h>
+
+    int main() {
+      std::vector<int> v = {1, 2, 3};
+      fmt::print("{}\n", v);
+    }
+
+Output::
+
+    [1, 2, 3]
+
+**Check a format string at compile time**
+
+.. code:: c++
+
+    std::string s = fmt::format("{:d}", "I am not a number");
+
+This gives a compile-time error in C++20 because ``d`` is an invalid format
+specifier for a string.
+
+**Write a file from a single thread**
+
+.. code:: c++
+
+    #include <fmt/os.h>
+
+    int main() {
+      auto out = fmt::output_file("guide.txt");
+      out.print("Don't {}", "Panic");
+    }
+
+This can be `5 to 9 times faster than fprintf
+<http://www.zverovich.net/2020/08/04/optimal-file-buffer-size.html>`_.
+
+**Print with colors and text styles**
+
+.. code:: c++
+
+    #include <fmt/color.h>
+
+    int main() {
+      fmt::print(fg(fmt::color::crimson) | fmt::emphasis::bold,
+                 "Hello, {}!\n", "world");
+      fmt::print(fg(fmt::color::floral_white) | bg(fmt::color::slate_gray) |
+                 fmt::emphasis::underline, "Hello, {}!\n", "мир");
+      fmt::print(fg(fmt::color::steel_blue) | fmt::emphasis::italic,
+                 "Hello, {}!\n", "世界");
+    }
+
+Output on a modern terminal:
+
+.. image:: https://user-images.githubusercontent.com/
+           576385/88485597-d312f600-cf2b-11ea-9cbe-61f535a86e28.png
+
+Benchmarks
+----------
+
+Speed tests
+~~~~~~~~~~~
+
+================= ============= ===========
+Library           Method        Run Time, s
+================= ============= ===========
+libc              printf          1.04
+libc++            std::ostream    3.05
+{fmt} 6.1.1       fmt::print      0.75
+Boost Format 1.67 boost::format   7.24
+Folly Format      folly::format   2.23
+================= ============= ===========
+
+{fmt} is the fastest of the benchmarked methods, ~35% faster than ``printf``.
+
+The above results were generated by building ``tinyformat_test.cpp`` on macOS
+10.14.6 with ``clang++ -O3 -DNDEBUG -DSPEED_TEST -DHAVE_FORMAT``, and taking the
+best of three runs. In the test, the format string ``"%0.10f:%04d:%+g:%s:%p:%c:%%\n"``
+or equivalent is filled 2,000,000 times with output sent to ``/dev/null``; for
+further details refer to the `source
+<https://github.com/fmtlib/format-benchmark/blob/master/src/tinyformat-test.cc>`_.
+
+{fmt} is up to 20-30x faster than ``std::ostringstream`` and ``sprintf`` on
+floating-point formatting (`dtoa-benchmark <https://github.com/fmtlib/dtoa-benchmark>`_)
+and faster than `double-conversion <https://github.com/google/double-conversion>`_ and
+`ryu <https://github.com/ulfjack/ryu>`_:
+
+.. image:: https://user-images.githubusercontent.com/576385/
+           95684665-11719600-0ba8-11eb-8e5b-972ff4e49428.png
+   :target: https://fmt.dev/unknown_mac64_clang12.0.html
+
+Compile time and code bloat
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The script `bloat-test.py
+<https://github.com/fmtlib/format-benchmark/blob/master/bloat-test.py>`_
+from `format-benchmark <https://github.com/fmtlib/format-benchmark>`_
+tests compile time and code bloat for nontrivial projects.
+It generates 100 translation units and uses ``printf()`` or its alternative
+five times in each to simulate a medium sized project.  The resulting
+executable size and compile time (Apple LLVM version 8.1.0 (clang-802.0.42),
+macOS Sierra, best of three) is shown in the following tables.
+
+**Optimized build (-O3)**
+
+============= =============== ==================== ==================
+Method        Compile Time, s Executable size, KiB Stripped size, KiB
+============= =============== ==================== ==================
+printf                    2.6                   29                 26
+printf+string            16.4                   29                 26
+iostreams                31.1                   59                 55
+{fmt}                    19.0                   37                 34
+Boost Format             91.9                  226                203
+Folly Format            115.7                  101                 88
+============= =============== ==================== ==================
+
+As you can see, {fmt} has 60% less overhead in terms of resulting binary code
+size compared to iostreams and comes pretty close to ``printf``. Boost Format
+and Folly Format have the largest overheads.
+
+``printf+string`` is the same as ``printf`` but with extra ``<string>``
+include to measure the overhead of the latter.
+
+**Non-optimized build**
+
+============= =============== ==================== ==================
+Method        Compile Time, s Executable size, KiB Stripped size, KiB
+============= =============== ==================== ==================
+printf                    2.2                   33                 30
+printf+string            16.0                   33                 30
+iostreams                28.3                   56                 52
+{fmt}                    18.2                   59                 50
+Boost Format             54.1                  365                303
+Folly Format             79.9                  445                430
+============= =============== ==================== ==================
+
+``libc``, ``lib(std)c++`` and ``libfmt`` are all linked as shared libraries to
+compare formatting function overhead only. Boost Format is a
+header-only library so it doesn't provide any linkage options.
+
+Running the tests
+~~~~~~~~~~~~~~~~~
+
+Please refer to `Building the library`__ for the instructions on how to build
+the library and run the unit tests.
+
+__ https://fmt.dev/latest/usage.html#building-the-library
+
+Benchmarks reside in a separate repository,
+`format-benchmarks <https://github.com/fmtlib/format-benchmark>`_,
+so to run the benchmarks you first need to clone this repository and
+generate Makefiles with CMake::
+
+    $ git clone --recursive https://github.com/fmtlib/format-benchmark.git
+    $ cd format-benchmark
+    $ cmake .
+
+Then you can run the speed test::
+
+    $ make speed-test
+
+or the bloat test::
+
+    $ make bloat-test
+    
+Migrating code
+--------------
+
+`clang-tidy-fmt <https://github.com/mikecrowe/clang-tidy-fmt>`_ provides clang
+tidy checks for converting occurrences of ``printf`` and ``fprintf`` to
+``fmt::print``.
+
+Projects using this library
+---------------------------
+
+* `0 A.D. <https://play0ad.com/>`_: a free, open-source, cross-platform
+  real-time strategy game
+
+* `2GIS <https://2gis.ru/>`_: free business listings with a city map
+
+* `AMPL/MP <https://github.com/ampl/mp>`_:
+  an open-source library for mathematical programming
+
+* `Aseprite <https://github.com/aseprite/aseprite>`_:
+  animated sprite editor & pixel art tool 
+
+* `AvioBook <https://www.aviobook.aero/en>`_: a comprehensive aircraft
+  operations suite
+  
+* `Blizzard Battle.net <https://battle.net/>`_: an online gaming platform
+  
+* `Celestia <https://celestia.space/>`_: real-time 3D visualization of space
+
+* `Ceph <https://ceph.com/>`_: a scalable distributed storage system
+
+* `ccache <https://ccache.dev/>`_: a compiler cache
+
+* `ClickHouse <https://github.com/ClickHouse/ClickHouse>`_: analytical database
+  management system
+
+* `CUAUV <https://cuauv.org/>`_: Cornell University's autonomous underwater
+  vehicle
+
+* `Drake <https://drake.mit.edu/>`_: a planning, control, and analysis toolbox
+  for nonlinear dynamical systems (MIT)
+
+* `Envoy <https://lyft.github.io/envoy/>`_: C++ L7 proxy and communication bus
+  (Lyft)
+
+* `FiveM <https://fivem.net/>`_: a modification framework for GTA V
+
+* `fmtlog <https://github.com/MengRao/fmtlog>`_: a performant fmtlib-style
+  logging library with latency in nanoseconds
+
+* `Folly <https://github.com/facebook/folly>`_: Facebook open-source library
+
+* `Grand Mountain Adventure
+  <https://store.steampowered.com/app/1247360/Grand_Mountain_Adventure/>`_:
+  A beautiful open-world ski & snowboarding game
+
+* `HarpyWar/pvpgn <https://github.com/pvpgn/pvpgn-server>`_:
+  Player vs Player Gaming Network with tweaks
+
+* `KBEngine <https://github.com/kbengine/kbengine>`_: an open-source MMOG server
+  engine
+
+* `Keypirinha <https://keypirinha.com/>`_: a semantic launcher for Windows
+
+* `Kodi <https://kodi.tv/>`_ (formerly xbmc): home theater software
+
+* `Knuth <https://kth.cash/>`_: high-performance Bitcoin full-node
+
+* `Microsoft Verona <https://github.com/microsoft/verona>`_:
+  research programming language for concurrent ownership
+
+* `MongoDB <https://mongodb.com/>`_: distributed document database
+
+* `MongoDB Smasher <https://github.com/duckie/mongo_smasher>`_: a small tool to
+  generate randomized datasets
+
+* `OpenSpace <https://openspaceproject.com/>`_: an open-source
+  astrovisualization framework
+
+* `PenUltima Online (POL) <https://www.polserver.com/>`_:
+  an MMO server, compatible with most Ultima Online clients
+
+* `PyTorch <https://github.com/pytorch/pytorch>`_: an open-source machine
+  learning library
+
+* `quasardb <https://www.quasardb.net/>`_: a distributed, high-performance,
+  associative database
+  
+* `Quill <https://github.com/odygrd/quill>`_: asynchronous low-latency logging library
+
+* `QKW <https://github.com/ravijanjam/qkw>`_: generalizing aliasing to simplify
+  navigation, and executing complex multi-line terminal command sequences
+
+* `redis-cerberus <https://github.com/HunanTV/redis-cerberus>`_: a Redis cluster
+  proxy
+
+* `redpanda <https://vectorized.io/redpanda>`_: a 10x faster Kafka® replacement
+  for mission critical systems written in C++
+
+* `rpclib <http://rpclib.net/>`_: a modern C++ msgpack-RPC server and client
+  library
+
+* `Salesforce Analytics Cloud
+  <https://www.salesforce.com/analytics-cloud/overview/>`_:
+  business intelligence software
+
+* `Scylla <https://www.scylladb.com/>`_: a Cassandra-compatible NoSQL data store
+  that can handle 1 million transactions per second on a single server
+
+* `Seastar <http://www.seastar-project.org/>`_: an advanced, open-source C++
+  framework for high-performance server applications on modern hardware
+
+* `spdlog <https://github.com/gabime/spdlog>`_: super fast C++ logging library
+
+* `Stellar <https://www.stellar.org/>`_: financial platform
+
+* `Touch Surgery <https://www.touchsurgery.com/>`_: surgery simulator
+
+* `TrinityCore <https://github.com/TrinityCore/TrinityCore>`_: open-source
+  MMORPG framework
+
+* `Windows Terminal <https://github.com/microsoft/terminal>`_: the new Windows
+  terminal
+
+`More... <https://github.com/search?q=fmtlib&type=Code>`_
+
+If you are aware of other projects using this library, please let me know
+by `email <mailto:victor.zverovich@gmail.com>`_ or by submitting an
+`issue <https://github.com/fmtlib/fmt/issues>`_.
+
+Motivation
+----------
+
+So why yet another formatting library?
+
+There are plenty of methods for doing this task, from standard ones like
+the printf family of function and iostreams to Boost Format and FastFormat
+libraries. The reason for creating a new library is that every existing
+solution that I found either had serious issues or didn't provide
+all the features I needed.
+
+printf
+~~~~~~
+
+The good thing about ``printf`` is that it is pretty fast and readily available
+being a part of the C standard library. The main drawback is that it
+doesn't support user-defined types. ``printf`` also has safety issues although
+they are somewhat mitigated with `__attribute__ ((format (printf, ...))
+<https://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html>`_ in GCC.
+There is a POSIX extension that adds positional arguments required for
+`i18n <https://en.wikipedia.org/wiki/Internationalization_and_localization>`_
+to ``printf`` but it is not a part of C99 and may not be available on some
+platforms.
+
+iostreams
+~~~~~~~~~
+
+The main issue with iostreams is best illustrated with an example:
+
+.. code:: c++
+
+    std::cout << std::setprecision(2) << std::fixed << 1.23456 << "\n";
+
+which is a lot of typing compared to printf:
+
+.. code:: c++
+
+    printf("%.2f\n", 1.23456);
+
+Matthew Wilson, the author of FastFormat, called this "chevron hell". iostreams
+don't support positional arguments by design.
+
+The good part is that iostreams support user-defined types and are safe although
+error handling is awkward.
+
+Boost Format
+~~~~~~~~~~~~
+
+This is a very powerful library which supports both ``printf``-like format
+strings and positional arguments. Its main drawback is performance. According to
+various benchmarks, it is much slower than other methods considered here. Boost
+Format also has excessive build times and severe code bloat issues (see
+`Benchmarks`_).
+
+FastFormat
+~~~~~~~~~~
+
+This is an interesting library which is fast, safe and has positional arguments.
+However, it has significant limitations, citing its author:
+
+    Three features that have no hope of being accommodated within the
+    current design are:
+
+    * Leading zeros (or any other non-space padding)
+    * Octal/hexadecimal encoding
+    * Runtime width/alignment specification
+
+It is also quite big and has a heavy dependency, STLSoft, which might be too
+restrictive for using it in some projects.
+
+Boost Spirit.Karma
+~~~~~~~~~~~~~~~~~~
+
+This is not really a formatting library but I decided to include it here for
+completeness. As iostreams, it suffers from the problem of mixing verbatim text
+with arguments. The library is pretty fast, but slower on integer formatting
+than ``fmt::format_to`` with format string compilation on Karma's own benchmark,
+see `Converting a hundred million integers to strings per second
+<http://www.zverovich.net/2020/06/13/fast-int-to-string-revisited.html>`_.
+
+License
+-------
+
+{fmt} is distributed under the MIT `license
+<https://github.com/fmtlib/fmt/blob/master/LICENSE.rst>`_.
+
+Documentation License
+---------------------
+
+The `Format String Syntax <https://fmt.dev/latest/syntax.html>`_
+section in the documentation is based on the one from Python `string module
+documentation <https://docs.python.org/3/library/string.html#module-string>`_.
+For this reason the documentation is distributed under the Python Software
+Foundation license available in `doc/python-license.txt
+<https://raw.github.com/fmtlib/fmt/master/doc/python-license.txt>`_.
+It only applies if you distribute the documentation of {fmt}.
+
+Maintainers
+-----------
+
+The {fmt} library is maintained by Victor Zverovich (`vitaut
+<https://github.com/vitaut>`_) and Jonathan Müller (`foonathan
+<https://github.com/foonathan>`_) with contributions from many other people.
+See `Contributors <https://github.com/fmtlib/fmt/graphs/contributors>`_ and
+`Releases <https://github.com/fmtlib/fmt/releases>`_ for some of the names.
+Let us know if your contribution is not listed or mentioned incorrectly and
+we'll make it right.

intern/atomic/tests/atomic_test.cc

@@ -423,6 +423,7 @@ TEST(atomic, atomic_fetch_and_and_uint32)
 
 /** \} */
 
+/* -------------------------------------------------------------------- */
 /** \name 32 bit signed int atomics
  * \{ */
 
@@ -559,6 +560,7 @@ TEST(atomic, atomic_fetch_and_and_int32)
 
 /** \} */
 
+/* -------------------------------------------------------------------- */
 /** \name 16 bit signed int atomics
  * \{ */
 
@@ -592,6 +594,9 @@ TEST(atomic, atomic_fetch_and_and_int16)
   }
 }
 
+/** \} */
+
+/* -------------------------------------------------------------------- */
 /** \name 8 bit unsigned int atomics
  * \{ */
 
@@ -638,6 +643,7 @@ TEST(atomic, atomic_fetch_and_and_int8)
 
 /** \} */
 
+/* -------------------------------------------------------------------- */
 /** \name char aliases
  * \{ */
 
@@ -661,6 +667,7 @@ TEST(atomic, atomic_fetch_and_and_char)
 
 /** \} */
 
+/* -------------------------------------------------------------------- */
 /** \name size_t aliases
  * \{ */
 
@@ -772,6 +779,7 @@ TEST(atomic, atomic_fetch_and_update_max_z)
 
 /** \} */
 
+/* -------------------------------------------------------------------- */
 /** \name unsigned int aliases
  * \{ */
 
@@ -867,6 +875,7 @@ TEST(atomic, atomic_cas_u)
 
 /** \} */
 
+/* -------------------------------------------------------------------- */
 /** \name pointer aliases
  * \{ */
 
@@ -885,6 +894,7 @@ TEST(atomic, atomic_cas_ptr)
 
 /** \} */
 
+/* -------------------------------------------------------------------- */
 /** \name floating point atomics
  * \{ */
 

intern/cycles/CMakeLists.txt

@@ -2,8 +2,12 @@
 # Copyright 2011-2022 Blender Foundation
 
 # Standalone or with Blender
-if(NOT WITH_BLENDER AND WITH_CYCLES_STANDALONE)
-  set(CYCLES_INSTALL_PATH ${CMAKE_INSTALL_PREFIX})
+if(NOT WITH_BLENDER)
+  if(WITH_CYCLES_STANDALONE OR NOT WITH_CYCLES_HYDRA_RENDER_DELEGATE)
+    set(CYCLES_INSTALL_PATH ${CMAKE_INSTALL_PREFIX})
+  else()
+    set(CYCLES_INSTALL_PATH ${CMAKE_INSTALL_PREFIX}/hdCycles/resources)
+  endif()
 else()
   set(WITH_CYCLES_BLENDER ON)
   # WINDOWS_PYTHON_DEBUG needs to write into the user addons folder since it will
@@ -335,6 +339,11 @@ if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_C_COMPILER_ID MATCHES "Clang")
   unset(_has_no_error_unused_macros)
 endif()
 
+if(WITH_CYCLES_HYDRA_RENDER_DELEGATE AND NOT WITH_USD)
+  message(STATUS "USD not found, disabling WITH_CYCLES_HYDRA_RENDER_DELEGATE")
+  set(WITH_CYCLES_HYDRA_RENDER_DELEGATE OFF)
+endif()
+
 if(WITH_CYCLES_CUDA_BINARIES AND (NOT WITH_CYCLES_CUBIN_COMPILER))
   if(MSVC)
     set(MAX_MSVC 1800)
@@ -395,6 +404,10 @@ if(WITH_GTESTS)
   add_subdirectory(test)
 endif()
 
-if(NOT WITH_BLENDER AND WITH_CYCLES_STANDALONE)
+if(WITH_CYCLES_HYDRA_RENDER_DELEGATE)
+  add_subdirectory(hydra)
+endif()
+
+if(NOT WITH_BLENDER)
   delayed_do_install(${CMAKE_BINARY_DIR}/bin)
 endif()

intern/cycles/app/CMakeLists.txt

@@ -22,6 +22,16 @@ set(LIBRARIES
   cycles_util
 )
 
+if(WITH_ALEMBIC)
+  add_definitions(-DWITH_ALEMBIC)
+  list(APPEND INC_SYS
+    ${ALEMBIC_INCLUDE_DIRS}
+  )
+  list(APPEND LIB
+    ${ALEMBIC_LIBRARIES}
+  )
+endif()
+
 if(WITH_CYCLES_OSL)
   list(APPEND LIBRARIES cycles_kernel_osl)
 endif()

intern/cycles/app/cycles_xml.cpp

@@ -9,6 +9,7 @@
 
 #include "graph/node_xml.h"
 
+#include "scene/alembic.h"
 #include "scene/background.h"
 #include "scene/camera.h"
 #include "scene/film.h"
@@ -192,6 +193,31 @@ static void xml_read_camera(XMLReadState &state, xml_node node)
   cam->update(state.scene);
 }
 
+/* Alembic */
+
+#ifdef WITH_ALEMBIC
+static void xml_read_alembic(XMLReadState &state, xml_node graph_node)
+{
+  AlembicProcedural *proc = state.scene->create_node<AlembicProcedural>();
+  xml_read_node(state, proc, graph_node);
+
+  for (xml_node node = graph_node.first_child(); node; node = node.next_sibling()) {
+    if (string_iequals(node.name(), "object")) {
+      string path;
+      if (xml_read_string(&path, node, "path")) {
+        ustring object_path(path, 0);
+        AlembicObject *object = static_cast<AlembicObject *>(
+            proc->get_or_create_object(object_path));
+
+        array<Node *> used_shaders = object->get_used_shaders();
+        used_shaders.push_back_slow(state.shader);
+        object->set_used_shaders(used_shaders);
+      }
+    }
+  }
+}
+#endif
+
 /* Shader */
 
 static void xml_read_shader_graph(XMLReadState &state, Shader *shader, xml_node graph_node)
@@ -647,6 +673,11 @@ static void xml_read_scene(XMLReadState &state, xml_node scene_node)
       if (xml_read_string(&src, node, "src"))
         xml_read_include(state, src);
     }
+#ifdef WITH_ALEMBIC
+    else if (string_iequals(node.name(), "alembic")) {
+      xml_read_alembic(state, node);
+    }
+#endif
     else
       fprintf(stderr, "Unknown node \"%s\".\n", node.name());
   }

intern/cycles/blender/addon/__init__.py

@@ -83,6 +83,17 @@ class CyclesRender(bpy.types.RenderEngine):
     # viewport render
     def view_update(self, context, depsgraph):
         if not self.session:
+            # When starting a new render session in viewport (by switching
+            # viewport to Rendered shading) unpause the render. The way to think
+            # of it is: artist requests render, so we start to render.
+            # Do it for both original and evaluated scene so that Cycles
+            # immediately reacts to un-paused render.
+            cscene = context.scene.cycles
+            cscene_eval = depsgraph.scene_eval.cycles
+            if cscene.preview_pause or cscene_eval.preview_pause:
+                cscene.preview_pause = False
+                cscene_eval.preview_pause = False
+
             engine.create(self, context.blend_data,
                           context.region, context.space_data, context.region_data)
 

intern/cycles/blender/addon/properties.py

@@ -216,7 +216,6 @@ enum_direct_light_sampling_type = (
 )
 
 def update_render_passes(self, context):
-    scene = context.scene
     view_layer = context.view_layer
     view_layer.update_render_passes()
 
@@ -349,8 +348,8 @@ class CyclesRenderSettings(bpy.types.PropertyGroup):
     scrambling_distance: FloatProperty(
         name="Scrambling Distance",
         default=1.0,
-        min=0.0, max=1.0,
-        description="Reduce randomization between pixels to improve GPU rendering performance, at the cost of possible rendering artifacts if set too low. Only works when not using adaptive sampling",
+        min=0.0, soft_max=1.0,
+        description="Reduce randomization between pixels to improve GPU rendering performance, at the cost of possible rendering artifacts if set too low",
     )
     preview_scrambling_distance: BoolProperty(
         name="Scrambling Distance viewport",
@@ -361,7 +360,7 @@ class CyclesRenderSettings(bpy.types.PropertyGroup):
     auto_scrambling_distance: BoolProperty(
         name="Automatic Scrambling Distance",
         default=False,
-        description="Automatically reduce the randomization between pixels to improve GPU rendering performance, at the cost of possible rendering artifacts. Only works when not using adaptive sampling",
+        description="Automatically reduce the randomization between pixels to improve GPU rendering performance, at the cost of possible rendering artifacts",
     )
 
     use_layer_samples: EnumProperty(
@@ -1353,7 +1352,7 @@ class CyclesPreferences(bpy.types.AddonPreferences):
         items=CyclesPreferences.get_device_types,
     )
 
-    devices: bpy.props.CollectionProperty(type=CyclesDeviceSettings)
+    devices: CollectionProperty(type=CyclesDeviceSettings)
 
     peer_memory: BoolProperty(
         name="Distribute memory across devices",
@@ -1481,7 +1480,7 @@ class CyclesPreferences(bpy.types.AddonPreferences):
                 col.label(text="and NVIDIA driver version 470 or newer", icon='BLANK1')
             elif device_type == 'HIP':
                 import sys
-                col.label(text="Requires discrete AMD GPU with RDNA architecture", icon='BLANK1')
+                col.label(text="Requires discrete AMD GPU with Vega architecture", icon='BLANK1')
                 if sys.platform[:3] == "win":
                     col.label(text="and AMD Radeon Pro 21.Q4 driver or newer", icon='BLANK1')
             elif device_type == 'METAL':

intern/cycles/blender/addon/ui.py

@@ -11,6 +11,7 @@ from bl_ui.utils import PresetPanel
 from bpy.types import Panel
 
 from bl_ui.properties_grease_pencil_common import GreasePencilSimplifyPanel
+from bl_ui.properties_render import draw_hair_settings
 from bl_ui.properties_view_layer import ViewLayerCryptomattePanel, ViewLayerAOVPanel
 
 class CyclesPresetPanel(PresetPanel, Panel):
@@ -288,11 +289,8 @@ class CYCLES_RENDER_PT_sampling_advanced(CyclesButtonsPanel, Panel):
         layout.separator()
 
         heading = layout.column(align=True, heading="Scrambling Distance")
-        heading.active = not (cscene.use_adaptive_sampling and cscene.use_preview_adaptive_sampling)
         heading.prop(cscene, "auto_scrambling_distance", text="Automatic")
-        sub = heading.row()
-        sub.active = not cscene.use_preview_adaptive_sampling
-        sub.prop(cscene, "preview_scrambling_distance", text="Viewport")
+        heading.prop(cscene, "preview_scrambling_distance", text="Viewport")
         heading.prop(cscene, "scrambling_distance", text="Multiplier")
 
         layout.separator()
@@ -355,6 +353,13 @@ class CYCLES_RENDER_PT_hair(CyclesButtonsPanel, Panel):
         if ccscene.shape == 'RIBBONS':
             col.prop(ccscene, "subdivisions", text="Curve Subdivisions")
 
+class CYCLES_RENDER_PT_hair_viewport_display(CyclesButtonsPanel, Panel):
+    bl_label = "Viewport Display"
+    bl_parent_id = "CYCLES_RENDER_PT_hair"
+    bl_options = {'DEFAULT_CLOSED'}
+
+    def draw(self, context):
+        draw_hair_settings(self, context)
 
 class CYCLES_RENDER_PT_volumes(CyclesButtonsPanel, Panel):
     bl_label = "Volumes"
@@ -1023,7 +1028,7 @@ class CYCLES_OBJECT_PT_motion_blur(CyclesButtonsPanel, Panel):
     def poll(cls, context):
         ob = context.object
         if CyclesButtonsPanel.poll(context) and ob:
-            if ob.type in {'MESH', 'CURVE', 'CURVE', 'SURFACE', 'FONT', 'META', 'CAMERA', 'HAIR', 'POINTCLOUD'}:
+            if ob.type in {'MESH', 'CURVE', 'CURVE', 'SURFACE', 'FONT', 'META', 'CAMERA', 'CURVES', 'POINTCLOUD'}:
                 return True
             if ob.instance_type == 'COLLECTION' and ob.instance_collection:
                 return True
@@ -1062,7 +1067,7 @@ class CYCLES_OBJECT_PT_motion_blur(CyclesButtonsPanel, Panel):
 
 
 def has_geometry_visibility(ob):
-    return ob and ((ob.type in {'MESH', 'CURVE', 'SURFACE', 'FONT', 'META', 'LIGHT', 'VOLUME', 'POINTCLOUD', 'HAIR'}) or
+    return ob and ((ob.type in {'MESH', 'CURVE', 'SURFACE', 'FONT', 'META', 'LIGHT', 'VOLUME', 'POINTCLOUD', 'CURVES'}) or
                    (ob.instance_type == 'COLLECTION' and ob.instance_collection))
 
 
@@ -2153,6 +2158,7 @@ classes = (
     CYCLES_RENDER_PT_volumes,
     CYCLES_RENDER_PT_subdivision,
     CYCLES_RENDER_PT_hair,
+    CYCLES_RENDER_PT_hair_viewport_display,
     CYCLES_RENDER_PT_simplify,
     CYCLES_RENDER_PT_simplify_viewport,
     CYCLES_RENDER_PT_simplify_render,

intern/cycles/blender/addon/version_update.py

@@ -5,7 +5,6 @@
 from __future__ import annotations
 
 import bpy
-import math
 
 from bpy.app.handlers import persistent
 

intern/cycles/blender/object.cpp

@@ -319,7 +319,9 @@ Object *BlenderSync::sync_object(BL::Depsgraph &b_depsgraph,
       (object->get_geometry() && object->get_geometry()->is_modified())) {
     object->name = b_ob.name().c_str();
     object->set_pass_id(b_ob.pass_index());
-    object->set_color(get_float3(b_ob.color()));
+    const BL::Array<float, 4> object_color = b_ob.color();
+    object->set_color(get_float3(object_color));
+    object->set_alpha(object_color[3]);
     object->set_tfm(tfm);
 
     /* dupli texture coordinates and random_id */
@@ -420,7 +422,7 @@ static float4 lookup_instance_property(BL::DepsgraphObjectInstance &b_instance,
     return value;
   }
 
-  return make_float4(0.0f);
+  return zero_float4();
 }
 
 bool BlenderSync::sync_object_attributes(BL::DepsgraphObjectInstance &b_instance, Object *object)

intern/cycles/blender/shader.cpp

@@ -271,6 +271,7 @@ static ShaderNode *add_node(Scene *scene,
     curves->set_min_x(min_x);
     curves->set_max_x(max_x);
     curves->set_curves(curve_mapping_curves);
+    curves->set_extrapolate(mapping.extend() == mapping.extend_EXTRAPOLATED);
     node = curves;
   }
   if (b_node.is_a(&RNA_ShaderNodeVectorCurve)) {
@@ -284,6 +285,7 @@ static ShaderNode *add_node(Scene *scene,
     curves->set_min_x(min_x);
     curves->set_max_x(max_x);
     curves->set_curves(curve_mapping_curves);
+    curves->set_extrapolate(mapping.extend() == mapping.extend_EXTRAPOLATED);
     node = curves;
   }
   else if (b_node.is_a(&RNA_ShaderNodeFloatCurve)) {
@@ -297,6 +299,7 @@ static ShaderNode *add_node(Scene *scene,
     curve->set_min_x(min_x);
     curve->set_max_x(max_x);
     curve->set_curve(curve_mapping_curve);
+    curve->set_extrapolate(mapping.extend() == mapping.extend_EXTRAPOLATED);
     node = curve;
   }
   else if (b_node.is_a(&RNA_ShaderNodeValToRGB)) {

intern/cycles/blender/sync.cpp

@@ -346,31 +346,48 @@ void BlenderSync::sync_integrator(BL::ViewLayer &b_view_layer, bool background)
       cscene, "sampling_pattern", SAMPLING_NUM_PATTERNS, SAMPLING_PATTERN_SOBOL);
   integrator->set_sampling_pattern(sampling_pattern);
 
+  int samples = 1;
   bool use_adaptive_sampling = false;
   if (preview) {
+    samples = get_int(cscene, "preview_samples");
     use_adaptive_sampling = RNA_boolean_get(&cscene, "use_preview_adaptive_sampling");
     integrator->set_use_adaptive_sampling(use_adaptive_sampling);
     integrator->set_adaptive_threshold(get_float(cscene, "preview_adaptive_threshold"));
     integrator->set_adaptive_min_samples(get_int(cscene, "preview_adaptive_min_samples"));
   }
   else {
+    samples = get_int(cscene, "samples");
     use_adaptive_sampling = RNA_boolean_get(&cscene, "use_adaptive_sampling");
     integrator->set_use_adaptive_sampling(use_adaptive_sampling);
     integrator->set_adaptive_threshold(get_float(cscene, "adaptive_threshold"));
     integrator->set_adaptive_min_samples(get_int(cscene, "adaptive_min_samples"));
   }
 
-  int samples = get_int(cscene, "samples");
   float scrambling_distance = get_float(cscene, "scrambling_distance");
   bool auto_scrambling_distance = get_boolean(cscene, "auto_scrambling_distance");
   if (auto_scrambling_distance) {
+    if (samples == 0) {
+      /* If samples is 0, then viewport rendering is set to render infinitely. In that case we
+       * override the samples value with 4096 so the Automatic Scrambling Distance algorithm
+       * picks a Scrambling Distance value with a good balance of performance and correlation
+       * artifacts when rendering to high sample counts. */
+      samples = 4096;
+    }
+
+    if (use_adaptive_sampling) {
+      /* If Adaptive Sampling is enabled, use "min_samples" in the Automatic Scrambling Distance
+       * algorithm to avoid artifacts common with Adaptive Sampling + Scrambling Distance. */
+      const AdaptiveSampling adaptive_sampling = integrator->get_adaptive_sampling();
+      samples = min(samples, adaptive_sampling.min_samples);
+    }
     scrambling_distance *= 4.0f / sqrtf(samples);
   }
 
-  /* only use scrambling distance in the viewport if user wants to and disable with AS */
+  /* Only use scrambling distance in the viewport if user wants to. */
   bool preview_scrambling_distance = get_boolean(cscene, "preview_scrambling_distance");
-  if ((preview && !preview_scrambling_distance) || use_adaptive_sampling)
+  if (preview && !preview_scrambling_distance) {
     scrambling_distance = 1.0f;
+  }
 
   if (scrambling_distance != 1.0f) {
     VLOG(3) << "Using scrambling distance: " << scrambling_distance;

intern/cycles/bvh/binning.cpp

@@ -203,7 +203,7 @@ BVHObjectBinning::BVHObjectBinning(const BVHRange &job,
     bestSAH = min(sah, bestSAH);
   }
 
-  int4 mask = float3_to_float4(cent_bounds_.size()) <= make_float4(0.0f);
+  int4 mask = float3_to_float4(cent_bounds_.size()) <= zero_float4();
   bestSAH = insert<3>(select(mask, make_float4(FLT_MAX), bestSAH), FLT_MAX);
 
   /* find best dimension */

intern/cycles/cmake/macros.cmake

@@ -101,6 +101,7 @@ macro(cycles_target_link_libraries target)
     ${PNG_LIBRARIES}
     ${JPEG_LIBRARIES}
     ${TIFF_LIBRARY}
+    ${WEBP_LIBRARIES}
     ${OPENJPEG_LIBRARIES}
     ${OPENEXR_LIBRARIES}
     ${OPENEXR_LIBRARIES} # For circular dependencies between libs.

intern/cycles/device/CMakeLists.txt

@@ -197,7 +197,8 @@ cycles_add_library(cycles_device "${LIB}" ${SRC})
 source_group("cpu" FILES ${SRC_CPU})
 source_group("cuda" FILES ${SRC_CUDA})
 source_group("dummy" FILES ${SRC_DUMMY})
+source_group("hip" FILES ${SRC_HIP})
 source_group("multi" FILES ${SRC_MULTI})
 source_group("metal" FILES ${SRC_METAL})
 source_group("optix" FILES ${SRC_OPTIX})
-source_group("common" FILES ${SRC} ${SRC_HEADERS})
+source_group("common" FILES ${SRC_BASE} ${SRC_HEADERS})

intern/cycles/device/hip/util.h

@@ -51,7 +51,7 @@ static inline bool hipSupportsDevice(const int hipDevId)
   hipDeviceGetAttribute(&major, hipDeviceAttributeComputeCapabilityMajor, hipDevId);
   hipDeviceGetAttribute(&minor, hipDeviceAttributeComputeCapabilityMinor, hipDevId);
 
-  return (major > 10) || (major == 10 && minor >= 1);
+  return (major >= 9);
 }
 
 CCL_NAMESPACE_END

intern/cycles/device/optix/device_impl.cpp

@@ -33,6 +33,191 @@
 
 CCL_NAMESPACE_BEGIN
 
+// A minimal copy of functionality `optix_denoiser_tiling.h` which allows to fix integer overflow
+// issues without bumping SDK or driver requirement.
+//
+// The original code is Copyright NVIDIA Corporation, BSD-3-Clause.
+namespace {
+
+static OptixResult optixUtilDenoiserSplitImage(const OptixImage2D &input,
+                                               const OptixImage2D &output,
+                                               unsigned int overlapWindowSizeInPixels,
+                                               unsigned int tileWidth,
+                                               unsigned int tileHeight,
+                                               std::vector<OptixUtilDenoiserImageTile> &tiles)
+{
+  if (tileWidth == 0 || tileHeight == 0)
+    return OPTIX_ERROR_INVALID_VALUE;
+
+  unsigned int inPixelStride = optixUtilGetPixelStride(input);
+  unsigned int outPixelStride = optixUtilGetPixelStride(output);
+
+  int inp_w = std::min(tileWidth + 2 * overlapWindowSizeInPixels, input.width);
+  int inp_h = std::min(tileHeight + 2 * overlapWindowSizeInPixels, input.height);
+  int inp_y = 0, copied_y = 0;
+
+  do {
+    int inputOffsetY = inp_y == 0 ? 0 :
+                                    std::max((int)overlapWindowSizeInPixels,
+                                             inp_h - ((int)input.height - inp_y));
+    int copy_y = inp_y == 0 ? std::min(input.height, tileHeight + overlapWindowSizeInPixels) :
+                              std::min(tileHeight, input.height - copied_y);
+
+    int inp_x = 0, copied_x = 0;
+    do {
+      int inputOffsetX = inp_x == 0 ? 0 :
+                                      std::max((int)overlapWindowSizeInPixels,
+                                               inp_w - ((int)input.width - inp_x));
+      int copy_x = inp_x == 0 ? std::min(input.width, tileWidth + overlapWindowSizeInPixels) :
+                                std::min(tileWidth, input.width - copied_x);
+
+      OptixUtilDenoiserImageTile tile;
+      tile.input.data = input.data + (size_t)(inp_y - inputOffsetY) * input.rowStrideInBytes +
+                        +(size_t)(inp_x - inputOffsetX) * inPixelStride;
+      tile.input.width = inp_w;
+      tile.input.height = inp_h;
+      tile.input.rowStrideInBytes = input.rowStrideInBytes;
+      tile.input.pixelStrideInBytes = input.pixelStrideInBytes;
+      tile.input.format = input.format;
+
+      tile.output.data = output.data + (size_t)inp_y * output.rowStrideInBytes +
+                         (size_t)inp_x * outPixelStride;
+      tile.output.width = copy_x;
+      tile.output.height = copy_y;
+      tile.output.rowStrideInBytes = output.rowStrideInBytes;
+      tile.output.pixelStrideInBytes = output.pixelStrideInBytes;
+      tile.output.format = output.format;
+
+      tile.inputOffsetX = inputOffsetX;
+      tile.inputOffsetY = inputOffsetY;
+      tiles.push_back(tile);
+
+      inp_x += inp_x == 0 ? tileWidth + overlapWindowSizeInPixels : tileWidth;
+      copied_x += copy_x;
+    } while (inp_x < static_cast<int>(input.width));
+
+    inp_y += inp_y == 0 ? tileHeight + overlapWindowSizeInPixels : tileHeight;
+    copied_y += copy_y;
+  } while (inp_y < static_cast<int>(input.height));
+
+  return OPTIX_SUCCESS;
+}
+
+static OptixResult optixUtilDenoiserInvokeTiled(OptixDenoiser denoiser,
+                                                CUstream stream,
+                                                const OptixDenoiserParams *params,
+                                                CUdeviceptr denoiserState,
+                                                size_t denoiserStateSizeInBytes,
+                                                const OptixDenoiserGuideLayer *guideLayer,
+                                                const OptixDenoiserLayer *layers,
+                                                unsigned int numLayers,
+                                                CUdeviceptr scratch,
+                                                size_t scratchSizeInBytes,
+                                                unsigned int overlapWindowSizeInPixels,
+                                                unsigned int tileWidth,
+                                                unsigned int tileHeight)
+{
+  if (!guideLayer || !layers)
+    return OPTIX_ERROR_INVALID_VALUE;
+
+  std::vector<std::vector<OptixUtilDenoiserImageTile>> tiles(numLayers);
+  std::vector<std::vector<OptixUtilDenoiserImageTile>> prevTiles(numLayers);
+  for (unsigned int l = 0; l < numLayers; l++) {
+    if (const OptixResult res = ccl::optixUtilDenoiserSplitImage(layers[l].input,
+                                                                 layers[l].output,
+                                                                 overlapWindowSizeInPixels,
+                                                                 tileWidth,
+                                                                 tileHeight,
+                                                                 tiles[l]))
+      return res;
+
+    if (layers[l].previousOutput.data) {
+      OptixImage2D dummyOutput = layers[l].previousOutput;
+      if (const OptixResult res = ccl::optixUtilDenoiserSplitImage(layers[l].previousOutput,
+                                                                   dummyOutput,
+                                                                   overlapWindowSizeInPixels,
+                                                                   tileWidth,
+                                                                   tileHeight,
+                                                                   prevTiles[l]))
+        return res;
+    }
+  }
+
+  std::vector<OptixUtilDenoiserImageTile> albedoTiles;
+  if (guideLayer->albedo.data) {
+    OptixImage2D dummyOutput = guideLayer->albedo;
+    if (const OptixResult res = ccl::optixUtilDenoiserSplitImage(guideLayer->albedo,
+                                                                 dummyOutput,
+                                                                 overlapWindowSizeInPixels,
+                                                                 tileWidth,
+                                                                 tileHeight,
+                                                                 albedoTiles))
+      return res;
+  }
+
+  std::vector<OptixUtilDenoiserImageTile> normalTiles;
+  if (guideLayer->normal.data) {
+    OptixImage2D dummyOutput = guideLayer->normal;
+    if (const OptixResult res = ccl::optixUtilDenoiserSplitImage(guideLayer->normal,
+                                                                 dummyOutput,
+                                                                 overlapWindowSizeInPixels,
+                                                                 tileWidth,
+                                                                 tileHeight,
+                                                                 normalTiles))
+      return res;
+  }
+  std::vector<OptixUtilDenoiserImageTile> flowTiles;
+  if (guideLayer->flow.data) {
+    OptixImage2D dummyOutput = guideLayer->flow;
+    if (const OptixResult res = ccl::optixUtilDenoiserSplitImage(guideLayer->flow,
+                                                                 dummyOutput,
+                                                                 overlapWindowSizeInPixels,
+                                                                 tileWidth,
+                                                                 tileHeight,
+                                                                 flowTiles))
+      return res;
+  }
+
+  for (size_t t = 0; t < tiles[0].size(); t++) {
+    std::vector<OptixDenoiserLayer> tlayers;
+    for (unsigned int l = 0; l < numLayers; l++) {
+      OptixDenoiserLayer layer = {};
+      layer.input = (tiles[l])[t].input;
+      layer.output = (tiles[l])[t].output;
+      if (layers[l].previousOutput.data)
+        layer.previousOutput = (prevTiles[l])[t].input;
+      tlayers.push_back(layer);
+    }
+
+    OptixDenoiserGuideLayer gl = {};
+    if (guideLayer->albedo.data)
+      gl.albedo = albedoTiles[t].input;
+
+    if (guideLayer->normal.data)
+      gl.normal = normalTiles[t].input;
+
+    if (guideLayer->flow.data)
+      gl.flow = flowTiles[t].input;
+
+    if (const OptixResult res = optixDenoiserInvoke(denoiser,
+                                                    stream,
+                                                    params,
+                                                    denoiserState,
+                                                    denoiserStateSizeInBytes,
+                                                    &gl,
+                                                    &tlayers[0],
+                                                    numLayers,
+                                                    (tiles[0])[t].inputOffsetX,
+                                                    (tiles[0])[t].inputOffsetY,
+                                                    scratch,
+                                                    scratchSizeInBytes))
+      return res;
+  }
+  return OPTIX_SUCCESS;
+}
+
+}  // namespace
+
 OptiXDevice::Denoiser::Denoiser(OptiXDevice *device)
     : device(device), queue(device), state(device, "__denoiser_state", true)
 {
@@ -1075,20 +1260,20 @@ bool OptiXDevice::denoise_run(DenoiseContext &context, const DenoisePass &pass)
   /* Finally run denoising. */
   OptixDenoiserParams params = {}; /* All parameters are disabled/zero. */
 
-  optix_assert(optixUtilDenoiserInvokeTiled(denoiser_.optix_denoiser,
-                                            denoiser_.queue.stream(),
-                                            &params,
-                                            denoiser_.state.device_pointer,
-                                            denoiser_.sizes.stateSizeInBytes,
-                                            &guide_layers,
-                                            &image_layers,
-                                            1,
-                                            denoiser_.state.device_pointer +
-                                                denoiser_.sizes.stateSizeInBytes,
-                                            denoiser_.sizes.withOverlapScratchSizeInBytes,
-                                            denoiser_.sizes.overlapWindowSizeInPixels,
-                                            denoiser_.configured_size.x,
-                                            denoiser_.configured_size.y));
+  optix_assert(ccl::optixUtilDenoiserInvokeTiled(denoiser_.optix_denoiser,
+                                                 denoiser_.queue.stream(),
+                                                 &params,
+                                                 denoiser_.state.device_pointer,
+                                                 denoiser_.sizes.stateSizeInBytes,
+                                                 &guide_layers,
+                                                 &image_layers,
+                                                 1,
+                                                 denoiser_.state.device_pointer +
+                                                     denoiser_.sizes.stateSizeInBytes,
+                                                 denoiser_.sizes.withOverlapScratchSizeInBytes,
+                                                 denoiser_.sizes.overlapWindowSizeInPixels,
+                                                 denoiser_.configured_size.x,
+                                                 denoiser_.configured_size.y));
 
   return true;
 }

intern/cycles/device/queue.h

@@ -100,7 +100,7 @@ class DeviceQueue {
    * based on number of cores and/or available memory. */
   virtual int num_concurrent_states(const size_t state_size) const = 0;
 
-  /* Number of states which keeps the device occupied with work without loosing performance.
+  /* Number of states which keeps the device occupied with work without losing performance.
    * The renderer will add more work (when available) when number of active paths falls below this
    * value. */
   virtual int num_concurrent_busy_states() const = 0;

intern/cycles/hydra/CMakeLists.txt

@@ -0,0 +1,174 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2022 Blender Foundation
+
+#####################################################################
+# Cycles Hydra render delegate
+#####################################################################
+
+set(INC
+  ..
+)
+set(INC_SYS
+  ${USD_INCLUDE_DIRS}
+  ${GLEW_INCLUDE_DIR}
+)
+
+set(INC_HD_CYCLES
+  attribute.h
+  camera.h
+  config.h
+  curves.h
+  display_driver.h
+  field.h
+  geometry.h
+  geometry.inl
+  instancer.h
+  light.h
+  material.h
+  mesh.h
+  node_util.h
+  output_driver.h
+  pointcloud.h
+  render_buffer.h
+  render_delegate.h
+  render_pass.h
+  session.h
+  volume.h
+)
+
+set(SRC_HD_CYCLES
+  attribute.cpp
+  curves.cpp
+  camera.cpp
+  display_driver.cpp
+  field.cpp
+  instancer.cpp
+  light.cpp
+  material.cpp
+  mesh.cpp
+  node_util.cpp
+  output_driver.cpp
+  pointcloud.cpp
+  render_buffer.cpp
+  render_delegate.cpp
+  render_pass.cpp
+  session.cpp
+  volume.cpp
+)
+
+add_definitions(${GL_DEFINITIONS})
+
+if(WITH_OPENVDB)
+  add_definitions(-DWITH_OPENVDB ${OPENVDB_DEFINITIONS})
+  list(APPEND INC_SYS
+    ${OPENVDB_INCLUDE_DIRS}
+  )
+  list(APPEND LIB
+    ${OPENVDB_LIBRARIES}
+  )
+endif()
+
+include_directories(${INC})
+include_directories(SYSTEM ${INC_SYS})
+
+add_library(hdCyclesStatic STATIC
+  ${SRC_HD_CYCLES}
+  ${INC_HD_CYCLES}
+)
+
+target_compile_options(hdCyclesStatic
+  PRIVATE
+  $<$<CXX_COMPILER_ID:MSVC>:/wd4003 /wd4244 /wd4506>
+  $<$<CXX_COMPILER_ID:GNU>:-Wno-float-conversion -Wno-double-promotion -Wno-deprecated>
+)
+
+target_compile_definitions(hdCyclesStatic
+  PRIVATE
+  GLOG_NO_ABBREVIATED_SEVERITIES=1
+  OSL_DEBUG=$<CONFIG:DEBUG>
+  TBB_USE_DEBUG=$<CONFIG:DEBUG>
+  $<$<CXX_COMPILER_ID:MSVC>:NOMINMAX=1>
+)
+
+target_link_libraries(hdCyclesStatic
+  PRIVATE
+  ${USD_LIBRARY_DIR}/${PXR_LIB_PREFIX}hd${CMAKE_LINK_LIBRARY_SUFFIX}
+  ${USD_LIBRARY_DIR}/${PXR_LIB_PREFIX}plug${CMAKE_LINK_LIBRARY_SUFFIX}
+  ${USD_LIBRARY_DIR}/${PXR_LIB_PREFIX}tf${CMAKE_LINK_LIBRARY_SUFFIX}
+  ${USD_LIBRARY_DIR}/${PXR_LIB_PREFIX}trace${CMAKE_LINK_LIBRARY_SUFFIX}
+  ${USD_LIBRARY_DIR}/${PXR_LIB_PREFIX}vt${CMAKE_LINK_LIBRARY_SUFFIX}
+  ${USD_LIBRARY_DIR}/${PXR_LIB_PREFIX}work${CMAKE_LINK_LIBRARY_SUFFIX}
+  ${USD_LIBRARY_DIR}/${PXR_LIB_PREFIX}sdf${CMAKE_LINK_LIBRARY_SUFFIX}
+  ${USD_LIBRARY_DIR}/${PXR_LIB_PREFIX}cameraUtil${CMAKE_LINK_LIBRARY_SUFFIX}
+  ${USD_LIBRARY_DIR}/${PXR_LIB_PREFIX}hf${CMAKE_LINK_LIBRARY_SUFFIX}
+  ${USD_LIBRARY_DIR}/${PXR_LIB_PREFIX}pxOsd${CMAKE_LINK_LIBRARY_SUFFIX}
+  ${USD_LIBRARY_DIR}/${PXR_LIB_PREFIX}gf${CMAKE_LINK_LIBRARY_SUFFIX}
+  ${USD_LIBRARY_DIR}/${PXR_LIB_PREFIX}arch${CMAKE_LINK_LIBRARY_SUFFIX}
+  ${USD_LIBRARY_DIR}/${PXR_LIB_PREFIX}hgi${CMAKE_LINK_LIBRARY_SUFFIX}
+  ${USD_LIBRARY_DIR}/${PXR_LIB_PREFIX}glf${CMAKE_LINK_LIBRARY_SUFFIX}
+  ${USD_LIBRARY_DIR}/${PXR_LIB_PREFIX}hdx${CMAKE_LINK_LIBRARY_SUFFIX}
+  ${USD_LIBRARY_DIR}/${PXR_LIB_PREFIX}usdGeom${CMAKE_LINK_LIBRARY_SUFFIX}
+  cycles_scene
+  cycles_session
+  cycles_graph
+)
+
+if(USD_PYTHON_LIBRARIES)
+  target_link_libraries(hdCyclesStatic
+    PRIVATE
+    ${USD_PYTHON_LIBRARIES}
+  )
+endif()
+
+set(HdCyclesPluginName hdCycles)
+add_library(${HdCyclesPluginName} SHARED
+  plugin.h
+  plugin.cpp
+)
+
+set_target_properties(${HdCyclesPluginName}
+  PROPERTIES PREFIX ""
+)
+
+target_compile_definitions(${HdCyclesPluginName}
+  PRIVATE
+  MFB_PACKAGE_NAME=${HdCyclesPluginName}
+  MFB_ALT_PACKAGE_NAME=${HdCyclesPluginName}
+  GLOG_NO_ABBREVIATED_SEVERITIES=1
+  OSL_DEBUG=$<CONFIG:DEBUG>
+  TBB_USE_DEBUG=$<CONFIG:DEBUG>
+  $<$<CXX_COMPILER_ID:MSVC>:NOMINMAX=1>
+)
+
+target_link_libraries(${HdCyclesPluginName}
+  hdCyclesStatic
+)
+
+target_link_directories(${HdCyclesPluginName}
+  BEFORE
+  PRIVATE
+  ${USD_LIBRARY_DIR}
+)
+
+cycles_target_link_libraries(${HdCyclesPluginName})
+
+if(WITH_CYCLES_BLENDER)
+  set(CYCLES_HYDRA_INSTALL_PATH "../")
+else()
+  set(CYCLES_HYDRA_INSTALL_PATH ${CMAKE_INSTALL_PREFIX})
+  # Put the root plugInfo.json one level up
+  delayed_install("${CMAKE_CURRENT_SOURCE_DIR}" "plugInfo.json" ${CMAKE_INSTALL_PREFIX})
+endif()
+
+delayed_install("" $<TARGET_FILE:${HdCyclesPluginName}> ${CYCLES_HYDRA_INSTALL_PATH})
+
+set(PLUG_INFO_ROOT          "..")
+set(PLUG_INFO_LIBRARY_PATH  "../${HdCyclesPluginName}${CMAKE_SHARED_LIBRARY_SUFFIX}")
+set(PLUG_INFO_RESOURCE_PATH "resources")
+
+configure_file(resources/plugInfo.json
+  ${CMAKE_CURRENT_BINARY_DIR}/resources/plugInfo.json
+  @ONLY
+)
+
+delayed_install("${CMAKE_CURRENT_BINARY_DIR}/resources" "plugInfo.json" "${CYCLES_HYDRA_INSTALL_PATH}/${HdCyclesPluginName}/resources")

intern/cycles/hydra/attribute.cpp

@@ -0,0 +1,71 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#include "hydra/attribute.h"
+#include "scene/attribute.h"
+#include "scene/geometry.h"
+#include "scene/scene.h"
+
+#include <pxr/base/gf/vec2f.h>
+#include <pxr/base/gf/vec3f.h>
+#include <pxr/base/gf/vec4f.h>
+#include <pxr/base/vt/array.h>
+#include <pxr/imaging/hd/tokens.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+void ApplyPrimvars(AttributeSet &attributes,
+                   const ustring &name,
+                   VtValue value,
+                   AttributeElement elem,
+                   AttributeStandard std)
+{
+  const void *data = HdGetValueData(value);
+  size_t size = value.GetArraySize();
+
+  const HdType valueType = HdGetValueTupleType(value).type;
+
+  TypeDesc attrType = CCL_NS::TypeUnknown;
+  switch (valueType) {
+    case HdTypeFloat:
+      attrType = CCL_NS::TypeFloat;
+      size *= sizeof(float);
+      break;
+    case HdTypeFloatVec2:
+      attrType = CCL_NS::TypeFloat2;
+      size *= sizeof(float2);
+      static_assert(sizeof(GfVec2f) == sizeof(float2));
+      break;
+    case HdTypeFloatVec3: {
+      attrType = CCL_NS::TypeVector;
+      size *= sizeof(float3);
+      // The Cycles "float3" data type is padded to "float4", so need to convert the array
+      const auto &valueData = value.Get<VtVec3fArray>();
+      VtArray<float3> valueConverted;
+      valueConverted.reserve(valueData.size());
+      for (const GfVec3f &vec : valueData) {
+        valueConverted.push_back(make_float3(vec[0], vec[1], vec[2]));
+      }
+      data = valueConverted.data();
+      value = std::move(valueConverted);
+      break;
+    }
+    case HdTypeFloatVec4:
+      attrType = CCL_NS::TypeFloat4;
+      size *= sizeof(float4);
+      static_assert(sizeof(GfVec4f) == sizeof(float4));
+      break;
+    default:
+      TF_WARN("Unsupported attribute type %d", static_cast<int>(valueType));
+      return;
+  }
+
+  Attribute *const attr = attributes.add(name, attrType, elem);
+  attr->std = std;
+
+  assert(size == attr->buffer.size());
+  std::memcpy(attr->data(), data, size);
+}
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/attribute.h

@@ -0,0 +1,21 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#pragma once
+
+#include "hydra/config.h"
+#include "scene/attribute.h"
+
+#include <pxr/base/vt/value.h>
+#include <pxr/imaging/hd/types.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+void ApplyPrimvars(CCL_NS::AttributeSet &attributes,
+                   const CCL_NS::ustring &name,
+                   PXR_NS::VtValue value,
+                   CCL_NS::AttributeElement elem,
+                   CCL_NS::AttributeStandard std);
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/camera.cpp

@@ -0,0 +1,297 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#include "hydra/camera.h"
+#include "scene/camera.h"
+
+#include <pxr/base/gf/frustum.h>
+#include <pxr/imaging/hd/sceneDelegate.h>
+#include <pxr/usd/usdGeom/tokens.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+extern Transform convert_transform(const GfMatrix4d &matrix);
+
+HdCyclesCamera::HdCyclesCamera(const SdfPath &sprimId) : HdCamera(sprimId)
+{
+#if PXR_VERSION >= 2102
+  // Synchronize default values
+  _horizontalAperture = _data.GetHorizontalAperture() * GfCamera::APERTURE_UNIT;
+  _verticalAperture = _data.GetVerticalAperture() * GfCamera::APERTURE_UNIT;
+  _horizontalApertureOffset = _data.GetHorizontalApertureOffset() * GfCamera::APERTURE_UNIT;
+  _verticalApertureOffset = _data.GetVerticalApertureOffset() * GfCamera::APERTURE_UNIT;
+  _focalLength = _data.GetFocalLength() * GfCamera::FOCAL_LENGTH_UNIT;
+  _clippingRange = _data.GetClippingRange();
+  _fStop = _data.GetFStop();
+  _focusDistance = _data.GetFocusDistance();
+#endif
+}
+
+HdCyclesCamera::~HdCyclesCamera()
+{
+}
+
+HdDirtyBits HdCyclesCamera::GetInitialDirtyBitsMask() const
+{
+  return DirtyBits::AllDirty;
+}
+
+void HdCyclesCamera::Sync(HdSceneDelegate *sceneDelegate,
+                          HdRenderParam *renderParam,
+                          HdDirtyBits *dirtyBits)
+{
+  if (*dirtyBits == DirtyBits::Clean) {
+    return;
+  }
+
+  VtValue value;
+  const SdfPath &id = GetId();
+
+#if PXR_VERSION >= 2102
+  if (*dirtyBits & DirtyBits::DirtyTransform) {
+    sceneDelegate->SampleTransform(id, &_transformSamples);
+
+    for (size_t i = 0; i < _transformSamples.count; ++i) {
+      if (_transformSamples.times[i] == 0.0f) {
+        _transform = _transformSamples.values[i];
+        _data.SetTransform(_transform);
+        break;
+      }
+    }
+  }
+#else
+  if (*dirtyBits & DirtyBits::DirtyViewMatrix) {
+    sceneDelegate->SampleTransform(id, &_transformSamples);
+
+    value = sceneDelegate->GetCameraParamValue(id, HdCameraTokens->worldToViewMatrix);
+    if (!value.IsEmpty()) {
+      _worldToViewMatrix = value.Get<GfMatrix4d>();
+      _worldToViewInverseMatrix = _worldToViewMatrix.GetInverse();
+      _data.SetTransform(_worldToViewInverseMatrix);
+    }
+  }
+#endif
+
+  if (*dirtyBits & DirtyBits::DirtyProjMatrix) {
+    value = sceneDelegate->GetCameraParamValue(id, HdCameraTokens->projectionMatrix);
+    if (!value.IsEmpty()) {
+      _projectionMatrix = value.Get<GfMatrix4d>();
+      const float focalLength = _data.GetFocalLength();  // Get default focal length
+#if PXR_VERSION >= 2102
+      _data.SetFromViewAndProjectionMatrix(GetViewMatrix(), _projectionMatrix, focalLength);
+#else
+      if (_projectionMatrix[2][3] < -0.5) {
+        _data.SetProjection(GfCamera::Perspective);
+
+        const float horizontalAperture = (2.0 * focalLength) / _projectionMatrix[0][0];
+        _data.SetHorizontalAperture(horizontalAperture);
+        _data.SetHorizontalApertureOffset(0.5 * horizontalAperture * _projectionMatrix[2][0]);
+        const float verticalAperture = (2.0 * focalLength) / _projectionMatrix[1][1];
+        _data.SetVerticalAperture(verticalAperture);
+        _data.SetVerticalApertureOffset(0.5 * verticalAperture * _projectionMatrix[2][1]);
+
+        _data.SetClippingRange(
+            GfRange1f(_projectionMatrix[3][2] / (_projectionMatrix[2][2] - 1.0),
+                      _projectionMatrix[3][2] / (_projectionMatrix[2][2] + 1.0)));
+      }
+      else {
+        _data.SetProjection(GfCamera::Orthographic);
+
+        const float horizontalAperture = (2.0 / GfCamera::APERTURE_UNIT) / _projectionMatrix[0][0];
+        _data.SetHorizontalAperture(horizontalAperture);
+        _data.SetHorizontalApertureOffset(-0.5 * horizontalAperture * _projectionMatrix[3][0]);
+        const float verticalAperture = (2.0 / GfCamera::APERTURE_UNIT) / _projectionMatrix[1][1];
+        _data.SetVerticalAperture(verticalAperture);
+        _data.SetVerticalApertureOffset(-0.5 * verticalAperture * _projectionMatrix[3][1]);
+
+        const double nearMinusFarHalf = 1.0 / _projectionMatrix[2][2];
+        const double nearPlusFarHalf = nearMinusFarHalf * _projectionMatrix[3][2];
+        _data.SetClippingRange(
+            GfRange1f(nearPlusFarHalf + nearMinusFarHalf, nearPlusFarHalf - nearMinusFarHalf));
+      }
+#endif
+    }
+  }
+
+  if (*dirtyBits & DirtyBits::DirtyWindowPolicy) {
+    value = sceneDelegate->GetCameraParamValue(id, HdCameraTokens->windowPolicy);
+    if (!value.IsEmpty()) {
+      _windowPolicy = value.Get<CameraUtilConformWindowPolicy>();
+    }
+  }
+
+  if (*dirtyBits & DirtyBits::DirtyClipPlanes) {
+    value = sceneDelegate->GetCameraParamValue(id, HdCameraTokens->clipPlanes);
+    if (!value.IsEmpty()) {
+      _clipPlanes = value.Get<std::vector<GfVec4d>>();
+    }
+  }
+
+  if (*dirtyBits & DirtyBits::DirtyParams) {
+#if PXR_VERSION >= 2102
+    value = sceneDelegate->GetCameraParamValue(id, HdCameraTokens->projection);
+    if (!value.IsEmpty()) {
+      _projection = value.Get<Projection>();
+      _data.SetProjection(_projection != Orthographic ? GfCamera::Perspective :
+                                                        GfCamera::Orthographic);
+    }
+#else
+    value = sceneDelegate->GetCameraParamValue(id, UsdGeomTokens->projection);
+    if (!value.IsEmpty()) {
+      _data.SetProjection(value.Get<TfToken>() != UsdGeomTokens->orthographic ?
+                              GfCamera::Perspective :
+                              GfCamera::Orthographic);
+    }
+#endif
+
+    value = sceneDelegate->GetCameraParamValue(id, HdCameraTokens->horizontalAperture);
+    if (!value.IsEmpty()) {
+      const auto horizontalAperture = value.Get<float>();
+#if PXR_VERSION >= 2102
+      _horizontalAperture = horizontalAperture;
+#endif
+      _data.SetHorizontalAperture(horizontalAperture / GfCamera::APERTURE_UNIT);
+    }
+
+    value = sceneDelegate->GetCameraParamValue(id, HdCameraTokens->verticalAperture);
+    if (!value.IsEmpty()) {
+      const auto verticalAperture = value.Get<float>();
+#if PXR_VERSION >= 2102
+      _verticalAperture = verticalAperture;
+#endif
+      _data.SetVerticalAperture(verticalAperture / GfCamera::APERTURE_UNIT);
+    }
+
+    value = sceneDelegate->GetCameraParamValue(id, HdCameraTokens->horizontalApertureOffset);
+    if (!value.IsEmpty()) {
+      const auto horizontalApertureOffset = value.Get<float>();
+#if PXR_VERSION >= 2102
+      _horizontalApertureOffset = horizontalApertureOffset;
+#endif
+      _data.SetHorizontalApertureOffset(horizontalApertureOffset / GfCamera::APERTURE_UNIT);
+    }
+
+    value = sceneDelegate->GetCameraParamValue(id, HdCameraTokens->verticalApertureOffset);
+    if (!value.IsEmpty()) {
+      const auto verticalApertureOffset = value.Get<float>();
+#if PXR_VERSION >= 2102
+      _verticalApertureOffset = verticalApertureOffset;
+#endif
+      _data.SetVerticalApertureOffset(verticalApertureOffset / GfCamera::APERTURE_UNIT);
+    }
+
+    value = sceneDelegate->GetCameraParamValue(id, HdCameraTokens->focalLength);
+    if (!value.IsEmpty()) {
+      const auto focalLength = value.Get<float>();
+#if PXR_VERSION >= 2102
+      _focalLength = focalLength;
+#endif
+      _data.SetFocalLength(focalLength / GfCamera::FOCAL_LENGTH_UNIT);
+    }
+
+    value = sceneDelegate->GetCameraParamValue(id, HdCameraTokens->clippingRange);
+    if (!value.IsEmpty()) {
+      const auto clippingRange = value.Get<GfRange1f>();
+#if PXR_VERSION >= 2102
+      _clippingRange = clippingRange;
+#endif
+      _data.SetClippingRange(clippingRange);
+    }
+
+    value = sceneDelegate->GetCameraParamValue(id, HdCameraTokens->fStop);
+    if (!value.IsEmpty()) {
+      const auto fStop = value.Get<float>();
+#if PXR_VERSION >= 2102
+      _fStop = fStop;
+#endif
+      _data.SetFStop(fStop);
+    }
+
+    value = sceneDelegate->GetCameraParamValue(id, HdCameraTokens->focusDistance);
+    if (!value.IsEmpty()) {
+      const auto focusDistance = value.Get<float>();
+#if PXR_VERSION >= 2102
+      _focusDistance = focusDistance;
+#endif
+      _data.SetFocusDistance(focusDistance);
+    }
+  }
+
+  *dirtyBits = DirtyBits::Clean;
+}
+
+void HdCyclesCamera::Finalize(HdRenderParam *renderParam)
+{
+  HdCamera::Finalize(renderParam);
+}
+
+void HdCyclesCamera::ApplyCameraSettings(Camera *cam) const
+{
+  ApplyCameraSettings(_data, _windowPolicy, cam);
+
+  array<Transform> motion(_transformSamples.count);
+  for (size_t i = 0; i < _transformSamples.count; ++i)
+    motion[i] = convert_transform(_transformSamples.values[i]) *
+                transform_scale(1.0f, 1.0f, -1.0f);
+  cam->set_motion(motion);
+}
+
+void HdCyclesCamera::ApplyCameraSettings(const GfCamera &dataUnconformedWindow,
+                                         CameraUtilConformWindowPolicy windowPolicy,
+                                         Camera *cam)
+{
+  const float width = cam->get_full_width();
+  const float height = cam->get_full_height();
+
+  auto data = dataUnconformedWindow;
+  CameraUtilConformWindow(&data, windowPolicy, width / height);
+
+  static_assert(GfCamera::Perspective == CAMERA_PERSPECTIVE &&
+                GfCamera::Orthographic == CAMERA_ORTHOGRAPHIC);
+  cam->set_camera_type(static_cast<CameraType>(data.GetProjection()));
+
+  auto viewplane = data.GetFrustum().GetWindow();
+  auto focalLength = 1.0f;
+  if (data.GetProjection() == GfCamera::Perspective) {
+    viewplane *= 2.0 / viewplane.GetSize()[1];  // Normalize viewplane
+    focalLength = data.GetFocalLength() * 1e-3f;
+
+    cam->set_fov(GfDegreesToRadians(data.GetFieldOfView(GfCamera::FOVVertical)));
+  }
+
+  cam->set_sensorwidth(data.GetHorizontalAperture() * GfCamera::APERTURE_UNIT);
+  cam->set_sensorheight(data.GetVerticalAperture() * GfCamera::APERTURE_UNIT);
+
+  cam->set_nearclip(data.GetClippingRange().GetMin());
+  cam->set_farclip(data.GetClippingRange().GetMax());
+
+  cam->set_viewplane_left(viewplane.GetMin()[0]);
+  cam->set_viewplane_right(viewplane.GetMax()[0]);
+  cam->set_viewplane_bottom(viewplane.GetMin()[1]);
+  cam->set_viewplane_top(viewplane.GetMax()[1]);
+
+  if (data.GetFStop() != 0.0f) {
+    cam->set_focaldistance(data.GetFocusDistance());
+    cam->set_aperturesize(focalLength / (2.0f * data.GetFStop()));
+  }
+
+  cam->set_matrix(convert_transform(data.GetTransform()) * transform_scale(1.0f, 1.0f, -1.0f));
+}
+
+void HdCyclesCamera::ApplyCameraSettings(const GfMatrix4d &worldToViewMatrix,
+                                         const GfMatrix4d &projectionMatrix,
+                                         const std::vector<GfVec4d> &clipPlanes,
+                                         Camera *cam)
+{
+#if PXR_VERSION >= 2102
+  GfCamera data;
+  data.SetFromViewAndProjectionMatrix(worldToViewMatrix, projectionMatrix);
+
+  ApplyCameraSettings(data, CameraUtilFit, cam);
+#else
+  TF_CODING_ERROR("Not implemented");
+#endif
+}
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/camera.h

@@ -0,0 +1,43 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#pragma once
+
+#include "hydra/config.h"
+
+#include <pxr/base/gf/camera.h>
+#include <pxr/imaging/hd/camera.h>
+#include <pxr/imaging/hd/timeSampleArray.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+class HdCyclesCamera final : public PXR_NS::HdCamera {
+ public:
+  HdCyclesCamera(const PXR_NS::SdfPath &sprimId);
+  ~HdCyclesCamera() override;
+
+  void ApplyCameraSettings(CCL_NS::Camera *targetCamera) const;
+
+  static void ApplyCameraSettings(const PXR_NS::GfCamera &cameraData,
+                                  PXR_NS::CameraUtilConformWindowPolicy windowPolicy,
+                                  CCL_NS::Camera *targetCamera);
+  static void ApplyCameraSettings(const PXR_NS::GfMatrix4d &worldToViewMatrix,
+                                  const PXR_NS::GfMatrix4d &projectionMatrix,
+                                  const std::vector<PXR_NS::GfVec4d> &clipPlanes,
+                                  CCL_NS::Camera *targetCamera);
+
+  PXR_NS::HdDirtyBits GetInitialDirtyBitsMask() const override;
+
+  void Sync(PXR_NS::HdSceneDelegate *sceneDelegate,
+            PXR_NS::HdRenderParam *renderParam,
+            PXR_NS::HdDirtyBits *dirtyBits) override;
+
+  void Finalize(PXR_NS::HdRenderParam *renderParam) override;
+
+ private:
+  PXR_NS::GfCamera _data;
+  PXR_NS::HdTimeSampleArray<PXR_NS::GfMatrix4d, 2> _transformSamples;
+};
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/config.h

@@ -0,0 +1,44 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#pragma once
+
+#include <pxr/pxr.h>
+
+#define CCL_NS ccl
+#define CCL_NAMESPACE_USING_DIRECTIVE using namespace CCL_NS;
+
+#define HD_CYCLES_NS HdCycles
+#define HDCYCLES_NAMESPACE_OPEN_SCOPE \
+  namespace HD_CYCLES_NS { \
+  CCL_NAMESPACE_USING_DIRECTIVE; \
+  PXR_NAMESPACE_USING_DIRECTIVE;
+#define HDCYCLES_NAMESPACE_CLOSE_SCOPE }
+
+namespace HD_CYCLES_NS {
+class HdCyclesCamera;
+class HdCyclesDelegate;
+class HdCyclesSession;
+class HdCyclesRenderBuffer;
+}  // namespace HD_CYCLES_NS
+
+namespace CCL_NS {
+class AttributeSet;
+class BufferParams;
+class Camera;
+class Geometry;
+class Hair;
+class Light;
+class Mesh;
+class Object;
+class ParticleSystem;
+class Pass;
+class PointCloud;
+class Scene;
+class Session;
+class SessionParams;
+class Shader;
+class ShaderGraph;
+class Volume;
+}  // namespace CCL_NS

intern/cycles/hydra/curves.cpp

@@ -0,0 +1,210 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#include "hydra/curves.h"
+#include "hydra/geometry.inl"
+#include "scene/hair.h"
+
+#include <pxr/imaging/hd/extComputationUtils.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+HdCyclesCurves::HdCyclesCurves(const SdfPath &rprimId
+#if PXR_VERSION < 2102
+                               ,
+                               const SdfPath &instancerId
+#endif
+                               )
+    : HdCyclesGeometry(rprimId
+#if PXR_VERSION < 2102
+                       ,
+                       instancerId
+#endif
+      )
+{
+}
+
+HdCyclesCurves::~HdCyclesCurves()
+{
+}
+
+HdDirtyBits HdCyclesCurves::GetInitialDirtyBitsMask() const
+{
+  HdDirtyBits bits = HdCyclesGeometry::GetInitialDirtyBitsMask();
+  bits |= HdChangeTracker::DirtyPoints | HdChangeTracker::DirtyWidths |
+          HdChangeTracker::DirtyPrimvar | HdChangeTracker::DirtyTopology;
+  return bits;
+}
+
+HdDirtyBits HdCyclesCurves::_PropagateDirtyBits(HdDirtyBits bits) const
+{
+  if (bits & (HdChangeTracker::DirtyTopology)) {
+    // Changing topology clears the geometry, so need to populate everything again
+    bits |= HdChangeTracker::DirtyPoints | HdChangeTracker::DirtyWidths |
+            HdChangeTracker::DirtyPrimvar;
+  }
+
+  return bits;
+}
+
+void HdCyclesCurves::Populate(HdSceneDelegate *sceneDelegate, HdDirtyBits dirtyBits, bool &rebuild)
+{
+  if (HdChangeTracker::IsTopologyDirty(dirtyBits, GetId())) {
+    PopulateTopology(sceneDelegate);
+  }
+
+  if (dirtyBits & HdChangeTracker::DirtyPoints) {
+    PopulatePoints(sceneDelegate);
+  }
+
+  if (dirtyBits & HdChangeTracker::DirtyWidths) {
+    PopulateWidths(sceneDelegate);
+  }
+
+  if (dirtyBits & HdChangeTracker::DirtyPrimvar) {
+    PopulatePrimvars(sceneDelegate);
+  }
+
+  rebuild = (_geom->curve_keys_is_modified()) || (_geom->curve_radius_is_modified());
+}
+
+void HdCyclesCurves::PopulatePoints(HdSceneDelegate *sceneDelegate)
+{
+  VtValue value;
+
+  for (const HdExtComputationPrimvarDescriptor &desc :
+       sceneDelegate->GetExtComputationPrimvarDescriptors(GetId(), HdInterpolationVertex)) {
+    if (desc.name == HdTokens->points) {
+      auto valueStore = HdExtComputationUtils::GetComputedPrimvarValues({desc}, sceneDelegate);
+      const auto valueStoreIt = valueStore.find(desc.name);
+      if (valueStoreIt != valueStore.end()) {
+        value = std::move(valueStoreIt->second);
+      }
+      break;
+    }
+  }
+
+  if (value.IsEmpty()) {
+    value = GetPrimvar(sceneDelegate, HdTokens->points);
+  }
+
+  if (!value.IsHolding<VtVec3fArray>()) {
+    TF_WARN("Invalid points data for %s", GetId().GetText());
+    return;
+  }
+
+  const auto &points = value.UncheckedGet<VtVec3fArray>();
+
+  array<float3> pointsDataCycles;
+  pointsDataCycles.reserve(points.size());
+
+  for (const GfVec3f &point : points) {
+    pointsDataCycles.push_back_reserved(make_float3(point[0], point[1], point[2]));
+  }
+
+  _geom->set_curve_keys(pointsDataCycles);
+}
+
+void HdCyclesCurves::PopulateWidths(HdSceneDelegate *sceneDelegate)
+{
+  VtValue value = GetPrimvar(sceneDelegate, HdTokens->widths);
+  const HdInterpolation interpolation = GetPrimvarInterpolation(sceneDelegate, HdTokens->widths);
+
+  if (!value.IsHolding<VtFloatArray>()) {
+    TF_WARN("Invalid widths data for %s", GetId().GetText());
+    return;
+  }
+
+  const auto &widths = value.UncheckedGet<VtFloatArray>();
+
+  array<float> radiusDataCycles;
+  radiusDataCycles.reserve(widths.size());
+
+  if (interpolation == HdInterpolationConstant) {
+    TF_VERIFY(widths.size() == 1);
+
+    const float constantRadius = widths[0] * 0.5f;
+
+    for (size_t i = 0; i < _geom->num_keys(); ++i) {
+      radiusDataCycles.push_back_reserved(constantRadius);
+    }
+  }
+  else if (interpolation == HdInterpolationVertex) {
+    TF_VERIFY(widths.size() == _geom->num_keys());
+
+    for (size_t i = 0; i < _geom->num_keys(); ++i) {
+      radiusDataCycles.push_back_reserved(widths[i] * 0.5f);
+    }
+  }
+
+  _geom->set_curve_radius(radiusDataCycles);
+}
+
+void HdCyclesCurves::PopulatePrimvars(HdSceneDelegate *sceneDelegate)
+{
+  Scene *const scene = (Scene *)_geom->get_owner();
+
+  const std::pair<HdInterpolation, AttributeElement> interpolations[] = {
+      std::make_pair(HdInterpolationVertex, ATTR_ELEMENT_CURVE_KEY),
+      std::make_pair(HdInterpolationVarying, ATTR_ELEMENT_CURVE_KEY),
+      std::make_pair(HdInterpolationUniform, ATTR_ELEMENT_CURVE),
+      std::make_pair(HdInterpolationConstant, ATTR_ELEMENT_OBJECT),
+  };
+
+  for (const auto &interpolation : interpolations) {
+    for (const HdPrimvarDescriptor &desc :
+         GetPrimvarDescriptors(sceneDelegate, interpolation.first)) {
+      // Skip special primvars that are handled separately
+      if (desc.name == HdTokens->points || desc.name == HdTokens->widths) {
+        continue;
+      }
+
+      VtValue value = GetPrimvar(sceneDelegate, desc.name);
+      if (value.IsEmpty()) {
+        continue;
+      }
+
+      const ustring name(desc.name.GetString());
+
+      AttributeStandard std = ATTR_STD_NONE;
+      if (desc.role == HdPrimvarRoleTokens->textureCoordinate) {
+        std = ATTR_STD_UV;
+      }
+      else if (desc.name == HdTokens->displayColor &&
+               interpolation.first == HdInterpolationConstant) {
+        if (value.IsHolding<VtVec3fArray>() && value.GetArraySize() == 1) {
+          const GfVec3f color = value.UncheckedGet<VtVec3fArray>()[0];
+          _instances[0]->set_color(make_float3(color[0], color[1], color[2]));
+        }
+      }
+
+      // Skip attributes that are not needed
+      if ((std != ATTR_STD_NONE && _geom->need_attribute(scene, std)) ||
+          _geom->need_attribute(scene, name)) {
+        ApplyPrimvars(_geom->attributes, name, value, interpolation.second, std);
+      }
+    }
+  }
+}
+
+void HdCyclesCurves::PopulateTopology(HdSceneDelegate *sceneDelegate)
+{
+  // Clear geometry before populating it again with updated topology
+  _geom->clear(true);
+
+  HdBasisCurvesTopology topology = GetBasisCurvesTopology(sceneDelegate);
+
+  _geom->reserve_curves(topology.GetNumCurves(), topology.CalculateNeededNumberOfControlPoints());
+
+  const VtIntArray vertCounts = topology.GetCurveVertexCounts();
+
+  for (int curve = 0, key = 0; curve < topology.GetNumCurves(); ++curve) {
+    // Always reference shader at index zero, which is the primitive material
+    _geom->add_curve(key, 0);
+
+    key += vertCounts[curve];
+  }
+}
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/curves.h

@@ -0,0 +1,42 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#pragma once
+
+#include "hydra/config.h"
+#include "hydra/geometry.h"
+
+#include <pxr/imaging/hd/basisCurves.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+class HdCyclesCurves final : public HdCyclesGeometry<PXR_NS::HdBasisCurves, CCL_NS::Hair> {
+ public:
+  HdCyclesCurves(
+      const PXR_NS::SdfPath &rprimId
+#if PXR_VERSION < 2102
+      ,
+      const PXR_NS::SdfPath &instancerId = {}
+#endif
+  );
+  ~HdCyclesCurves() override;
+
+  PXR_NS::HdDirtyBits GetInitialDirtyBitsMask() const override;
+
+ private:
+  PXR_NS::HdDirtyBits _PropagateDirtyBits(PXR_NS::HdDirtyBits bits) const override;
+
+  void Populate(PXR_NS::HdSceneDelegate *sceneDelegate,
+                PXR_NS::HdDirtyBits dirtyBits,
+                bool &rebuild) override;
+
+  void PopulatePoints(PXR_NS::HdSceneDelegate *sceneDelegate);
+  void PopulateWidths(PXR_NS::HdSceneDelegate *sceneDelegate);
+
+  void PopulatePrimvars(PXR_NS::HdSceneDelegate *sceneDelegate);
+
+  void PopulateTopology(PXR_NS::HdSceneDelegate *sceneDelegate);
+};
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/display_driver.cpp

@@ -0,0 +1,240 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#ifdef _WIN32
+// Include first to avoid "NOGDI" definition set in Cycles headers
+#  include <Windows.h>
+#endif
+
+#include "hydra/display_driver.h"
+#include "hydra/render_buffer.h"
+#include "hydra/session.h"
+
+#include <GL/glew.h>
+#include <pxr/imaging/hgiGL/texture.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+HdCyclesDisplayDriver::HdCyclesDisplayDriver(HdCyclesSession *renderParam, Hgi *hgi)
+    : _renderParam(renderParam), _hgi(hgi)
+{
+#ifdef _WIN32
+  hdc_ = GetDC(CreateWindowA("STATIC",
+                             "HdCycles",
+                             WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
+                             0,
+                             0,
+                             64,
+                             64,
+                             NULL,
+                             NULL,
+                             GetModuleHandle(NULL),
+                             NULL));
+
+  int pixelFormat = GetPixelFormat(wglGetCurrentDC());
+  PIXELFORMATDESCRIPTOR pfd = {sizeof(pfd)};
+  DescribePixelFormat((HDC)hdc_, pixelFormat, sizeof(pfd), &pfd);
+  SetPixelFormat((HDC)hdc_, pixelFormat, &pfd);
+
+  TF_VERIFY(gl_context_ = wglCreateContext((HDC)hdc_));
+  TF_VERIFY(wglShareLists(wglGetCurrentContext(), (HGLRC)gl_context_));
+#endif
+
+  glewInit();
+
+  glGenBuffers(1, &gl_pbo_id_);
+}
+
+HdCyclesDisplayDriver::~HdCyclesDisplayDriver()
+{
+  if (texture_) {
+    _hgi->DestroyTexture(&texture_);
+  }
+
+  glDeleteBuffers(1, &gl_pbo_id_);
+
+#ifdef _WIN32
+  TF_VERIFY(wglDeleteContext((HGLRC)gl_context_));
+  DestroyWindow(WindowFromDC((HDC)hdc_));
+#endif
+}
+
+void HdCyclesDisplayDriver::next_tile_begin()
+{
+}
+
+bool HdCyclesDisplayDriver::update_begin(const Params &params,
+                                         int texture_width,
+                                         int texture_height)
+{
+#ifdef _WIN32
+  if (!hdc_ || !gl_context_) {
+    return false;
+  }
+#endif
+
+  graphics_interop_activate();
+
+  if (gl_render_sync_) {
+    glWaitSync((GLsync)gl_render_sync_, 0, GL_TIMEOUT_IGNORED);
+  }
+
+  if (pbo_size_.x != params.full_size.x || pbo_size_.y != params.full_size.y) {
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, gl_pbo_id_);
+    glBufferData(GL_PIXEL_UNPACK_BUFFER,
+                 sizeof(half4) * params.full_size.x * params.full_size.y,
+                 0,
+                 GL_DYNAMIC_DRAW);
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+
+    pbo_size_ = params.full_size;
+  }
+
+  need_update_ = true;
+
+  return true;
+}
+
+void HdCyclesDisplayDriver::update_end()
+{
+  gl_upload_sync_ = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
+
+  glFlush();
+
+  graphics_interop_deactivate();
+}
+
+void HdCyclesDisplayDriver::flush()
+{
+  graphics_interop_activate();
+
+  if (gl_upload_sync_) {
+    glWaitSync((GLsync)gl_upload_sync_, 0, GL_TIMEOUT_IGNORED);
+  }
+
+  if (gl_render_sync_) {
+    glWaitSync((GLsync)gl_render_sync_, 0, GL_TIMEOUT_IGNORED);
+  }
+
+  graphics_interop_deactivate();
+}
+
+half4 *HdCyclesDisplayDriver::map_texture_buffer()
+{
+  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, gl_pbo_id_);
+
+  const auto mapped_rgba_pixels = static_cast<half4 *>(
+      glMapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_WRITE_ONLY));
+
+  if (need_clear_ && mapped_rgba_pixels) {
+    memset(mapped_rgba_pixels, 0, sizeof(half4) * pbo_size_.x * pbo_size_.y);
+    need_clear_ = false;
+  }
+
+  return mapped_rgba_pixels;
+}
+
+void HdCyclesDisplayDriver::unmap_texture_buffer()
+{
+  glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
+
+  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+}
+
+DisplayDriver::GraphicsInterop HdCyclesDisplayDriver::graphics_interop_get()
+{
+  GraphicsInterop interop_dst;
+  interop_dst.buffer_width = pbo_size_.x;
+  interop_dst.buffer_height = pbo_size_.y;
+  interop_dst.opengl_pbo_id = gl_pbo_id_;
+
+  interop_dst.need_clear = need_clear_;
+  need_clear_ = false;
+
+  return interop_dst;
+}
+
+void HdCyclesDisplayDriver::graphics_interop_activate()
+{
+  mutex_.lock();
+
+#ifdef _WIN32
+  // Do not change context if this is called in the main thread
+  if (wglGetCurrentContext() == nullptr) {
+    TF_VERIFY(wglMakeCurrent((HDC)hdc_, (HGLRC)gl_context_));
+  }
+#endif
+}
+
+void HdCyclesDisplayDriver::graphics_interop_deactivate()
+{
+#ifdef _WIN32
+  if (wglGetCurrentContext() == gl_context_) {
+    TF_VERIFY(wglMakeCurrent(nullptr, nullptr));
+  }
+#endif
+
+  mutex_.unlock();
+}
+
+void HdCyclesDisplayDriver::clear()
+{
+  need_clear_ = true;
+}
+
+void HdCyclesDisplayDriver::draw(const Params &params)
+{
+  const auto renderBuffer = static_cast<HdCyclesRenderBuffer *>(
+      _renderParam->GetDisplayAovBinding().renderBuffer);
+  if (!renderBuffer ||  // Ensure this render buffer matches the texture dimensions
+      (renderBuffer->GetWidth() != params.size.x || renderBuffer->GetHeight() != params.size.y)) {
+    return;
+  }
+
+  // Cycles 'DisplayDriver' only supports 'half4' format
+  TF_VERIFY(renderBuffer->GetFormat() == HdFormatFloat16Vec4);
+
+  const thread_scoped_lock lock(mutex_);
+
+  const GfVec3i dimensions(params.size.x, params.size.y, 1);
+  if (!texture_ || texture_->GetDescriptor().dimensions != dimensions) {
+    if (texture_) {
+      _hgi->DestroyTexture(&texture_);
+    }
+
+    HgiTextureDesc texDesc;
+    texDesc.usage = 0;
+    texDesc.format = HgiFormatFloat16Vec4;
+    texDesc.type = HgiTextureType2D;
+    texDesc.dimensions = dimensions;
+    texDesc.sampleCount = HgiSampleCount1;
+
+    texture_ = _hgi->CreateTexture(texDesc);
+
+    renderBuffer->SetResource(VtValue(texture_));
+  }
+
+  HgiGLTexture *const texture = dynamic_cast<HgiGLTexture *>(texture_.Get());
+  if (!texture || !need_update_ || pbo_size_.x != params.size.x || pbo_size_.y != params.size.y) {
+    return;
+  }
+
+  if (gl_upload_sync_) {
+    glWaitSync((GLsync)gl_upload_sync_, 0, GL_TIMEOUT_IGNORED);
+  }
+
+  glBindTexture(GL_TEXTURE_2D, texture->GetTextureId());
+  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, gl_pbo_id_);
+  glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, pbo_size_.x, pbo_size_.y, GL_RGBA, GL_HALF_FLOAT, 0);
+  glBindTexture(GL_TEXTURE_2D, 0);
+  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+
+  gl_render_sync_ = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
+
+  glFlush();
+
+  need_update_ = false;
+}
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/display_driver.h

@@ -0,0 +1,61 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#pragma once
+
+#include "hydra/config.h"
+#include "session/display_driver.h"
+#include "util/thread.h"
+
+#include <pxr/imaging/hgi/hgi.h>
+#include <pxr/imaging/hgi/texture.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+class HdCyclesDisplayDriver final : public CCL_NS::DisplayDriver {
+ public:
+  HdCyclesDisplayDriver(HdCyclesSession *renderParam, Hgi *hgi);
+  ~HdCyclesDisplayDriver();
+
+ private:
+  void next_tile_begin() override;
+
+  bool update_begin(const Params &params, int texture_width, int texture_height) override;
+  void update_end() override;
+
+  void flush() override;
+
+  CCL_NS::half4 *map_texture_buffer() override;
+  void unmap_texture_buffer() override;
+
+  GraphicsInterop graphics_interop_get() override;
+
+  void graphics_interop_activate() override;
+  void graphics_interop_deactivate() override;
+
+  void clear() override;
+
+  void draw(const Params &params) override;
+
+  HdCyclesSession *const _renderParam;
+  Hgi *const _hgi;
+
+#ifdef _WIN32
+  void *hdc_ = nullptr;
+  void *gl_context_ = nullptr;
+#endif
+
+  CCL_NS::thread_mutex mutex_;
+
+  PXR_NS::HgiTextureHandle texture_;
+  unsigned int gl_pbo_id_ = 0;
+  CCL_NS::int2 pbo_size_ = CCL_NS::make_int2(0, 0);
+  bool need_update_ = false;
+  std::atomic_bool need_clear_ = false;
+
+  void *gl_render_sync_ = nullptr;
+  void *gl_upload_sync_ = nullptr;
+};
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/field.cpp

@@ -0,0 +1,88 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#include "hydra/field.h"
+#include "hydra/session.h"
+#include "scene/image_vdb.h"
+#include "scene/scene.h"
+
+#include <pxr/imaging/hd/sceneDelegate.h>
+#include <pxr/usd/sdf/assetPath.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+// clang-format off
+TF_DEFINE_PRIVATE_TOKENS(_tokens,
+   (fieldName)
+);
+// clang-format on
+
+#ifdef WITH_OPENVDB
+class HdCyclesVolumeLoader : public VDBImageLoader {
+ public:
+  HdCyclesVolumeLoader(const std::string &filePath, const std::string &gridName)
+      : VDBImageLoader(gridName)
+  {
+    openvdb::io::File file(filePath);
+    file.setCopyMaxBytes(0);
+    if (file.open()) {
+      grid = file.readGrid(gridName);
+    }
+  }
+};
+#endif
+
+HdCyclesField::HdCyclesField(const SdfPath &bprimId, const TfToken &typeId) : HdField(bprimId)
+{
+}
+
+HdCyclesField::~HdCyclesField()
+{
+}
+
+HdDirtyBits HdCyclesField::GetInitialDirtyBitsMask() const
+{
+  return DirtyBits::DirtyParams;
+}
+
+void HdCyclesField::Sync(HdSceneDelegate *sceneDelegate,
+                         HdRenderParam *renderParam,
+                         HdDirtyBits *dirtyBits)
+{
+#ifdef WITH_OPENVDB
+  VtValue value;
+  const SdfPath &id = GetId();
+
+  if (*dirtyBits & DirtyBits::DirtyParams) {
+    value = sceneDelegate->Get(id, HdFieldTokens->filePath);
+    if (value.IsHolding<SdfAssetPath>()) {
+      std::string filename = value.UncheckedGet<SdfAssetPath>().GetResolvedPath();
+      if (filename.empty()) {
+        filename = value.UncheckedGet<SdfAssetPath>().GetAssetPath();
+      }
+
+#  if PXR_VERSION >= 2108
+      value = sceneDelegate->Get(id, HdFieldTokens->fieldName);
+#  else
+      value = sceneDelegate->Get(id, _tokens->fieldName);
+#  endif
+      if (value.IsHolding<TfToken>()) {
+        ImageLoader *const loader = new HdCyclesVolumeLoader(
+            filename, value.UncheckedGet<TfToken>().GetString());
+
+        const SceneLock lock(renderParam);
+
+        ImageParams params;
+        params.frame = 0.0f;
+
+        _handle = lock.scene->image_manager->add_image(loader, params, false);
+      }
+    }
+  }
+#endif
+
+  *dirtyBits = DirtyBits::Clean;
+}
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/field.h

@@ -0,0 +1,34 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#pragma once
+
+#include "hydra/config.h"
+#include "scene/image.h"
+
+#include <pxr/imaging/hd/field.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+class HdCyclesField final : public PXR_NS::HdField {
+ public:
+  HdCyclesField(const PXR_NS::SdfPath &bprimId, const PXR_NS::TfToken &typeId);
+  ~HdCyclesField() override;
+
+  PXR_NS::HdDirtyBits GetInitialDirtyBitsMask() const override;
+
+  void Sync(PXR_NS::HdSceneDelegate *sceneDelegate,
+            PXR_NS::HdRenderParam *renderParam,
+            PXR_NS::HdDirtyBits *dirtyBits) override;
+
+  CCL_NS::ImageHandle GetImageHandle() const
+  {
+    return _handle;
+  }
+
+ private:
+  CCL_NS::ImageHandle _handle;
+};
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/geometry.h

@@ -0,0 +1,54 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#pragma once
+
+#include "hydra/config.h"
+
+#include <pxr/imaging/hd/rprim.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+template<typename Base, typename CyclesBase> class HdCyclesGeometry : public Base {
+ public:
+  HdCyclesGeometry(const PXR_NS::SdfPath &rprimId
+#if PXR_VERSION < 2102
+                   ,
+                   const PXR_NS::SdfPath &instancerId
+#endif
+  );
+
+  void Sync(PXR_NS::HdSceneDelegate *sceneDelegate,
+            PXR_NS::HdRenderParam *renderParam,
+            PXR_NS::HdDirtyBits *dirtyBits,
+            const PXR_NS::TfToken &reprToken) override;
+
+  PXR_NS::HdDirtyBits GetInitialDirtyBitsMask() const override;
+
+  virtual void Finalize(PXR_NS::HdRenderParam *renderParam) override;
+
+ protected:
+  void _InitRepr(const PXR_NS::TfToken &reprToken, PXR_NS::HdDirtyBits *dirtyBits) override;
+
+  PXR_NS::HdDirtyBits _PropagateDirtyBits(PXR_NS::HdDirtyBits bits) const override;
+
+  virtual void Populate(PXR_NS::HdSceneDelegate *sceneDelegate,
+                        PXR_NS::HdDirtyBits dirtyBits,
+                        bool &rebuild) = 0;
+
+  PXR_NS::HdInterpolation GetPrimvarInterpolation(PXR_NS::HdSceneDelegate *sceneDelegate,
+                                                  const PXR_NS::TfToken &name) const;
+
+  CyclesBase *_geom = nullptr;
+  std::vector<CCL_NS::Object *> _instances;
+
+ private:
+  void Initialize(PXR_NS::HdRenderParam *renderParam);
+
+  void InitializeInstance(int index);
+
+  PXR_NS::GfMatrix4d _geomTransform;
+};
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/geometry.inl

@@ -0,0 +1,247 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#include "hydra/attribute.h"
+#include "hydra/geometry.h"
+#include "hydra/instancer.h"
+#include "hydra/material.h"
+#include "hydra/session.h"
+#include "scene/geometry.h"
+#include "scene/object.h"
+#include "scene/scene.h"
+#include "util/hash.h"
+
+#include <pxr/imaging/hd/sceneDelegate.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+extern Transform convert_transform(const GfMatrix4d &matrix);
+
+template<typename Base, typename CyclesBase>
+HdCyclesGeometry<Base, CyclesBase>::HdCyclesGeometry(const SdfPath &rprimId
+#if PXR_VERSION < 2102
+                                                     ,
+                                                     const SdfPath &instancerId
+#endif
+                                                     )
+    : Base(rprimId
+#if PXR_VERSION < 2102
+
+           ,
+           instancerId
+#endif
+           ),
+      _geomTransform(1.0)
+{
+}
+
+template<typename Base, typename CyclesBase>
+void HdCyclesGeometry<Base, CyclesBase>::_InitRepr(const TfToken &reprToken,
+                                                   HdDirtyBits *dirtyBits)
+{
+  TF_UNUSED(reprToken);
+  TF_UNUSED(dirtyBits);
+}
+
+template<typename Base, typename CyclesBase>
+HdDirtyBits HdCyclesGeometry<Base, CyclesBase>::GetInitialDirtyBitsMask() const
+{
+  return HdChangeTracker::DirtyPrimID | HdChangeTracker::DirtyTransform |
+         HdChangeTracker::DirtyMaterialId | HdChangeTracker::DirtyVisibility |
+         HdChangeTracker::DirtyInstancer;
+}
+
+template<typename Base, typename CyclesBase>
+HdDirtyBits HdCyclesGeometry<Base, CyclesBase>::_PropagateDirtyBits(HdDirtyBits bits) const
+{
+  return bits;
+}
+
+template<typename Base, typename CyclesBase>
+void HdCyclesGeometry<Base, CyclesBase>::Sync(HdSceneDelegate *sceneDelegate,
+                                              HdRenderParam *renderParam,
+                                              HdDirtyBits *dirtyBits,
+                                              const TfToken &reprToken)
+{
+  TF_UNUSED(reprToken);
+
+  if (*dirtyBits == HdChangeTracker::Clean) {
+    return;
+  }
+
+  Initialize(renderParam);
+
+#if PXR_VERSION >= 2102
+  Base::_UpdateInstancer(sceneDelegate, dirtyBits);
+  HdInstancer::_SyncInstancerAndParents(sceneDelegate->GetRenderIndex(), Base::GetInstancerId());
+#endif
+  Base::_UpdateVisibility(sceneDelegate, dirtyBits);
+
+  const SceneLock lock(renderParam);
+
+  if (*dirtyBits & HdChangeTracker::DirtyMaterialId) {
+#if HD_API_VERSION >= 37 && PXR_VERSION >= 2105
+    Base::SetMaterialId(sceneDelegate->GetMaterialId(Base::GetId()));
+#else
+    Base::_SetMaterialId(sceneDelegate->GetRenderIndex().GetChangeTracker(),
+                         sceneDelegate->GetMaterialId(Base::GetId()));
+#endif
+
+    const auto material = static_cast<const HdCyclesMaterial *>(
+        sceneDelegate->GetRenderIndex().GetSprim(HdPrimTypeTokens->material,
+                                                 Base::GetMaterialId()));
+
+    array<Node *> usedShaders(1);
+    if (material && material->GetCyclesShader()) {
+      usedShaders[0] = material->GetCyclesShader();
+    }
+    else {
+      usedShaders[0] = lock.scene->default_surface;
+    }
+
+    for (Node *shader : usedShaders) {
+      static_cast<Shader *>(shader)->tag_used(lock.scene);
+    }
+
+    _geom->set_used_shaders(usedShaders);
+  }
+
+  const SdfPath &id = Base::GetId();
+
+  if (HdChangeTracker::IsPrimIdDirty(*dirtyBits, id)) {
+    // This needs to be corrected in the AOV
+    _instances[0]->set_pass_id(Base::GetPrimId() + 1);
+  }
+
+  if (HdChangeTracker::IsTransformDirty(*dirtyBits, id)) {
+    _geomTransform = sceneDelegate->GetTransform(id);
+  }
+
+  if (HdChangeTracker::IsTransformDirty(*dirtyBits, id) ||
+      HdChangeTracker::IsInstancerDirty(*dirtyBits, id)) {
+    const auto instancer = static_cast<HdCyclesInstancer *>(
+        sceneDelegate->GetRenderIndex().GetInstancer(Base::GetInstancerId()));
+
+    // Make sure the first object attribute is the instanceId
+    assert(_instances[0]->attributes.size() >= 1 &&
+           _instances[0]->attributes.front().name() == HdAovTokens->instanceId.GetString());
+
+    VtMatrix4dArray transforms;
+    if (instancer) {
+      transforms = instancer->ComputeInstanceTransforms(id);
+      _instances[0]->attributes.front() = ParamValue(HdAovTokens->instanceId.GetString(), +0.0f);
+    }
+    else {
+      // Default to a single instance with an identity transform
+      transforms.push_back(GfMatrix4d(1.0));
+      _instances[0]->attributes.front() = ParamValue(HdAovTokens->instanceId.GetString(), -1.0f);
+    }
+
+    const size_t oldSize = _instances.size();
+    const size_t newSize = transforms.size();
+
+    // Resize instance list
+    for (size_t i = newSize; i < oldSize; ++i) {
+      lock.scene->delete_node(_instances[i]);
+    }
+    _instances.resize(newSize);
+    for (size_t i = oldSize; i < newSize; ++i) {
+      _instances[i] = lock.scene->create_node<Object>();
+      InitializeInstance(static_cast<int>(i));
+    }
+
+    // Update transforms of all instances
+    for (size_t i = 0; i < transforms.size(); ++i) {
+      const Transform tfm = convert_transform(_geomTransform * transforms[i]);
+      _instances[i]->set_tfm(tfm);
+    }
+  }
+
+  if (HdChangeTracker::IsVisibilityDirty(*dirtyBits, id)) {
+    for (Object *instance : _instances) {
+      instance->set_visibility(Base::IsVisible() ? ~0 : 0);
+    }
+  }
+
+  // Must happen after material ID update, so that attribute decisions can be made
+  // based on it (e.g. check whether an attribute is actually needed)
+  bool rebuild = false;
+  Populate(sceneDelegate, *dirtyBits, rebuild);
+
+  if (_geom->is_modified() || rebuild) {
+    _geom->tag_update(lock.scene, rebuild);
+  }
+
+  for (Object *instance : _instances) {
+    instance->tag_update(lock.scene);
+  }
+
+  *dirtyBits = HdChangeTracker::Clean;
+}
+
+template<typename Base, typename CyclesBase>
+void HdCyclesGeometry<Base, CyclesBase>::Finalize(HdRenderParam *renderParam)
+{
+  if (!_geom && _instances.empty()) {
+    return;
+  }
+
+  const SceneLock lock(renderParam);
+
+  lock.scene->delete_node(_geom);
+  _geom = nullptr;
+
+  lock.scene->delete_nodes(set<Object *>(_instances.begin(), _instances.end()));
+  _instances.clear();
+  _instances.shrink_to_fit();
+}
+
+template<typename Base, typename CyclesBase>
+void HdCyclesGeometry<Base, CyclesBase>::Initialize(HdRenderParam *renderParam)
+{
+  if (_geom) {
+    return;
+  }
+
+  const SceneLock lock(renderParam);
+
+  // Create geometry
+  _geom = lock.scene->create_node<CyclesBase>();
+  _geom->name = Base::GetId().GetString();
+
+  // Create default instance
+  _instances.push_back(lock.scene->create_node<Object>());
+  InitializeInstance(0);
+}
+
+template<typename Base, typename CyclesBase>
+void HdCyclesGeometry<Base, CyclesBase>::InitializeInstance(int index)
+{
+  Object *instance = _instances[index];
+  instance->set_geometry(_geom);
+
+  instance->attributes.emplace_back(HdAovTokens->instanceId.GetString(),
+                                    _instances.size() == 1 ? -1.0f : static_cast<float>(index));
+
+  instance->set_color(make_float3(0.8f, 0.8f, 0.8f));
+  instance->set_random_id(hash_uint2(hash_string(_geom->name.c_str()), index));
+}
+
+template<typename Base, typename CyclesBase>
+HdInterpolation HdCyclesGeometry<Base, CyclesBase>::GetPrimvarInterpolation(
+    HdSceneDelegate *sceneDelegate, const TfToken &name) const
+{
+  for (int i = 0; i < HdInterpolationCount; ++i) {
+    for (const HdPrimvarDescriptor &desc :
+         Base::GetPrimvarDescriptors(sceneDelegate, static_cast<HdInterpolation>(i))) {
+      if (desc.name == name) {
+        return static_cast<HdInterpolation>(i);
+      }
+    }
+  }
+
+  return HdInterpolationCount;
+}
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/instancer.cpp

@@ -0,0 +1,138 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#include "hydra/instancer.h"
+
+#include <pxr/base/gf/quatd.h>
+#include <pxr/imaging/hd/sceneDelegate.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+HdCyclesInstancer::HdCyclesInstancer(HdSceneDelegate *delegate,
+                                     const SdfPath &instancerId
+#if PXR_VERSION <= 2011
+                                     ,
+                                     const SdfPath &parentId
+#endif
+                                     )
+    : HdInstancer(delegate,
+                  instancerId
+#if PXR_VERSION <= 2011
+                  ,
+                  parentId
+#endif
+      )
+{
+}
+
+HdCyclesInstancer::~HdCyclesInstancer()
+{
+}
+
+#if PXR_VERSION > 2011
+void HdCyclesInstancer::Sync(HdSceneDelegate *sceneDelegate,
+                             HdRenderParam *renderParam,
+                             HdDirtyBits *dirtyBits)
+{
+  _UpdateInstancer(sceneDelegate, dirtyBits);
+
+  if (HdChangeTracker::IsAnyPrimvarDirty(*dirtyBits, GetId())) {
+    SyncPrimvars();
+  }
+}
+#endif
+
+void HdCyclesInstancer::SyncPrimvars()
+{
+  HdSceneDelegate *const sceneDelegate = GetDelegate();
+  const HdDirtyBits dirtyBits =
+      sceneDelegate->GetRenderIndex().GetChangeTracker().GetInstancerDirtyBits(GetId());
+
+  for (const HdPrimvarDescriptor &desc :
+       sceneDelegate->GetPrimvarDescriptors(GetId(), HdInterpolationInstance)) {
+    if (!HdChangeTracker::IsPrimvarDirty(dirtyBits, GetId(), desc.name)) {
+      continue;
+    }
+
+    const VtValue value = sceneDelegate->Get(GetId(), desc.name);
+    if (value.IsEmpty()) {
+      continue;
+    }
+
+    if (desc.name == HdInstancerTokens->translate) {
+      _translate = value.Get<VtVec3fArray>();
+    }
+    else if (desc.name == HdInstancerTokens->rotate) {
+      _rotate = value.Get<VtVec4fArray>();
+    }
+    else if (desc.name == HdInstancerTokens->scale) {
+      _scale = value.Get<VtVec3fArray>();
+    }
+    else if (desc.name == HdInstancerTokens->instanceTransform) {
+      _instanceTransform = value.Get<VtMatrix4dArray>();
+    }
+  }
+
+  sceneDelegate->GetRenderIndex().GetChangeTracker().MarkInstancerClean(GetId());
+}
+
+VtMatrix4dArray HdCyclesInstancer::ComputeInstanceTransforms(const SdfPath &prototypeId)
+{
+#if PXR_VERSION <= 2011
+  SyncPrimvars();
+#endif
+
+  const VtIntArray instanceIndices = GetDelegate()->GetInstanceIndices(GetId(), prototypeId);
+  const GfMatrix4d instanceTransform = GetDelegate()->GetInstancerTransform(GetId());
+
+  VtMatrix4dArray transforms;
+  transforms.reserve(instanceIndices.size());
+
+  for (int index : instanceIndices) {
+    GfMatrix4d transform = instanceTransform;
+
+    if (index < _translate.size()) {
+      GfMatrix4d translateMat(1);
+      translateMat.SetTranslate(_translate[index]);
+      transform *= translateMat;
+    }
+
+    if (index < _rotate.size()) {
+      GfMatrix4d rotateMat(1);
+      const GfVec4f &quat = _rotate[index];
+      rotateMat.SetRotate(GfQuatd(quat[0], quat[1], quat[2], quat[3]));
+      transform *= rotateMat;
+    }
+
+    if (index < _scale.size()) {
+      GfMatrix4d scaleMat(1);
+      scaleMat.SetScale(_scale[index]);
+      transform *= scaleMat;
+    }
+
+    if (index < _instanceTransform.size()) {
+      transform *= _instanceTransform[index];
+    }
+
+    transforms.push_back(transform);
+  }
+
+  VtMatrix4dArray resultTransforms;
+
+  if (const auto instancer = static_cast<HdCyclesInstancer *>(
+          GetDelegate()->GetRenderIndex().GetInstancer(GetParentId()))) {
+    for (const GfMatrix4d &parentTransform : instancer->ComputeInstanceTransforms(GetId())) {
+      for (const GfMatrix4d &localTransform : transforms) {
+        resultTransforms.push_back(parentTransform * localTransform);
+      }
+    }
+  }
+  else {
+    resultTransforms = std::move(transforms);
+  }
+
+  return resultTransforms;
+}
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/instancer.h

@@ -0,0 +1,45 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#pragma once
+
+#include "hydra/config.h"
+
+#include <pxr/base/gf/matrix4d.h>
+#include <pxr/base/gf/vec3f.h>
+#include <pxr/base/gf/vec4f.h>
+#include <pxr/base/vt/array.h>
+#include <pxr/imaging/hd/instancer.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+class HdCyclesInstancer final : public PXR_NS::HdInstancer {
+ public:
+  HdCyclesInstancer(PXR_NS::HdSceneDelegate *delegate,
+                    const PXR_NS::SdfPath &instancerId
+#if PXR_VERSION <= 2011
+                    ,
+                    const PXR_NS::SdfPath &parentId
+#endif
+  );
+  ~HdCyclesInstancer() override;
+
+#if PXR_VERSION > 2011
+  void Sync(PXR_NS::HdSceneDelegate *sceneDelegate,
+            PXR_NS::HdRenderParam *renderParam,
+            PXR_NS::HdDirtyBits *dirtyBits) override;
+#endif
+
+  PXR_NS::VtMatrix4dArray ComputeInstanceTransforms(const PXR_NS::SdfPath &prototypeId);
+
+ private:
+  void SyncPrimvars();
+
+  PXR_NS::VtVec3fArray _translate;
+  PXR_NS::VtVec4fArray _rotate;
+  PXR_NS::VtVec3fArray _scale;
+  PXR_NS::VtMatrix4dArray _instanceTransform;
+};
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/light.cpp

@@ -0,0 +1,399 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#include "hydra/light.h"
+#include "hydra/session.h"
+#include "scene/light.h"
+#include "scene/scene.h"
+#include "scene/shader.h"
+#include "scene/shader_graph.h"
+#include "scene/shader_nodes.h"
+#include "util/hash.h"
+
+#include <pxr/imaging/hd/sceneDelegate.h>
+#include <pxr/usd/sdf/assetPath.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+extern Transform convert_transform(const GfMatrix4d &matrix);
+
+// clang-format off
+TF_DEFINE_PRIVATE_TOKENS(_tokens,
+    (visibleInPrimaryRay)
+);
+// clang-format on
+
+HdCyclesLight::HdCyclesLight(const SdfPath &sprimId, const TfToken &lightType)
+    : HdLight(sprimId), _lightType(lightType)
+{
+}
+
+HdCyclesLight::~HdCyclesLight()
+{
+}
+
+HdDirtyBits HdCyclesLight::GetInitialDirtyBitsMask() const
+{
+  return DirtyBits::DirtyTransform | DirtyBits::DirtyParams;
+}
+
+void HdCyclesLight::Sync(HdSceneDelegate *sceneDelegate,
+                         HdRenderParam *renderParam,
+                         HdDirtyBits *dirtyBits)
+{
+  if (*dirtyBits == DirtyBits::Clean) {
+    return;
+  }
+
+  Initialize(renderParam);
+
+  const SceneLock lock(renderParam);
+
+  VtValue value;
+  const SdfPath &id = GetId();
+
+  if (*dirtyBits & DirtyBits::DirtyTransform) {
+#if PXR_VERSION >= 2011
+    const Transform tfm = convert_transform(sceneDelegate->GetTransform(id));
+#else
+    const Transform tfm = convert_transform(
+        sceneDelegate->GetLightParamValue(id, HdTokens->transform).Get<GfMatrix4d>());
+#endif
+    _light->set_tfm(tfm);
+
+    _light->set_co(transform_get_column(&tfm, 3));
+    _light->set_dir(-transform_get_column(&tfm, 2));
+
+    if (_lightType == HdPrimTypeTokens->diskLight || _lightType == HdPrimTypeTokens->rectLight) {
+      _light->set_axisu(transform_get_column(&tfm, 0));
+      _light->set_axisv(transform_get_column(&tfm, 1));
+    }
+  }
+
+  if (*dirtyBits & DirtyBits::DirtyParams) {
+    float3 strength = make_float3(1.0f, 1.0f, 1.0f);
+
+    value = sceneDelegate->GetLightParamValue(id, HdLightTokens->color);
+    if (!value.IsEmpty()) {
+      const auto color = value.Get<GfVec3f>();
+      strength = make_float3(color[0], color[1], color[2]);
+    }
+
+    value = sceneDelegate->GetLightParamValue(id, HdLightTokens->exposure);
+    if (!value.IsEmpty()) {
+      strength *= exp2(value.Get<float>());
+    }
+
+    value = sceneDelegate->GetLightParamValue(id, HdLightTokens->intensity);
+    if (!value.IsEmpty()) {
+      strength *= value.Get<float>();
+    }
+
+    // Cycles lights are normalized by default, so need to scale intensity if Hydra light is not
+    value = sceneDelegate->GetLightParamValue(id, HdLightTokens->normalize);
+    const bool normalize = value.IsHolding<bool>() && value.UncheckedGet<bool>();
+
+    value = sceneDelegate->GetLightParamValue(id, _tokens->visibleInPrimaryRay);
+    if (!value.IsEmpty()) {
+      _light->set_use_camera(value.Get<bool>());
+    }
+
+    value = sceneDelegate->GetLightParamValue(id, HdLightTokens->shadowEnable);
+    if (!value.IsEmpty()) {
+      _light->set_cast_shadow(value.Get<bool>());
+    }
+
+    if (_lightType == HdPrimTypeTokens->distantLight) {
+      value = sceneDelegate->GetLightParamValue(id, HdLightTokens->angle);
+      if (!value.IsEmpty()) {
+        _light->set_angle(GfDegreesToRadians(value.Get<float>()));
+      }
+    }
+    else if (_lightType == HdPrimTypeTokens->diskLight) {
+      value = sceneDelegate->GetLightParamValue(id, HdLightTokens->radius);
+      if (!value.IsEmpty()) {
+        const float size = value.Get<float>() * 2.0f;
+        _light->set_sizeu(size);
+        _light->set_sizev(size);
+      }
+
+      if (!normalize) {
+        const float radius = _light->get_sizeu() * 0.5f;
+        strength *= M_PI * radius * radius;
+      }
+    }
+    else if (_lightType == HdPrimTypeTokens->rectLight) {
+      value = sceneDelegate->GetLightParamValue(id, HdLightTokens->width);
+      if (!value.IsEmpty()) {
+        _light->set_sizeu(value.Get<float>());
+      }
+
+      value = sceneDelegate->GetLightParamValue(id, HdLightTokens->height);
+      if (!value.IsEmpty()) {
+        _light->set_sizev(value.Get<float>());
+      }
+
+      if (!normalize) {
+        strength *= _light->get_sizeu() * _light->get_sizeu();
+      }
+    }
+    else if (_lightType == HdPrimTypeTokens->sphereLight) {
+      value = sceneDelegate->GetLightParamValue(id, HdLightTokens->radius);
+      if (!value.IsEmpty()) {
+        _light->set_size(value.Get<float>());
+      }
+
+      bool shaping = false;
+
+      value = sceneDelegate->GetLightParamValue(id, HdLightTokens->shapingConeAngle);
+      if (!value.IsEmpty()) {
+        _light->set_spot_angle(GfDegreesToRadians(value.Get<float>()) * 2.0f);
+        shaping = true;
+      }
+
+      value = sceneDelegate->GetLightParamValue(id, HdLightTokens->shapingConeSoftness);
+      if (!value.IsEmpty()) {
+        _light->set_spot_smooth(value.Get<float>());
+        shaping = true;
+      }
+
+      _light->set_light_type(shaping ? LIGHT_SPOT : LIGHT_POINT);
+
+      if (!normalize) {
+        const float radius = _light->get_size();
+        strength *= M_PI * radius * radius * 4.0f;
+      }
+    }
+
+    const bool visible = sceneDelegate->GetVisible(id);
+    // Disable invisible lights by zeroing the strength
+    // So 'LightManager::test_enabled_lights' updates the enabled flag correctly
+    if (!visible) {
+      strength = zero_float3();
+    }
+
+    _light->set_strength(strength);
+    _light->set_is_enabled(visible);
+
+    PopulateShaderGraph(sceneDelegate);
+  }
+  // Need to update shader graph when transform changes in case transform was baked into it
+  else if (_light->tfm_is_modified() && (_lightType == HdPrimTypeTokens->domeLight ||
+                                         _light->get_shader()->has_surface_spatial_varying)) {
+    PopulateShaderGraph(sceneDelegate);
+  }
+
+  if (_light->is_modified()) {
+    _light->tag_update(lock.scene);
+  }
+
+  *dirtyBits = DirtyBits::Clean;
+}
+
+void HdCyclesLight::PopulateShaderGraph(HdSceneDelegate *sceneDelegate)
+{
+  auto graph = new ShaderGraph();
+  ShaderNode *outputNode = nullptr;
+
+  if (_lightType == HdPrimTypeTokens->domeLight) {
+    BackgroundNode *bgNode = graph->create_node<BackgroundNode>();
+    // Bake strength into shader graph, since only the shader is used for background lights
+    bgNode->set_color(_light->get_strength());
+    graph->add(bgNode);
+
+    graph->connect(bgNode->output("Background"), graph->output()->input("Surface"));
+
+    outputNode = bgNode;
+  }
+  else {
+    EmissionNode *emissionNode = graph->create_node<EmissionNode>();
+    emissionNode->set_color(one_float3());
+    emissionNode->set_strength(1.0f);
+    graph->add(emissionNode);
+
+    graph->connect(emissionNode->output("Emission"), graph->output()->input("Surface"));
+
+    outputNode = emissionNode;
+  }
+
+  VtValue value;
+  const SdfPath &id = GetId();
+  bool hasSpatialVarying = false;
+  bool hasColorTemperature = false;
+
+  if (sceneDelegate != nullptr) {
+    value = sceneDelegate->GetLightParamValue(id, HdLightTokens->enableColorTemperature);
+    const bool enableColorTemperature = value.IsHolding<bool>() && value.UncheckedGet<bool>();
+
+    if (enableColorTemperature) {
+      value = sceneDelegate->GetLightParamValue(id, HdLightTokens->colorTemperature);
+      if (value.IsHolding<float>()) {
+        BlackbodyNode *blackbodyNode = graph->create_node<BlackbodyNode>();
+        blackbodyNode->set_temperature(value.UncheckedGet<float>());
+        graph->add(blackbodyNode);
+
+        if (_lightType == HdPrimTypeTokens->domeLight) {
+          VectorMathNode *mathNode = graph->create_node<VectorMathNode>();
+          mathNode->set_math_type(NODE_VECTOR_MATH_MULTIPLY);
+          mathNode->set_vector2(_light->get_strength());
+          graph->add(mathNode);
+
+          graph->connect(blackbodyNode->output("Color"), mathNode->input("Vector1"));
+          graph->connect(mathNode->output("Vector"), outputNode->input("Color"));
+        }
+        else {
+          graph->connect(blackbodyNode->output("Color"), outputNode->input("Color"));
+        }
+
+        hasColorTemperature = true;
+      }
+    }
+
+    value = sceneDelegate->GetLightParamValue(id, HdLightTokens->shapingIesFile);
+    if (value.IsHolding<SdfAssetPath>()) {
+      std::string filename = value.UncheckedGet<SdfAssetPath>().GetResolvedPath();
+      if (filename.empty()) {
+        filename = value.UncheckedGet<SdfAssetPath>().GetAssetPath();
+      }
+
+      TextureCoordinateNode *coordNode = graph->create_node<TextureCoordinateNode>();
+      coordNode->set_ob_tfm(_light->get_tfm());
+      coordNode->set_use_transform(true);
+      graph->add(coordNode);
+
+      IESLightNode *iesNode = graph->create_node<IESLightNode>();
+      iesNode->set_filename(ustring(filename));
+
+      graph->connect(coordNode->output("Normal"), iesNode->input("Vector"));
+      graph->connect(iesNode->output("Fac"), outputNode->input("Strength"));
+
+      hasSpatialVarying = true;
+    }
+
+    value = sceneDelegate->GetLightParamValue(id, HdLightTokens->textureFile);
+    if (value.IsHolding<SdfAssetPath>()) {
+      std::string filename = value.UncheckedGet<SdfAssetPath>().GetResolvedPath();
+      if (filename.empty()) {
+        filename = value.UncheckedGet<SdfAssetPath>().GetAssetPath();
+      }
+
+      ImageSlotTextureNode *textureNode = nullptr;
+      if (_lightType == HdPrimTypeTokens->domeLight) {
+        Transform tfm = _light->get_tfm();
+        transform_set_column(&tfm, 3, zero_float3());  // Remove translation
+
+        TextureCoordinateNode *coordNode = graph->create_node<TextureCoordinateNode>();
+        coordNode->set_ob_tfm(tfm);
+        coordNode->set_use_transform(true);
+        graph->add(coordNode);
+
+        textureNode = graph->create_node<EnvironmentTextureNode>();
+        static_cast<EnvironmentTextureNode *>(textureNode)->set_filename(ustring(filename));
+        graph->add(textureNode);
+
+        graph->connect(coordNode->output("Object"), textureNode->input("Vector"));
+
+        hasSpatialVarying = true;
+      }
+      else {
+        GeometryNode *coordNode = graph->create_node<GeometryNode>();
+        graph->add(coordNode);
+
+        textureNode = graph->create_node<ImageTextureNode>();
+        static_cast<ImageTextureNode *>(textureNode)->set_filename(ustring(filename));
+        graph->add(textureNode);
+
+        graph->connect(coordNode->output("Parametric"), textureNode->input("Vector"));
+      }
+
+      if (hasColorTemperature) {
+        VectorMathNode *mathNode = graph->create_node<VectorMathNode>();
+        mathNode->set_math_type(NODE_VECTOR_MATH_MULTIPLY);
+        graph->add(mathNode);
+
+        graph->connect(textureNode->output("Color"), mathNode->input("Vector1"));
+        ShaderInput *const outputNodeInput = outputNode->input("Color");
+        graph->connect(outputNodeInput->link, mathNode->input("Vector2"));
+        graph->disconnect(outputNodeInput);
+        graph->connect(mathNode->output("Vector"), outputNodeInput);
+      }
+      else if (_lightType == HdPrimTypeTokens->domeLight) {
+        VectorMathNode *mathNode = graph->create_node<VectorMathNode>();
+        mathNode->set_math_type(NODE_VECTOR_MATH_MULTIPLY);
+        mathNode->set_vector2(_light->get_strength());
+        graph->add(mathNode);
+
+        graph->connect(textureNode->output("Color"), mathNode->input("Vector1"));
+        graph->connect(mathNode->output("Vector"), outputNode->input("Color"));
+      }
+      else {
+        graph->connect(textureNode->output("Color"), outputNode->input("Color"));
+      }
+    }
+  }
+
+  Shader *const shader = _light->get_shader();
+  shader->set_graph(graph);
+  shader->tag_update((Scene *)_light->get_owner());
+
+  shader->has_surface_spatial_varying = hasSpatialVarying;
+}
+
+void HdCyclesLight::Finalize(HdRenderParam *renderParam)
+{
+  if (!_light) {
+    return;
+  }
+
+  const SceneLock lock(renderParam);
+
+  lock.scene->delete_node(_light);
+  _light = nullptr;
+}
+
+void HdCyclesLight::Initialize(HdRenderParam *renderParam)
+{
+  if (_light) {
+    return;
+  }
+
+  const SceneLock lock(renderParam);
+
+  _light = lock.scene->create_node<Light>();
+  _light->name = GetId().GetString();
+
+  _light->set_random_id(hash_uint2(hash_string(_light->name.c_str()), 0));
+
+  if (_lightType == HdPrimTypeTokens->domeLight) {
+    _light->set_light_type(LIGHT_BACKGROUND);
+  }
+  else if (_lightType == HdPrimTypeTokens->distantLight) {
+    _light->set_light_type(LIGHT_DISTANT);
+  }
+  else if (_lightType == HdPrimTypeTokens->diskLight) {
+    _light->set_light_type(LIGHT_AREA);
+    _light->set_round(true);
+    _light->set_size(1.0f);
+  }
+  else if (_lightType == HdPrimTypeTokens->rectLight) {
+    _light->set_light_type(LIGHT_AREA);
+    _light->set_round(false);
+    _light->set_size(1.0f);
+  }
+  else if (_lightType == HdPrimTypeTokens->sphereLight) {
+    _light->set_light_type(LIGHT_POINT);
+    _light->set_size(1.0f);
+  }
+
+  _light->set_use_mis(true);
+  _light->set_use_camera(false);
+
+  Shader *const shader = lock.scene->create_node<Shader>();
+  _light->set_shader(shader);
+
+  // Create default shader graph
+  PopulateShaderGraph(nullptr);
+}
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/light.h

@@ -0,0 +1,35 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#pragma once
+
+#include "hydra/config.h"
+
+#include <pxr/imaging/hd/light.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+class HdCyclesLight final : public PXR_NS::HdLight {
+ public:
+  HdCyclesLight(const PXR_NS::SdfPath &sprimId, const PXR_NS::TfToken &lightType);
+  ~HdCyclesLight() override;
+
+  PXR_NS::HdDirtyBits GetInitialDirtyBitsMask() const override;
+
+  void Sync(PXR_NS::HdSceneDelegate *sceneDelegate,
+            PXR_NS::HdRenderParam *renderParam,
+            PXR_NS::HdDirtyBits *dirtyBits) override;
+
+  void Finalize(PXR_NS::HdRenderParam *renderParam) override;
+
+ private:
+  void Initialize(PXR_NS::HdRenderParam *renderParam);
+
+  void PopulateShaderGraph(PXR_NS::HdSceneDelegate *sceneDelegate);
+
+  CCL_NS::Light *_light = nullptr;
+  PXR_NS::TfToken _lightType;
+};
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/material.cpp

@@ -0,0 +1,589 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#include "hydra/material.h"
+#include "hydra/node_util.h"
+#include "hydra/session.h"
+#include "scene/scene.h"
+#include "scene/shader.h"
+#include "scene/shader_graph.h"
+#include "scene/shader_nodes.h"
+
+#include <pxr/imaging/hd/sceneDelegate.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+// clang-format off
+TF_DEFINE_PRIVATE_TOKENS(CyclesMaterialTokens,
+    ((cyclesSurface, "cycles:surface"))
+    ((cyclesDisplacement, "cycles:displacement"))
+    ((cyclesVolume, "cycles:volume"))
+    (UsdPreviewSurface)
+    (UsdUVTexture)
+    (UsdPrimvarReader_float)
+    (UsdPrimvarReader_float2)
+    (UsdPrimvarReader_float3)
+    (UsdPrimvarReader_float4)
+    (UsdPrimvarReader_int)
+    (UsdTransform2d)
+    (a)
+    (rgb)
+    (r)
+    (g)
+    (b)
+    (result)
+    (st)
+    (wrapS)
+    (wrapT)
+    (periodic)
+);
+// clang-format on
+
+namespace {
+
+// Simple class to handle remapping of USDPreviewSurface nodes and parameters to Cycles equivalents
+class UsdToCyclesMapping {
+  using ParamMap = std::unordered_map<TfToken, ustring, TfToken::HashFunctor>;
+
+ public:
+  UsdToCyclesMapping(const char *nodeType, ParamMap paramMap)
+      : _nodeType(nodeType), _paramMap(std::move(paramMap))
+  {
+  }
+
+  ustring nodeType() const
+  {
+    return _nodeType;
+  }
+
+  virtual std::string parameterName(const TfToken &name,
+                                    const ShaderInput *inputConnection,
+                                    VtValue *value = nullptr) const
+  {
+    // UsdNode.name -> Node.input
+    // These all follow a simple pattern that we can just remap
+    // based on the name or 'Node.input' type
+    if (inputConnection) {
+      if (name == CyclesMaterialTokens->a) {
+        return "alpha";
+      }
+      if (name == CyclesMaterialTokens->rgb) {
+        return "color";
+      }
+      // TODO: Is there a better mapping than 'color'?
+      if (name == CyclesMaterialTokens->r || name == CyclesMaterialTokens->g ||
+          name == CyclesMaterialTokens->b) {
+        return "color";
+      }
+
+      if (name == CyclesMaterialTokens->result) {
+        switch (inputConnection->socket_type.type) {
+          case SocketType::BOOLEAN:
+          case SocketType::FLOAT:
+          case SocketType::INT:
+          case SocketType::UINT:
+            return "alpha";
+          case SocketType::COLOR:
+          case SocketType::VECTOR:
+          case SocketType::POINT:
+          case SocketType::NORMAL:
+          default:
+            return "color";
+        }
+      }
+    }
+
+    // Simple mapping case
+    const auto it = _paramMap.find(name);
+    return it != _paramMap.end() ? it->second.string() : name.GetString();
+  }
+
+ private:
+  const ustring _nodeType;
+  ParamMap _paramMap;
+};
+
+class UsdToCyclesTexture : public UsdToCyclesMapping {
+ public:
+  using UsdToCyclesMapping::UsdToCyclesMapping;
+
+  std::string parameterName(const TfToken &name,
+                            const ShaderInput *inputConnection,
+                            VtValue *value) const override
+  {
+    if (value) {
+      // Remap UsdUVTexture.wrapS and UsdUVTexture.wrapT to cycles_image_texture.extension
+      if (name == CyclesMaterialTokens->wrapS || name == CyclesMaterialTokens->wrapT) {
+        std::string valueString = VtValue::Cast<std::string>(*value).Get<std::string>();
+
+        // A value of 'repeat' in USD is equivalent to 'periodic' in Cycles
+        if (valueString == "repeat") {
+          *value = VtValue(CyclesMaterialTokens->periodic);
+        }
+
+        return "extension";
+      }
+    }
+
+    return UsdToCyclesMapping::parameterName(name, inputConnection, value);
+  }
+};
+
+class UsdToCycles {
+  const UsdToCyclesMapping UsdPreviewSurface = {
+      "principled_bsdf",
+      {
+          {TfToken("diffuseColor"), ustring("base_color")},
+          {TfToken("emissiveColor"), ustring("emission")},
+          {TfToken("specularColor"), ustring("specular")},
+          {TfToken("clearcoatRoughness"), ustring("clearcoat_roughness")},
+          {TfToken("opacity"), ustring("alpha")},
+          // opacityThreshold
+          // occlusion
+          // displacement
+      }};
+  const UsdToCyclesTexture UsdUVTexture = {
+      "image_texture",
+      {
+          {CyclesMaterialTokens->st, ustring("vector")},
+          {CyclesMaterialTokens->wrapS, ustring("extension")},
+          {CyclesMaterialTokens->wrapT, ustring("extension")},
+          {TfToken("file"), ustring("filename")},
+          {TfToken("sourceColorSpace"), ustring("colorspace")},
+      }};
+  const UsdToCyclesMapping UsdPrimvarReader = {"attribute",
+                                               {{TfToken("varname"), ustring("attribute")}}};
+
+ public:
+  const UsdToCyclesMapping *findUsd(const TfToken &usdNodeType)
+  {
+    if (usdNodeType == CyclesMaterialTokens->UsdPreviewSurface) {
+      return &UsdPreviewSurface;
+    }
+    if (usdNodeType == CyclesMaterialTokens->UsdUVTexture) {
+      return &UsdUVTexture;
+    }
+    if (usdNodeType == CyclesMaterialTokens->UsdPrimvarReader_float ||
+        usdNodeType == CyclesMaterialTokens->UsdPrimvarReader_float2 ||
+        usdNodeType == CyclesMaterialTokens->UsdPrimvarReader_float3 ||
+        usdNodeType == CyclesMaterialTokens->UsdPrimvarReader_float4 ||
+        usdNodeType == CyclesMaterialTokens->UsdPrimvarReader_int) {
+      return &UsdPrimvarReader;
+    }
+
+    return nullptr;
+  }
+  const UsdToCyclesMapping *findCycles(const ustring &cyclesNodeType)
+  {
+    return nullptr;
+  }
+};
+TfStaticData<UsdToCycles> sUsdToCyles;
+
+}  // namespace
+
+struct HdCyclesMaterial::NodeDesc {
+  ShaderNode *node;
+  const UsdToCyclesMapping *mapping;
+};
+
+HdCyclesMaterial::HdCyclesMaterial(const SdfPath &sprimId) : HdMaterial(sprimId)
+{
+}
+
+HdCyclesMaterial::~HdCyclesMaterial()
+{
+}
+
+HdDirtyBits HdCyclesMaterial::GetInitialDirtyBitsMask() const
+{
+  return DirtyBits::DirtyResource | DirtyBits::DirtyParams;
+}
+
+void HdCyclesMaterial::Sync(HdSceneDelegate *sceneDelegate,
+                            HdRenderParam *renderParam,
+                            HdDirtyBits *dirtyBits)
+{
+  if (*dirtyBits == DirtyBits::Clean) {
+    return;
+  }
+
+  Initialize(renderParam);
+
+  const SceneLock lock(renderParam);
+
+  const bool dirtyParams = (*dirtyBits & DirtyBits::DirtyParams);
+  const bool dirtyResource = (*dirtyBits & DirtyBits::DirtyResource);
+
+  VtValue value;
+  const SdfPath &id = GetId();
+
+  if (dirtyResource || dirtyParams) {
+    value = sceneDelegate->GetMaterialResource(id);
+
+#if 1
+    const HdMaterialNetwork2 *network = nullptr;
+    std::unique_ptr<HdMaterialNetwork2> networkConverted;
+    if (value.IsHolding<HdMaterialNetwork2>()) {
+      network = &value.UncheckedGet<HdMaterialNetwork2>();
+    }
+    else if (value.IsHolding<HdMaterialNetworkMap>()) {
+      const auto &networkOld = value.UncheckedGet<HdMaterialNetworkMap>();
+      // In the case of only parameter updates, there is no need to waste time converting to a
+      // HdMaterialNetwork2, as supporting HdMaterialNetworkMap for parameters only is trivial.
+      if (!_nodes.empty() && !dirtyResource) {
+        for (const auto &networkEntry : networkOld.map) {
+          UpdateParameters(networkEntry.second);
+        }
+        _shader->tag_modified();
+      }
+      else {
+        networkConverted = std::make_unique<HdMaterialNetwork2>();
+        HdMaterialNetwork2ConvertFromHdMaterialNetworkMap(networkOld, networkConverted.get());
+        network = networkConverted.get();
+      }
+    }
+    else {
+      TF_RUNTIME_ERROR("Could not get a HdMaterialNetwork2.");
+    }
+
+    if (network) {
+      if (!_nodes.empty() && !dirtyResource) {
+        UpdateParameters(*network);
+        _shader->tag_modified();
+      }
+      else {
+        PopulateShaderGraph(*network);
+      }
+    }
+#endif
+  }
+
+  if (_shader->is_modified()) {
+    _shader->tag_update(lock.scene);
+  }
+
+  *dirtyBits = DirtyBits::Clean;
+}
+
+void HdCyclesMaterial::UpdateParameters(NodeDesc &nodeDesc,
+                                        const std::map<TfToken, VtValue> &parameters,
+                                        const SdfPath &nodePath)
+{
+  for (const std::pair<TfToken, VtValue> &param : parameters) {
+    VtValue value = param.second;
+
+    // See if the parameter name is in USDPreviewSurface terms, and needs to be converted
+    const UsdToCyclesMapping *inputMapping = nodeDesc.mapping;
+    const std::string inputName = inputMapping ?
+                                      inputMapping->parameterName(param.first, nullptr, &value) :
+                                      param.first.GetString();
+
+    // Find the input to write the parameter value to
+    const SocketType *input = nullptr;
+    for (const SocketType &socket : nodeDesc.node->type->inputs) {
+      if (string_iequals(socket.name.string(), inputName) || socket.ui_name == inputName) {
+        input = &socket;
+        break;
+      }
+    }
+
+    if (!input) {
+      TF_WARN("Could not find parameter '%s' on node '%s' ('%s')",
+              param.first.GetText(),
+              nodePath.GetText(),
+              nodeDesc.node->name.c_str());
+      continue;
+    }
+
+    SetNodeValue(nodeDesc.node, *input, value);
+  }
+}
+
+void HdCyclesMaterial::UpdateParameters(const HdMaterialNetwork &network)
+{
+  for (const HdMaterialNode &nodeEntry : network.nodes) {
+    const SdfPath &nodePath = nodeEntry.path;
+
+    const auto nodeIt = _nodes.find(nodePath);
+    if (nodeIt == _nodes.end()) {
+      TF_RUNTIME_ERROR("Could not update parameters on missing node '%s'", nodePath.GetText());
+      continue;
+    }
+
+    UpdateParameters(nodeIt->second, nodeEntry.parameters, nodePath);
+  }
+}
+
+void HdCyclesMaterial::UpdateParameters(const HdMaterialNetwork2 &network)
+{
+  for (const std::pair<SdfPath, HdMaterialNode2> &nodeEntry : network.nodes) {
+    const SdfPath &nodePath = nodeEntry.first;
+
+    const auto nodeIt = _nodes.find(nodePath);
+    if (nodeIt == _nodes.end()) {
+      TF_RUNTIME_ERROR("Could not update parameters on missing node '%s'", nodePath.GetText());
+      continue;
+    }
+
+    UpdateParameters(nodeIt->second, nodeEntry.second.parameters, nodePath);
+  }
+}
+
+void HdCyclesMaterial::UpdateConnections(NodeDesc &nodeDesc,
+                                         const HdMaterialNode2 &matNode,
+                                         const SdfPath &nodePath,
+                                         ShaderGraph *shaderGraph)
+{
+  for (const std::pair<TfToken, std::vector<HdMaterialConnection2>> &connection :
+       matNode.inputConnections) {
+    const TfToken &dstSocketName = connection.first;
+
+    const UsdToCyclesMapping *inputMapping = nodeDesc.mapping;
+    const std::string inputName = inputMapping ?
+                                      inputMapping->parameterName(dstSocketName, nullptr) :
+                                      dstSocketName.GetString();
+
+    // Find the input to connect to on the passed in node
+    ShaderInput *input = nullptr;
+    for (ShaderInput *in : nodeDesc.node->inputs) {
+      if (string_iequals(in->socket_type.name.string(), inputName)) {
+        input = in;
+        break;
+      }
+    }
+
+    if (!input) {
+      TF_WARN("Ignoring connection on '%s.%s', input '%s' was not found",
+              nodePath.GetText(),
+              dstSocketName.GetText(),
+              dstSocketName.GetText());
+      continue;
+    }
+
+    // Now find the output to connect from
+    const auto &connectedNodes = connection.second;
+    if (connectedNodes.empty()) {
+      continue;
+    }
+
+    // TODO: Hydra allows multiple connections of the same input
+    //       Unsure how to handle this in Cycles, so just use the first
+    if (connectedNodes.size() > 1) {
+      TF_WARN(
+          "Ignoring multiple connections to '%s.%s'", nodePath.GetText(), dstSocketName.GetText());
+    }
+
+    const SdfPath &upstreamNodePath = connectedNodes.front().upstreamNode;
+    const TfToken &upstreamOutputName = connectedNodes.front().upstreamOutputName;
+
+    const auto srcNodeIt = _nodes.find(upstreamNodePath);
+    if (srcNodeIt == _nodes.end()) {
+      TF_WARN("Ignoring connection from '%s.%s' to '%s.%s', node '%s' was not found",
+              upstreamNodePath.GetText(),
+              upstreamOutputName.GetText(),
+              nodePath.GetText(),
+              dstSocketName.GetText(),
+              upstreamNodePath.GetText());
+      continue;
+    }
+
+    const UsdToCyclesMapping *outputMapping = srcNodeIt->second.mapping;
+    const std::string outputName = outputMapping ?
+                                       outputMapping->parameterName(upstreamOutputName, input) :
+                                       upstreamOutputName.GetString();
+
+    ShaderOutput *output = nullptr;
+    for (ShaderOutput *out : srcNodeIt->second.node->outputs) {
+      if (string_iequals(out->socket_type.name.string(), outputName)) {
+        output = out;
+        break;
+      }
+    }
+
+    if (!output) {
+      TF_WARN("Ignoring connection from '%s.%s' to '%s.%s', output '%s' was not found",
+              upstreamNodePath.GetText(),
+              upstreamOutputName.GetText(),
+              nodePath.GetText(),
+              dstSocketName.GetText(),
+              upstreamOutputName.GetText());
+      continue;
+    }
+
+    shaderGraph->connect(output, input);
+  }
+}
+
+void HdCyclesMaterial::PopulateShaderGraph(const HdMaterialNetwork2 &networkMap)
+{
+  _nodes.clear();
+
+  auto graph = new ShaderGraph();
+
+  // Iterate all the nodes first and build a complete but unconnected graph with parameters set
+  for (const std::pair<SdfPath, HdMaterialNode2> &nodeEntry : networkMap.nodes) {
+    NodeDesc nodeDesc = {};
+    const SdfPath &nodePath = nodeEntry.first;
+
+    const auto nodeIt = _nodes.find(nodePath);
+    // Create new node only if it does not exist yet
+    if (nodeIt != _nodes.end()) {
+      nodeDesc = nodeIt->second;
+    }
+    else {
+      // E.g. cycles_principled_bsdf or UsdPreviewSurface
+      const std::string &nodeTypeId = nodeEntry.second.nodeTypeId.GetString();
+
+      ustring cyclesType(nodeTypeId);
+      // Interpret a node type ID prefixed with cycles_<type> or cycles:<type> as a node of <type>
+      if (nodeTypeId.rfind("cycles", 0) == 0) {
+        cyclesType = nodeTypeId.substr(7);
+        nodeDesc.mapping = sUsdToCyles->findCycles(cyclesType);
+      }
+      else {
+        // Check if any remapping is needed (e.g. for USDPreviewSurface to Cycles nodes)
+        nodeDesc.mapping = sUsdToCyles->findUsd(nodeEntry.second.nodeTypeId);
+        if (nodeDesc.mapping) {
+          cyclesType = nodeDesc.mapping->nodeType();
+        }
+      }
+
+      // If it's a native Cycles' node-type, just do the lookup now.
+      if (const NodeType *nodeType = NodeType::find(cyclesType)) {
+        nodeDesc.node = static_cast<ShaderNode *>(nodeType->create(nodeType));
+        nodeDesc.node->set_owner(graph);
+
+        graph->add(nodeDesc.node);
+
+        _nodes.emplace(nodePath, nodeDesc);
+      }
+      else {
+        TF_RUNTIME_ERROR("Could not create node '%s'", nodePath.GetText());
+        continue;
+      }
+    }
+
+    UpdateParameters(nodeDesc, nodeEntry.second.parameters, nodePath);
+  }
+
+  // Now that all nodes have been constructed, iterate the network again and build up any
+  // connections between nodes
+  for (const std::pair<SdfPath, HdMaterialNode2> &nodeEntry : networkMap.nodes) {
+    const SdfPath &nodePath = nodeEntry.first;
+
+    const auto nodeIt = _nodes.find(nodePath);
+    if (nodeIt == _nodes.end()) {
+      TF_RUNTIME_ERROR("Could not find node '%s' to connect", nodePath.GetText());
+      continue;
+    }
+
+    UpdateConnections(nodeIt->second, nodeEntry.second, nodePath, graph);
+  }
+
+  // Finally connect the terminals to the graph output (Surface, Volume, Displacement)
+  for (const std::pair<TfToken, HdMaterialConnection2> &terminalEntry : networkMap.terminals) {
+    const TfToken &terminalName = terminalEntry.first;
+    const HdMaterialConnection2 &connection = terminalEntry.second;
+
+    const auto nodeIt = _nodes.find(connection.upstreamNode);
+    if (nodeIt == _nodes.end()) {
+      TF_RUNTIME_ERROR("Could not find terminal node '%s'", connection.upstreamNode.GetText());
+      continue;
+    }
+
+    ShaderNode *const node = nodeIt->second.node;
+
+    const char *inputName = nullptr;
+    const char *outputName = nullptr;
+    if (terminalName == HdMaterialTerminalTokens->surface ||
+        terminalName == CyclesMaterialTokens->cyclesSurface) {
+      inputName = "Surface";
+      // Find default output name based on the node if none is provided
+      if (node->type->name == "add_closure" || node->type->name == "mix_closure") {
+        outputName = "Closure";
+      }
+      else if (node->type->name == "emission") {
+        outputName = "Emission";
+      }
+      else {
+        outputName = "BSDF";
+      }
+    }
+    else if (terminalName == HdMaterialTerminalTokens->displacement ||
+             terminalName == CyclesMaterialTokens->cyclesDisplacement) {
+      inputName = outputName = "Displacement";
+    }
+    else if (terminalName == HdMaterialTerminalTokens->volume ||
+             terminalName == CyclesMaterialTokens->cyclesVolume) {
+      inputName = outputName = "Volume";
+    }
+
+    if (!connection.upstreamOutputName.IsEmpty()) {
+      outputName = connection.upstreamOutputName.GetText();
+    }
+
+    ShaderInput *const input = inputName ? graph->output()->input(inputName) : nullptr;
+    if (!input) {
+      TF_RUNTIME_ERROR("Could not find terminal input '%s.%s'",
+                       connection.upstreamNode.GetText(),
+                       inputName ? inputName : "<null>");
+      continue;
+    }
+
+    ShaderOutput *const output = outputName ? node->output(outputName) : nullptr;
+    if (!output) {
+      TF_RUNTIME_ERROR("Could not find terminal output '%s.%s'",
+                       connection.upstreamNode.GetText(),
+                       outputName ? outputName : "<null>");
+      continue;
+    }
+
+    graph->connect(output, input);
+  }
+
+  // Create the instanceId AOV output
+  {
+    const ustring instanceId(HdAovTokens->instanceId.GetString());
+
+    OutputAOVNode *aovNode = graph->create_node<OutputAOVNode>();
+    aovNode->set_name(instanceId);
+    graph->add(aovNode);
+
+    AttributeNode *instanceIdNode = graph->create_node<AttributeNode>();
+    instanceIdNode->set_attribute(instanceId);
+    graph->add(instanceIdNode);
+
+    graph->connect(instanceIdNode->output("Fac"), aovNode->input("Value"));
+  }
+
+  _shader->set_graph(graph);
+}
+
+void HdCyclesMaterial::Finalize(HdRenderParam *renderParam)
+{
+  if (!_shader) {
+    return;
+  }
+
+  const SceneLock lock(renderParam);
+
+  _nodes.clear();
+
+  lock.scene->delete_node(_shader);
+  _shader = nullptr;
+}
+
+void HdCyclesMaterial::Initialize(HdRenderParam *renderParam)
+{
+  if (_shader) {
+    return;
+  }
+
+  const SceneLock lock(renderParam);
+
+  _shader = lock.scene->create_node<Shader>();
+}
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/material.h

@@ -0,0 +1,60 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#pragma once
+
+#include "hydra/config.h"
+
+#include <pxr/imaging/hd/material.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+class HdCyclesMaterial final : public PXR_NS::HdMaterial {
+ public:
+  HdCyclesMaterial(const PXR_NS::SdfPath &sprimId);
+  ~HdCyclesMaterial() override;
+
+  PXR_NS::HdDirtyBits GetInitialDirtyBitsMask() const override;
+
+  void Sync(PXR_NS::HdSceneDelegate *sceneDelegate,
+            PXR_NS::HdRenderParam *renderParam,
+            PXR_NS::HdDirtyBits *dirtyBits) override;
+
+#if PXR_VERSION < 2011
+  void Reload() override
+  {
+  }
+#endif
+
+  void Finalize(PXR_NS::HdRenderParam *renderParam) override;
+
+  CCL_NS::Shader *GetCyclesShader() const
+  {
+    return _shader;
+  }
+
+  struct NodeDesc;
+
+ private:
+  void Initialize(PXR_NS::HdRenderParam *renderParam);
+
+  void UpdateParameters(NodeDesc &nodeDesc,
+                        const std::map<PXR_NS::TfToken, PXR_NS::VtValue> &parameters,
+                        const PXR_NS::SdfPath &nodePath);
+
+  void UpdateParameters(const PXR_NS::HdMaterialNetwork &network);
+  void UpdateParameters(const PXR_NS::HdMaterialNetwork2 &network);
+
+  void UpdateConnections(NodeDesc &nodeDesc,
+                         const PXR_NS::HdMaterialNode2 &matNode,
+                         const PXR_NS::SdfPath &nodePath,
+                         CCL_NS::ShaderGraph *shaderGraph);
+
+  void PopulateShaderGraph(const PXR_NS::HdMaterialNetwork2 &network);
+
+  CCL_NS::Shader *_shader = nullptr;
+  std::unordered_map<PXR_NS::SdfPath, NodeDesc, PXR_NS::SdfPath::Hash> _nodes;
+};
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/mesh.cpp

@@ -0,0 +1,524 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#include "hydra/mesh.h"
+#include "hydra/geometry.inl"
+#include "scene/mesh.h"
+
+#include <pxr/base/gf/vec2f.h>
+#include <pxr/imaging/hd/extComputationUtils.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+namespace {
+
+template<typename T>
+VtValue ComputeTriangulatedUniformPrimvar(VtValue value, const VtIntArray &primitiveParams)
+{
+  T output;
+  output.reserve(primitiveParams.size());
+  const T &input = value.Get<T>();
+
+  for (size_t i = 0; i < primitiveParams.size(); ++i) {
+    const int faceIndex = HdMeshUtil::DecodeFaceIndexFromCoarseFaceParam(primitiveParams[i]);
+
+    output.push_back(input[faceIndex]);
+  }
+
+  return VtValue(output);
+}
+
+VtValue ComputeTriangulatedUniformPrimvar(VtValue value,
+                                          const HdType valueType,
+                                          const VtIntArray &primitiveParams)
+{
+  switch (valueType) {
+    case HdTypeFloat:
+      return ComputeTriangulatedUniformPrimvar<VtFloatArray>(value, primitiveParams);
+    case HdTypeFloatVec2:
+      return ComputeTriangulatedUniformPrimvar<VtVec2fArray>(value, primitiveParams);
+    case HdTypeFloatVec3:
+      return ComputeTriangulatedUniformPrimvar<VtVec3fArray>(value, primitiveParams);
+    case HdTypeFloatVec4:
+      return ComputeTriangulatedUniformPrimvar<VtVec4fArray>(value, primitiveParams);
+    default:
+      TF_RUNTIME_ERROR("Unsupported attribute type %d", static_cast<int>(valueType));
+      return VtValue();
+  }
+}
+
+VtValue ComputeTriangulatedFaceVaryingPrimvar(VtValue value,
+                                              const HdType valueType,
+                                              HdMeshUtil &meshUtil)
+{
+  if (meshUtil.ComputeTriangulatedFaceVaryingPrimvar(
+          HdGetValueData(value), value.GetArraySize(), valueType, &value)) {
+    return value;
+  }
+
+  return VtValue();
+}
+
+}  // namespace
+
+Transform convert_transform(const GfMatrix4d &matrix)
+{
+  return make_transform(matrix[0][0],
+                        matrix[1][0],
+                        matrix[2][0],
+                        matrix[3][0],
+                        matrix[0][1],
+                        matrix[1][1],
+                        matrix[2][1],
+                        matrix[3][1],
+                        matrix[0][2],
+                        matrix[1][2],
+                        matrix[2][2],
+                        matrix[3][2]);
+}
+
+HdCyclesMesh::HdCyclesMesh(const SdfPath &rprimId
+#if PXR_VERSION < 2102
+                           ,
+                           const SdfPath &instancerId
+#endif
+                           )
+    : HdCyclesGeometry(rprimId
+#if PXR_VERSION < 2102
+                       ,
+                       instancerId
+#endif
+                       ),
+      _util(&_topology, rprimId)
+{
+}
+
+HdCyclesMesh::~HdCyclesMesh()
+{
+}
+
+HdDirtyBits HdCyclesMesh::GetInitialDirtyBitsMask() const
+{
+  HdDirtyBits bits = HdCyclesGeometry::GetInitialDirtyBitsMask();
+  bits |= HdChangeTracker::DirtyPoints | HdChangeTracker::DirtyNormals |
+          HdChangeTracker::DirtyPrimvar | HdChangeTracker::DirtyTopology |
+          HdChangeTracker::DirtyDisplayStyle | HdChangeTracker::DirtySubdivTags;
+  return bits;
+}
+
+HdDirtyBits HdCyclesMesh::_PropagateDirtyBits(HdDirtyBits bits) const
+{
+  if (bits & (HdChangeTracker::DirtyMaterialId)) {
+    // Update used shaders from geometry subsets if any exist in the topology
+    bits |= HdChangeTracker::DirtyTopology;
+  }
+
+  if (bits & (HdChangeTracker::DirtyTopology | HdChangeTracker::DirtyDisplayStyle |
+              HdChangeTracker::DirtySubdivTags)) {
+    // Do full topology update when display style or subdivision changes
+    bits |= HdChangeTracker::DirtyTopology | HdChangeTracker::DirtyDisplayStyle |
+            HdChangeTracker::DirtySubdivTags;
+  }
+
+  if (bits & (HdChangeTracker::DirtyTopology)) {
+    // Changing topology clears the geometry, so need to populate everything again
+    bits |= HdChangeTracker::DirtyPoints | HdChangeTracker::DirtyNormals |
+            HdChangeTracker::DirtyPrimvar;
+  }
+
+  return bits;
+}
+
+void HdCyclesMesh::Populate(HdSceneDelegate *sceneDelegate, HdDirtyBits dirtyBits, bool &rebuild)
+{
+  if (HdChangeTracker::IsTopologyDirty(dirtyBits, GetId())) {
+    PopulateTopology(sceneDelegate);
+  }
+
+  if (dirtyBits & HdChangeTracker::DirtyPoints) {
+    PopulatePoints(sceneDelegate);
+  }
+
+  // Must happen after topology update, so that normals attribute size can be calculated
+  if (dirtyBits & HdChangeTracker::DirtyNormals) {
+    PopulateNormals(sceneDelegate);
+  }
+
+  // Must happen after topology update, so that appropriate attribute set can be selected
+  if (dirtyBits & HdChangeTracker::DirtyPrimvar) {
+    PopulatePrimvars(sceneDelegate);
+  }
+
+  rebuild = (_geom->triangles_is_modified()) || (_geom->subd_start_corner_is_modified()) ||
+            (_geom->subd_num_corners_is_modified()) || (_geom->subd_shader_is_modified()) ||
+            (_geom->subd_smooth_is_modified()) || (_geom->subd_ptex_offset_is_modified()) ||
+            (_geom->subd_face_corners_is_modified());
+}
+
+void HdCyclesMesh::PopulatePoints(HdSceneDelegate *sceneDelegate)
+{
+  VtValue value;
+
+  for (const HdExtComputationPrimvarDescriptor &desc :
+       sceneDelegate->GetExtComputationPrimvarDescriptors(GetId(), HdInterpolationVertex)) {
+    if (desc.name == HdTokens->points) {
+      auto valueStore = HdExtComputationUtils::GetComputedPrimvarValues({desc}, sceneDelegate);
+      const auto valueStoreIt = valueStore.find(desc.name);
+      if (valueStoreIt != valueStore.end()) {
+        value = std::move(valueStoreIt->second);
+      }
+      break;
+    }
+  }
+
+  if (value.IsEmpty()) {
+    value = GetPoints(sceneDelegate);
+  }
+
+  if (!value.IsHolding<VtVec3fArray>()) {
+    TF_WARN("Invalid points data for %s", GetId().GetText());
+    return;
+  }
+
+  const auto &points = value.UncheckedGet<VtVec3fArray>();
+
+  TF_VERIFY(points.size() >= static_cast<size_t>(_topology.GetNumPoints()));
+
+  array<float3> pointsDataCycles;
+  pointsDataCycles.reserve(points.size());
+  for (const GfVec3f &point : points) {
+    pointsDataCycles.push_back_reserved(make_float3(point[0], point[1], point[2]));
+  }
+
+  _geom->set_verts(pointsDataCycles);
+}
+
+void HdCyclesMesh::PopulateNormals(HdSceneDelegate *sceneDelegate)
+{
+  _geom->attributes.remove(ATTR_STD_FACE_NORMAL);
+  _geom->attributes.remove(ATTR_STD_VERTEX_NORMAL);
+
+  // Authored normals should only exist on triangle meshes
+  if (_geom->get_subdivision_type() != Mesh::SUBDIVISION_NONE) {
+    return;
+  }
+
+  VtValue value;
+  HdInterpolation interpolation = HdInterpolationCount;
+
+  for (int i = 0; i < HdInterpolationCount && interpolation == HdInterpolationCount; ++i) {
+    for (const HdExtComputationPrimvarDescriptor &desc :
+         sceneDelegate->GetExtComputationPrimvarDescriptors(GetId(),
+                                                            static_cast<HdInterpolation>(i))) {
+      if (desc.name == HdTokens->normals) {
+        auto valueStore = HdExtComputationUtils::GetComputedPrimvarValues({desc}, sceneDelegate);
+        const auto valueStoreIt = valueStore.find(desc.name);
+        if (valueStoreIt != valueStore.end()) {
+          value = std::move(valueStoreIt->second);
+          interpolation = static_cast<HdInterpolation>(i);
+        }
+        break;
+      }
+    }
+  }
+
+  if (value.IsEmpty()) {
+    interpolation = GetPrimvarInterpolation(sceneDelegate, HdTokens->normals);
+    if (interpolation == HdInterpolationCount) {
+      return;  // Ignore missing normals
+    }
+
+    value = GetNormals(sceneDelegate);
+  }
+
+  if (!value.IsHolding<VtVec3fArray>()) {
+    TF_WARN("Invalid normals data for %s", GetId().GetText());
+    return;
+  }
+
+  const auto &normals = value.UncheckedGet<VtVec3fArray>();
+
+  if (interpolation == HdInterpolationConstant) {
+    TF_VERIFY(normals.size() == 1);
+
+    const GfVec3f constantNormal = normals[0];
+
+    float3 *const N = _geom->attributes.add(ATTR_STD_VERTEX_NORMAL)->data_float3();
+    for (size_t i = 0; i < _geom->get_verts().size(); ++i) {
+      N[i] = make_float3(constantNormal[0], constantNormal[1], constantNormal[2]);
+    }
+  }
+  else if (interpolation == HdInterpolationUniform) {
+    TF_VERIFY(normals.size() == static_cast<size_t>(_topology.GetNumFaces()));
+
+    float3 *const N = _geom->attributes.add(ATTR_STD_FACE_NORMAL)->data_float3();
+    for (size_t i = 0; i < _geom->num_triangles(); ++i) {
+      const int faceIndex = HdMeshUtil::DecodeFaceIndexFromCoarseFaceParam(_primitiveParams[i]);
+
+      N[i] = make_float3(normals[faceIndex][0], normals[faceIndex][1], normals[faceIndex][2]);
+    }
+  }
+  else if (interpolation == HdInterpolationVertex || interpolation == HdInterpolationVarying) {
+    TF_VERIFY(normals.size() == static_cast<size_t>(_topology.GetNumPoints()) &&
+              static_cast<size_t>(_topology.GetNumPoints()) == _geom->get_verts().size());
+
+    float3 *const N = _geom->attributes.add(ATTR_STD_VERTEX_NORMAL)->data_float3();
+    for (size_t i = 0; i < _geom->get_verts().size(); ++i) {
+      N[i] = make_float3(normals[i][0], normals[i][1], normals[i][2]);
+    }
+  }
+  else if (interpolation == HdInterpolationFaceVarying) {
+    TF_VERIFY(normals.size() == static_cast<size_t>(_topology.GetNumFaceVaryings()));
+
+    if (!_util.ComputeTriangulatedFaceVaryingPrimvar(
+            normals.data(), normals.size(), HdTypeFloatVec3, &value)) {
+      return;
+    }
+
+    const auto &normalsTriangulated = value.UncheckedGet<VtVec3fArray>();
+
+    // Cycles has no standard attribute for face-varying normals, so this is a lossy transformation
+    float3 *const N = _geom->attributes.add(ATTR_STD_FACE_NORMAL)->data_float3();
+    for (size_t i = 0; i < _geom->num_triangles(); ++i) {
+      GfVec3f averageNormal = normalsTriangulated[i * 3] + normalsTriangulated[i * 3 + 1] +
+                              normalsTriangulated[i * 3 + 2];
+      GfNormalize(&averageNormal);
+
+      N[i] = make_float3(averageNormal[0], averageNormal[1], averageNormal[2]);
+    }
+  }
+}
+
+void HdCyclesMesh::PopulatePrimvars(HdSceneDelegate *sceneDelegate)
+{
+  Scene *const scene = (Scene *)_geom->get_owner();
+
+  const bool subdivision = _geom->get_subdivision_type() != Mesh::SUBDIVISION_NONE;
+  AttributeSet &attributes = subdivision ? _geom->subd_attributes : _geom->attributes;
+
+  const std::pair<HdInterpolation, AttributeElement> interpolations[] = {
+      std::make_pair(HdInterpolationFaceVarying, ATTR_ELEMENT_CORNER),
+      std::make_pair(HdInterpolationUniform, ATTR_ELEMENT_FACE),
+      std::make_pair(HdInterpolationVertex, ATTR_ELEMENT_VERTEX),
+      std::make_pair(HdInterpolationVarying, ATTR_ELEMENT_VERTEX),
+      std::make_pair(HdInterpolationConstant, ATTR_ELEMENT_OBJECT),
+  };
+
+  for (const auto &interpolation : interpolations) {
+    for (const HdPrimvarDescriptor &desc :
+         GetPrimvarDescriptors(sceneDelegate, interpolation.first)) {
+      // Skip special primvars that are handled separately
+      if (desc.name == HdTokens->points || desc.name == HdTokens->normals) {
+        continue;
+      }
+
+      VtValue value = GetPrimvar(sceneDelegate, desc.name);
+      if (value.IsEmpty()) {
+        continue;
+      }
+
+      const ustring name(desc.name.GetString());
+
+      AttributeStandard std = ATTR_STD_NONE;
+      if (desc.role == HdPrimvarRoleTokens->textureCoordinate) {
+        std = ATTR_STD_UV;
+      }
+      else if (interpolation.first == HdInterpolationVertex) {
+        if (desc.name == HdTokens->displayColor || desc.role == HdPrimvarRoleTokens->color) {
+          std = ATTR_STD_VERTEX_COLOR;
+        }
+        else if (desc.name == HdTokens->normals) {
+          std = ATTR_STD_VERTEX_NORMAL;
+        }
+      }
+      else if (desc.name == HdTokens->displayColor &&
+               interpolation.first == HdInterpolationConstant) {
+        if (value.IsHolding<VtVec3fArray>() && value.GetArraySize() == 1) {
+          const GfVec3f color = value.UncheckedGet<VtVec3fArray>()[0];
+          _instances[0]->set_color(make_float3(color[0], color[1], color[2]));
+        }
+      }
+
+      // Skip attributes that are not needed
+      if ((std != ATTR_STD_NONE && _geom->need_attribute(scene, std)) ||
+          _geom->need_attribute(scene, name)) {
+        const HdType valueType = HdGetValueTupleType(value).type;
+
+        if (!subdivision) {
+          // Adjust attributes for polygons that were triangulated
+          if (interpolation.first == HdInterpolationUniform) {
+            value = ComputeTriangulatedUniformPrimvar(value, valueType, _primitiveParams);
+            if (value.IsEmpty()) {
+              continue;
+            }
+          }
+          else if (interpolation.first == HdInterpolationFaceVarying) {
+            value = ComputeTriangulatedFaceVaryingPrimvar(value, valueType, _util);
+            if (value.IsEmpty()) {
+              continue;
+            }
+          }
+        }
+
+        ApplyPrimvars(attributes, name, value, interpolation.second, std);
+      }
+    }
+  }
+}
+
+void HdCyclesMesh::PopulateTopology(HdSceneDelegate *sceneDelegate)
+{
+  // Clear geometry before populating it again with updated topology
+  _geom->clear(true);
+
+  const HdDisplayStyle displayStyle = GetDisplayStyle(sceneDelegate);
+  _topology = HdMeshTopology(GetMeshTopology(sceneDelegate), displayStyle.refineLevel);
+
+  const TfToken subdivScheme = _topology.GetScheme();
+  if (subdivScheme == PxOsdOpenSubdivTokens->bilinear && _topology.GetRefineLevel() > 0) {
+    _geom->set_subdivision_type(Mesh::SUBDIVISION_LINEAR);
+  }
+  else if (subdivScheme == PxOsdOpenSubdivTokens->catmullClark && _topology.GetRefineLevel() > 0) {
+    _geom->set_subdivision_type(Mesh::SUBDIVISION_CATMULL_CLARK);
+  }
+  else {
+    _geom->set_subdivision_type(Mesh::SUBDIVISION_NONE);
+  }
+
+  const bool smooth = !displayStyle.flatShadingEnabled;
+  const bool subdivision = _geom->get_subdivision_type() != Mesh::SUBDIVISION_NONE;
+
+  // Initialize lookup table from polygon face to material shader index
+  VtIntArray faceShaders(_topology.GetNumFaces(), 0);
+
+  HdGeomSubsets const &geomSubsets = _topology.GetGeomSubsets();
+  if (!geomSubsets.empty()) {
+    array<Node *> usedShaders = std::move(_geom->get_used_shaders());
+    // Remove any previous materials except for the material assigned to the prim
+    usedShaders.resize(1);
+
+    std::unordered_map<SdfPath, int, SdfPath::Hash> materials;
+
+    for (const HdGeomSubset &geomSubset : geomSubsets) {
+      TF_VERIFY(geomSubset.type == HdGeomSubset::TypeFaceSet);
+
+      int shader = 0;
+      const auto it = materials.find(geomSubset.materialId);
+      if (it != materials.end()) {
+        shader = it->second;
+      }
+      else {
+        const auto material = static_cast<const HdCyclesMaterial *>(
+            sceneDelegate->GetRenderIndex().GetSprim(HdPrimTypeTokens->material,
+                                                     geomSubset.materialId));
+
+        if (material && material->GetCyclesShader()) {
+          shader = static_cast<int>(usedShaders.size());
+          usedShaders.push_back_slow(material->GetCyclesShader());
+
+          materials.emplace(geomSubset.materialId, shader);
+        }
+      }
+
+      for (int face : geomSubset.indices) {
+        faceShaders[face] = shader;
+      }
+    }
+
+    _geom->set_used_shaders(usedShaders);
+  }
+
+  const VtIntArray vertIndx = _topology.GetFaceVertexIndices();
+  const VtIntArray vertCounts = _topology.GetFaceVertexCounts();
+
+  if (!subdivision) {
+    VtVec3iArray triangles;
+    _util.ComputeTriangleIndices(&triangles, &_primitiveParams);
+
+    _geom->reserve_mesh(_topology.GetNumPoints(), triangles.size());
+
+    for (size_t i = 0; i < _primitiveParams.size(); ++i) {
+      const int faceIndex = HdMeshUtil::DecodeFaceIndexFromCoarseFaceParam(_primitiveParams[i]);
+
+      const GfVec3i triangle = triangles[i];
+      _geom->add_triangle(triangle[0], triangle[1], triangle[2], faceShaders[faceIndex], smooth);
+    }
+  }
+  else {
+    PxOsdSubdivTags subdivTags = GetSubdivTags(sceneDelegate);
+    _topology.SetSubdivTags(subdivTags);
+
+    size_t numNgons = 0;
+    size_t numCorners = 0;
+    for (int vertCount : vertCounts) {
+      numNgons += (vertCount == 4) ? 0 : 1;
+      numCorners += vertCount;
+    }
+
+    _geom->reserve_subd_faces(_topology.GetNumFaces(), numNgons, numCorners);
+
+    // TODO: Handle hole indices
+    size_t faceIndex = 0;
+    size_t indexOffset = 0;
+    for (int vertCount : vertCounts) {
+      _geom->add_subd_face(&vertIndx[indexOffset], vertCount, faceShaders[faceIndex], smooth);
+
+      faceIndex++;
+      indexOffset += vertCount;
+    }
+
+    const VtIntArray creaseLengths = subdivTags.GetCreaseLengths();
+    if (!creaseLengths.empty()) {
+      size_t numCreases = 0;
+      for (int creaseLength : creaseLengths) {
+        numCreases += creaseLength - 1;
+      }
+
+      _geom->reserve_subd_creases(numCreases);
+
+      const VtIntArray creaseIndices = subdivTags.GetCreaseIndices();
+      const VtFloatArray creaseWeights = subdivTags.GetCreaseWeights();
+
+      indexOffset = 0;
+      size_t creaseLengthOffset = 0;
+      size_t createWeightOffset = 0;
+      for (int creaseLength : creaseLengths) {
+        for (int j = 0; j < creaseLength - 1; ++j, ++createWeightOffset) {
+          const int v0 = creaseIndices[indexOffset + j];
+          const int v1 = creaseIndices[indexOffset + j + 1];
+
+          float weight = creaseWeights.size() == creaseLengths.size() ?
+                             creaseWeights[creaseLengthOffset] :
+                             creaseWeights[createWeightOffset];
+
+          _geom->add_edge_crease(v0, v1, weight);
+        }
+
+        indexOffset += creaseLength;
+        creaseLengthOffset++;
+      }
+
+      const VtIntArray cornerIndices = subdivTags.GetCornerIndices();
+      const VtFloatArray cornerWeights = subdivTags.GetCornerWeights();
+
+      for (size_t i = 0; i < cornerIndices.size(); ++i) {
+        _geom->add_vertex_crease(cornerIndices[i], cornerWeights[i]);
+      }
+    }
+
+    _geom->set_subd_dicing_rate(1.0f);
+    _geom->set_subd_max_level(_topology.GetRefineLevel());
+    _geom->set_subd_objecttoworld(_instances[0]->get_tfm());
+  }
+}
+
+void HdCyclesMesh::Finalize(PXR_NS::HdRenderParam *renderParam)
+{
+  _topology = HdMeshTopology();
+  _primitiveParams.clear();
+
+  HdCyclesGeometry<PXR_NS::HdMesh, Mesh>::Finalize(renderParam);
+}
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/mesh.h

@@ -0,0 +1,49 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#pragma once
+
+#include "hydra/config.h"
+#include "hydra/geometry.h"
+
+#include <pxr/imaging/hd/mesh.h>
+#include <pxr/imaging/hd/meshUtil.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+class HdCyclesMesh final : public HdCyclesGeometry<PXR_NS::HdMesh, CCL_NS::Mesh> {
+ public:
+  HdCyclesMesh(
+      const PXR_NS::SdfPath &rprimId
+#if PXR_VERSION < 2102
+      ,
+      const PXR_NS::SdfPath &instancerId = {}
+#endif
+  );
+  ~HdCyclesMesh() override;
+
+  PXR_NS::HdDirtyBits GetInitialDirtyBitsMask() const override;
+
+  void Finalize(PXR_NS::HdRenderParam *renderParam) override;
+
+ private:
+  PXR_NS::HdDirtyBits _PropagateDirtyBits(PXR_NS::HdDirtyBits bits) const override;
+
+  void Populate(PXR_NS::HdSceneDelegate *sceneDelegate,
+                PXR_NS::HdDirtyBits dirtyBits,
+                bool &rebuild) override;
+
+  void PopulatePoints(PXR_NS::HdSceneDelegate *sceneDelegate);
+  void PopulateNormals(PXR_NS::HdSceneDelegate *sceneDelegate);
+
+  void PopulatePrimvars(PXR_NS::HdSceneDelegate *sceneDelegate);
+
+  void PopulateTopology(PXR_NS::HdSceneDelegate *sceneDelegate);
+
+  PXR_NS::HdMeshUtil _util;
+  PXR_NS::HdMeshTopology _topology;
+  PXR_NS::VtIntArray _primitiveParams;
+};
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/node_util.cpp

@@ -0,0 +1,561 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#include "hydra/node_util.h"
+#include "util/transform.h"
+
+#include <pxr/base/gf/matrix3d.h>
+#include <pxr/base/gf/matrix3f.h>
+#include <pxr/base/gf/matrix4d.h>
+#include <pxr/base/gf/matrix4f.h>
+#include <pxr/base/gf/vec2f.h>
+#include <pxr/base/gf/vec3f.h>
+#include <pxr/base/vt/array.h>
+#include <pxr/usd/sdf/assetPath.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+namespace {
+
+template<typename DstType> DstType convertToCycles(const VtValue &value)
+{
+  if (value.IsHolding<DstType>()) {
+    return value.UncheckedGet<DstType>();
+  }
+
+  VtValue castedValue = VtValue::Cast<DstType>(value);
+  if (castedValue.IsHolding<DstType>()) {
+    return castedValue.UncheckedGet<DstType>();
+  }
+
+  TF_WARN("Could not convert VtValue to Cycles type");
+  return DstType(0);
+}
+
+template<> float2 convertToCycles<float2>(const VtValue &value)
+{
+  const GfVec2f convertedValue = convertToCycles<GfVec2f>(value);
+  return make_float2(convertedValue[0], convertedValue[1]);
+}
+
+template<> float3 convertToCycles<float3>(const VtValue &value)
+{
+  if (value.IsHolding<GfVec3f>()) {
+    const GfVec3f convertedValue = value.UncheckedGet<GfVec3f>();
+    return make_float3(convertedValue[0], convertedValue[1], convertedValue[2]);
+  }
+  if (value.IsHolding<GfVec4f>()) {
+    const GfVec4f convertedValue = value.UncheckedGet<GfVec4f>();
+    return make_float3(convertedValue[0], convertedValue[1], convertedValue[2]);
+  }
+
+  if (value.CanCast<GfVec3f>()) {
+    const GfVec3f convertedValue = VtValue::Cast<GfVec3f>(value).UncheckedGet<GfVec3f>();
+    return make_float3(convertedValue[0], convertedValue[1], convertedValue[2]);
+  }
+  if (value.CanCast<GfVec4f>()) {
+    const GfVec4f convertedValue = VtValue::Cast<GfVec4f>(value).UncheckedGet<GfVec4f>();
+    return make_float3(convertedValue[0], convertedValue[1], convertedValue[2]);
+  }
+
+  TF_WARN("Could not convert VtValue to float3");
+  return zero_float3();
+}
+
+template<> ustring convertToCycles<ustring>(const VtValue &value)
+{
+  if (value.IsHolding<TfToken>()) {
+    return ustring(value.UncheckedGet<TfToken>().GetString());
+  }
+  if (value.IsHolding<std::string>()) {
+    return ustring(value.UncheckedGet<std::string>());
+  }
+  if (value.IsHolding<SdfAssetPath>()) {
+    const SdfAssetPath &path = value.UncheckedGet<SdfAssetPath>();
+    return ustring(path.GetResolvedPath());
+  }
+
+  if (value.CanCast<TfToken>()) {
+    return convertToCycles<ustring>(VtValue::Cast<TfToken>(value));
+  }
+  if (value.CanCast<std::string>()) {
+    return convertToCycles<ustring>(VtValue::Cast<std::string>(value));
+  }
+  if (value.CanCast<SdfAssetPath>()) {
+    return convertToCycles<ustring>(VtValue::Cast<SdfAssetPath>(value));
+  }
+
+  TF_WARN("Could not convert VtValue to ustring");
+  return ustring();
+}
+
+template<typename Matrix>
+Transform convertMatrixToCycles(
+    const typename std::enable_if<Matrix::numRows == 3 && Matrix::numColumns == 3, Matrix>::type
+        &matrix)
+{
+  return make_transform(matrix[0][0],
+                        matrix[1][0],
+                        matrix[2][0],
+                        0,
+                        matrix[0][1],
+                        matrix[1][1],
+                        matrix[2][1],
+                        0,
+                        matrix[0][2],
+                        matrix[1][2],
+                        matrix[2][2],
+                        0);
+}
+
+template<typename Matrix>
+Transform convertMatrixToCycles(
+    const typename std::enable_if<Matrix::numRows == 4 && Matrix::numColumns == 4, Matrix>::type
+        &matrix)
+{
+  return make_transform(matrix[0][0],
+                        matrix[1][0],
+                        matrix[2][0],
+                        matrix[3][0],
+                        matrix[0][1],
+                        matrix[1][1],
+                        matrix[2][1],
+                        matrix[3][1],
+                        matrix[0][2],
+                        matrix[1][2],
+                        matrix[2][2],
+                        matrix[3][2]);
+}
+
+template<> Transform convertToCycles<Transform>(const VtValue &value)
+{
+  if (value.IsHolding<GfMatrix4f>()) {
+    return convertMatrixToCycles<GfMatrix4f>(value.UncheckedGet<GfMatrix4f>());
+  }
+  if (value.IsHolding<GfMatrix3f>()) {
+    return convertMatrixToCycles<GfMatrix3f>(value.UncheckedGet<GfMatrix3f>());
+  }
+  if (value.IsHolding<GfMatrix4d>()) {
+    return convertMatrixToCycles<GfMatrix4d>(value.UncheckedGet<GfMatrix4d>());
+  }
+  if (value.IsHolding<GfMatrix3d>()) {
+    return convertMatrixToCycles<GfMatrix3d>(value.UncheckedGet<GfMatrix3d>());
+  }
+
+  if (value.CanCast<GfMatrix4f>()) {
+    return convertToCycles<Transform>(VtValue::Cast<GfMatrix4f>(value));
+  }
+  if (value.CanCast<GfMatrix3f>()) {
+    return convertToCycles<Transform>(VtValue::Cast<GfMatrix3f>(value));
+  }
+  if (value.CanCast<GfMatrix4d>()) {
+    return convertToCycles<Transform>(VtValue::Cast<GfMatrix4d>(value));
+  }
+  if (value.CanCast<GfMatrix3d>()) {
+    return convertToCycles<Transform>(VtValue::Cast<GfMatrix3d>(value));
+  }
+
+  TF_WARN("Could not convert VtValue to Transform");
+  return transform_identity();
+}
+
+template<typename DstType, typename SrcType = DstType>
+array<DstType> convertToCyclesArray(const VtValue &value)
+{
+  static_assert(sizeof(DstType) == sizeof(SrcType),
+                "Size mismatch between VtArray and array base type");
+
+  using SrcArray = VtArray<SrcType>;
+
+  if (value.IsHolding<SrcArray>()) {
+    const auto &valueData = value.UncheckedGet<SrcArray>();
+    array<DstType> cyclesArray;
+    cyclesArray.resize(valueData.size());
+    std::memcpy(cyclesArray.data(), valueData.data(), valueData.size() * sizeof(DstType));
+    return cyclesArray;
+  }
+
+  if (value.CanCast<SrcArray>()) {
+    VtValue castedValue = VtValue::Cast<SrcArray>(value);
+    const auto &valueData = castedValue.UncheckedGet<SrcArray>();
+    array<DstType> cyclesArray;
+    cyclesArray.resize(valueData.size());
+    std::memcpy(cyclesArray.data(), valueData.data(), valueData.size() * sizeof(DstType));
+    return cyclesArray;
+  }
+
+  return array<DstType>();
+}
+
+template<> array<float3> convertToCyclesArray<float3, GfVec3f>(const VtValue &value)
+{
+  if (value.IsHolding<VtVec3fArray>()) {
+    const auto &valueData = value.UncheckedGet<VtVec3fArray>();
+    array<float3> cyclesArray;
+    cyclesArray.reserve(valueData.size());
+    for (const GfVec3f &vec : valueData) {
+      cyclesArray.push_back_reserved(make_float3(vec[0], vec[1], vec[2]));
+    }
+    return cyclesArray;
+  }
+  if (value.IsHolding<VtVec4fArray>()) {
+    const auto &valueData = value.UncheckedGet<VtVec4fArray>();
+    array<float3> cyclesArray;
+    cyclesArray.reserve(valueData.size());
+    for (const GfVec4f &vec : valueData) {
+      cyclesArray.push_back_reserved(make_float3(vec[0], vec[1], vec[2]));
+    }
+    return cyclesArray;
+  }
+
+  if (value.CanCast<VtVec3fArray>()) {
+    return convertToCyclesArray<float3, GfVec3f>(VtValue::Cast<VtVec3fArray>(value));
+  }
+  if (value.CanCast<VtVec4fArray>()) {
+    return convertToCyclesArray<float3, GfVec3f>(VtValue::Cast<VtVec4fArray>(value));
+  }
+
+  return array<float3>();
+}
+
+template<> array<ustring> convertToCyclesArray<ustring, void>(const VtValue &value)
+{
+  using SdfPathArray = VtArray<SdfAssetPath>;
+
+  if (value.IsHolding<VtStringArray>()) {
+    const auto &valueData = value.UncheckedGet<VtStringArray>();
+    array<ustring> cyclesArray;
+    cyclesArray.reserve(valueData.size());
+    for (const auto &element : valueData) {
+      cyclesArray.push_back_reserved(ustring(element));
+    }
+    return cyclesArray;
+  }
+  if (value.IsHolding<VtTokenArray>()) {
+    const auto &valueData = value.UncheckedGet<VtTokenArray>();
+    array<ustring> cyclesArray;
+    cyclesArray.reserve(valueData.size());
+    for (const auto &element : valueData) {
+      cyclesArray.push_back_reserved(ustring(element.GetString()));
+    }
+    return cyclesArray;
+  }
+  if (value.IsHolding<SdfPathArray>()) {
+    const auto &valueData = value.UncheckedGet<SdfPathArray>();
+    array<ustring> cyclesArray;
+    cyclesArray.reserve(valueData.size());
+    for (const auto &element : valueData) {
+      cyclesArray.push_back_reserved(ustring(element.GetResolvedPath()));
+    }
+    return cyclesArray;
+  }
+
+  if (value.CanCast<VtStringArray>()) {
+    return convertToCyclesArray<ustring, void>(VtValue::Cast<VtStringArray>(value));
+  }
+  if (value.CanCast<VtTokenArray>()) {
+    return convertToCyclesArray<ustring, void>(VtValue::Cast<VtTokenArray>(value));
+  }
+  if (value.CanCast<SdfPathArray>()) {
+    return convertToCyclesArray<ustring, void>(VtValue::Cast<SdfPathArray>(value));
+  }
+
+  TF_WARN("Could not convert VtValue to array<ustring>");
+  return array<ustring>();
+}
+
+template<typename MatrixArray> array<Transform> convertToCyclesTransformArray(const VtValue &value)
+{
+  assert(value.IsHolding<MatrixArray>());
+
+  const auto &valueData = value.UncheckedGet<MatrixArray>();
+  array<Transform> cyclesArray;
+  cyclesArray.reserve(valueData.size());
+  for (const auto &element : valueData) {
+    cyclesArray.push_back_reserved(convertMatrixToCycles<MatrixArray::value_type>(element));
+  }
+  return cyclesArray;
+}
+
+template<> array<Transform> convertToCyclesArray<Transform, void>(const VtValue &value)
+{
+  if (value.IsHolding<VtMatrix4fArray>()) {
+    return convertToCyclesTransformArray<VtMatrix4fArray>(value);
+  }
+  if (value.IsHolding<VtMatrix3fArray>()) {
+    return convertToCyclesTransformArray<VtMatrix3fArray>(value);
+  }
+  if (value.IsHolding<VtMatrix4dArray>()) {
+    return convertToCyclesTransformArray<VtMatrix4dArray>(value);
+  }
+  if (value.IsHolding<VtMatrix3dArray>()) {
+    return convertToCyclesTransformArray<VtMatrix3dArray>(value);
+  }
+
+  if (value.CanCast<VtMatrix4fArray>()) {
+    return convertToCyclesTransformArray<VtMatrix4fArray>(VtValue::Cast<VtMatrix4fArray>(value));
+  }
+  if (value.CanCast<VtMatrix3fArray>()) {
+    return convertToCyclesTransformArray<VtMatrix3fArray>(VtValue::Cast<VtMatrix3fArray>(value));
+  }
+  if (value.CanCast<VtMatrix4dArray>()) {
+    return convertToCyclesTransformArray<VtMatrix4dArray>(VtValue::Cast<VtMatrix4dArray>(value));
+  }
+  if (value.CanCast<VtMatrix3dArray>()) {
+    return convertToCyclesTransformArray<VtMatrix3dArray>(VtValue::Cast<VtMatrix3dArray>(value));
+  }
+
+  TF_WARN("Could not convert VtValue to array<Transform>");
+  return array<Transform>();
+}
+
+template<typename SrcType> VtValue convertFromCycles(const SrcType &value)
+{
+  return VtValue(value);
+}
+
+template<> VtValue convertFromCycles<float2>(const float2 &value)
+{
+  const GfVec2f convertedValue(value.x, value.y);
+  return VtValue(convertedValue);
+}
+
+template<> VtValue convertFromCycles<float3>(const float3 &value)
+{
+  const GfVec3f convertedValue(value.x, value.y, value.z);
+  return VtValue(convertedValue);
+}
+
+template<> VtValue convertFromCycles<ustring>(const ustring &value)
+{
+  return VtValue(value.string());
+}
+
+GfMatrix4f convertMatrixFromCycles(const Transform &matrix)
+{
+  return GfMatrix4f(matrix[0][0],
+                    matrix[1][0],
+                    matrix[2][0],
+                    0.0f,
+                    matrix[0][1],
+                    matrix[1][1],
+                    matrix[2][1],
+                    0.0f,
+                    matrix[0][2],
+                    matrix[1][2],
+                    matrix[2][2],
+                    0.0f,
+                    0.0f,
+                    0.0f,
+                    0.0f,
+                    1.0f);
+}
+
+template<> VtValue convertFromCycles<Transform>(const Transform &value)
+{
+  return VtValue(convertMatrixFromCycles(value));
+}
+
+template<typename SrcType, typename DstType = SrcType>
+VtValue convertFromCyclesArray(const array<SrcType> &value)
+{
+  static_assert(sizeof(DstType) == sizeof(SrcType),
+                "Size mismatch between VtArray and array base type");
+
+  VtArray<DstType> convertedValue;
+  convertedValue.resize(value.size());
+  std::memcpy(convertedValue.data(), value.data(), value.size() * sizeof(SrcType));
+  return VtValue(convertedValue);
+}
+
+template<> VtValue convertFromCyclesArray<float3, GfVec3f>(const array<float3> &value)
+{
+  VtVec3fArray convertedValue;
+  convertedValue.reserve(value.size());
+  for (const auto &element : value) {
+    convertedValue.push_back(GfVec3f(element.x, element.y, element.z));
+  }
+  return VtValue(convertedValue);
+}
+
+template<> VtValue convertFromCyclesArray<ustring, void>(const array<ustring> &value)
+{
+  VtStringArray convertedValue;
+  convertedValue.reserve(value.size());
+  for (const auto &element : value) {
+    convertedValue.push_back(element.string());
+  }
+  return VtValue(convertedValue);
+}
+
+template<> VtValue convertFromCyclesArray<Transform, void>(const array<Transform> &value)
+{
+  VtMatrix4fArray convertedValue;
+  convertedValue.reserve(value.size());
+  for (const auto &element : value) {
+    convertedValue.push_back(convertMatrixFromCycles(element));
+  }
+  return VtValue(convertedValue);
+}
+
+}  // namespace
+
+void SetNodeValue(Node *node, const SocketType &socket, const VtValue &value)
+{
+  switch (socket.type) {
+    default:
+    case SocketType::UNDEFINED:
+      TF_RUNTIME_ERROR("Unexpected conversion: SocketType::UNDEFINED");
+      break;
+
+    case SocketType::BOOLEAN:
+      node->set(socket, convertToCycles<bool>(value));
+      break;
+    case SocketType::FLOAT:
+      node->set(socket, convertToCycles<float>(value));
+      break;
+    case SocketType::INT:
+      node->set(socket, convertToCycles<int>(value));
+      break;
+    case SocketType::UINT:
+      node->set(socket, convertToCycles<unsigned int>(value));
+      break;
+    case SocketType::COLOR:
+    case SocketType::VECTOR:
+    case SocketType::POINT:
+    case SocketType::NORMAL:
+      node->set(socket, convertToCycles<float3>(value));
+      break;
+    case SocketType::POINT2:
+      node->set(socket, convertToCycles<float2>(value));
+      break;
+    case SocketType::CLOSURE:
+      // Handled by node connections
+      break;
+    case SocketType::STRING:
+      node->set(socket, convertToCycles<ustring>(value));
+      break;
+    case SocketType::ENUM:
+      // Enum's can accept a string or an int
+      if (value.IsHolding<TfToken>() || value.IsHolding<std::string>()) {
+        node->set(socket, convertToCycles<ustring>(value));
+      }
+      else {
+        node->set(socket, convertToCycles<int>(value));
+      }
+      break;
+    case SocketType::TRANSFORM:
+      node->set(socket, convertToCycles<Transform>(value));
+      break;
+    case SocketType::NODE:
+      // TODO: renderIndex->GetRprim()->cycles_node ?
+      TF_WARN("Unimplemented conversion: SocketType::NODE");
+      break;
+
+    case SocketType::BOOLEAN_ARRAY: {
+      auto cyclesArray = convertToCyclesArray<bool>(value);
+      node->set(socket, cyclesArray);
+      break;
+    }
+    case SocketType::FLOAT_ARRAY: {
+      auto cyclesArray = convertToCyclesArray<float>(value);
+      node->set(socket, cyclesArray);
+      break;
+    }
+    case SocketType::INT_ARRAY: {
+      auto cyclesArray = convertToCyclesArray<int>(value);
+      node->set(socket, cyclesArray);
+      break;
+    }
+    case SocketType::COLOR_ARRAY:
+    case SocketType::VECTOR_ARRAY:
+    case SocketType::POINT_ARRAY:
+    case SocketType::NORMAL_ARRAY: {
+      auto cyclesArray = convertToCyclesArray<float3, GfVec3f>(value);
+      node->set(socket, cyclesArray);
+      break;
+    }
+    case SocketType::POINT2_ARRAY: {
+      auto cyclesArray = convertToCyclesArray<float2, GfVec2f>(value);
+      node->set(socket, cyclesArray);
+      break;
+    }
+    case SocketType::STRING_ARRAY: {
+      auto cyclesArray = convertToCyclesArray<ustring, void>(value);
+      node->set(socket, cyclesArray);
+      break;
+    }
+    case SocketType::TRANSFORM_ARRAY: {
+      auto cyclesArray = convertToCyclesArray<Transform, void>(value);
+      node->set(socket, cyclesArray);
+      break;
+    }
+    case SocketType::NODE_ARRAY: {
+      // TODO: renderIndex->GetRprim()->cycles_node ?
+      TF_WARN("Unimplemented conversion: SocketType::NODE_ARRAY");
+      break;
+    }
+  }
+}
+
+VtValue GetNodeValue(const Node *node, const SocketType &socket)
+{
+  switch (socket.type) {
+    default:
+    case SocketType::UNDEFINED:
+      TF_RUNTIME_ERROR("Unexpected conversion: SocketType::UNDEFINED");
+      return VtValue();
+
+    case SocketType::BOOLEAN:
+      return convertFromCycles(node->get_bool(socket));
+    case SocketType::FLOAT:
+      return convertFromCycles(node->get_float(socket));
+    case SocketType::INT:
+      return convertFromCycles(node->get_int(socket));
+    case SocketType::UINT:
+      return convertFromCycles(node->get_uint(socket));
+    case SocketType::COLOR:
+    case SocketType::VECTOR:
+    case SocketType::POINT:
+    case SocketType::NORMAL:
+      return convertFromCycles(node->get_float3(socket));
+    case SocketType::POINT2:
+      return convertFromCycles(node->get_float2(socket));
+    case SocketType::CLOSURE:
+      return VtValue();
+    case SocketType::STRING:
+      return convertFromCycles(node->get_string(socket));
+    case SocketType::ENUM:
+      return convertFromCycles(node->get_int(socket));
+    case SocketType::TRANSFORM:
+      return convertFromCycles(node->get_transform(socket));
+    case SocketType::NODE:
+      TF_WARN("Unimplemented conversion: SocketType::NODE");
+      return VtValue();
+
+    case SocketType::BOOLEAN_ARRAY:
+      return convertFromCyclesArray(node->get_bool_array(socket));
+    case SocketType::FLOAT_ARRAY:
+      return convertFromCyclesArray(node->get_float_array(socket));
+    case SocketType::INT_ARRAY:
+      return convertFromCyclesArray(node->get_int_array(socket));
+    case SocketType::COLOR_ARRAY:
+    case SocketType::VECTOR_ARRAY:
+    case SocketType::POINT_ARRAY:
+    case SocketType::NORMAL_ARRAY:
+      return convertFromCyclesArray<float3, GfVec3f>(node->get_float3_array(socket));
+    case SocketType::POINT2_ARRAY:
+      return convertFromCyclesArray<float2, GfVec2f>(node->get_float2_array(socket));
+    case SocketType::STRING_ARRAY:
+      return convertFromCyclesArray<ustring, void>(node->get_string_array(socket));
+    case SocketType::TRANSFORM_ARRAY:
+      return convertFromCyclesArray<Transform, void>(node->get_transform_array(socket));
+    case SocketType::NODE_ARRAY: {
+      TF_WARN("Unimplemented conversion: SocketType::NODE_ARRAY");
+      return VtValue();
+    }
+  }
+}
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/node_util.h

@@ -0,0 +1,18 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#pragma once
+
+#include "graph/node.h"
+#include "hydra/config.h"
+
+#include <pxr/base/vt/value.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+void SetNodeValue(CCL_NS::Node *node, const CCL_NS::SocketType &socket, const VtValue &value);
+
+VtValue GetNodeValue(const CCL_NS::Node *node, const CCL_NS::SocketType &socket);
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/output_driver.cpp

@@ -0,0 +1,78 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#include "hydra/output_driver.h"
+#include "hydra/render_buffer.h"
+#include "hydra/session.h"
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+HdCyclesOutputDriver::HdCyclesOutputDriver(HdCyclesSession *renderParam)
+    : _renderParam(renderParam)
+{
+}
+
+void HdCyclesOutputDriver::write_render_tile(const Tile &tile)
+{
+  update_render_tile(tile);
+
+  // Update convergence state of all render buffers
+  for (const HdRenderPassAovBinding &aovBinding : _renderParam->GetAovBindings()) {
+    if (const auto renderBuffer = static_cast<HdCyclesRenderBuffer *>(aovBinding.renderBuffer)) {
+      renderBuffer->SetConverged(true);
+    }
+  }
+}
+
+bool HdCyclesOutputDriver::update_render_tile(const Tile &tile)
+{
+  std::vector<float> pixels;
+
+  for (const HdRenderPassAovBinding &aovBinding : _renderParam->GetAovBindings()) {
+    if (aovBinding == _renderParam->GetDisplayAovBinding()) {
+      continue;  // Display AOV binding is already updated by Cycles display driver
+    }
+
+    if (const auto renderBuffer = static_cast<HdCyclesRenderBuffer *>(aovBinding.renderBuffer)) {
+      const HdFormat format = renderBuffer->GetFormat();
+      if (format == HdFormatInvalid) {
+        continue;  // Skip invalid AOV bindings
+      }
+
+      const size_t channels = HdGetComponentCount(format);
+      // Avoid extra copy by mapping render buffer directly when dimensions/format match the tile
+      if (tile.offset.x == 0 && tile.offset.y == 0 && tile.size.x == renderBuffer->GetWidth() &&
+          tile.size.y == renderBuffer->GetHeight() &&
+          (format >= HdFormatFloat32 && format <= HdFormatFloat32Vec4)) {
+        float *const data = static_cast<float *>(renderBuffer->Map());
+        TF_VERIFY(tile.get_pass_pixels(aovBinding.aovName.GetString(), channels, data));
+        renderBuffer->Unmap();
+      }
+      else {
+        pixels.resize(channels * tile.size.x * tile.size.y);
+        if (tile.get_pass_pixels(aovBinding.aovName.GetString(), channels, pixels.data())) {
+          const bool isId = aovBinding.aovName == HdAovTokens->primId ||
+                            aovBinding.aovName == HdAovTokens->elementId ||
+                            aovBinding.aovName == HdAovTokens->instanceId;
+
+          renderBuffer->WritePixels(pixels.data(),
+                                    GfVec2i(tile.offset.x, tile.offset.y),
+                                    GfVec2i(tile.size.x, tile.size.y),
+                                    channels,
+                                    isId);
+        }
+        else {
+          // Do not warn on missing elementId, which is a standard AOV but is not implememted
+          if (aovBinding.aovName != HdAovTokens->elementId) {
+            TF_RUNTIME_ERROR("Could not find pass for AOV '%s'", aovBinding.aovName.GetText());
+          }
+        }
+      }
+    }
+  }
+
+  return true;
+}
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/output_driver.h

@@ -0,0 +1,23 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#pragma once
+
+#include "hydra/config.h"
+#include "session/output_driver.h"
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+class HdCyclesOutputDriver final : public CCL_NS::OutputDriver {
+ public:
+  HdCyclesOutputDriver(HdCyclesSession *renderParam);
+
+ private:
+  void write_render_tile(const Tile &tile) override;
+  bool update_render_tile(const Tile &tile) override;
+
+  HdCyclesSession *const _renderParam;
+};
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/plugInfo.json

@@ -0,0 +1,3 @@
+{
+    "Includes": [ "*/resources/" ]
+}

intern/cycles/hydra/plugin.cpp

@@ -0,0 +1,71 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#include "hydra/plugin.h"
+#include "hydra/render_delegate.h"
+#include "util/log.h"
+#include "util/path.h"
+
+#include <pxr/base/arch/filesystem.h>
+#include <pxr/base/plug/plugin.h>
+#include <pxr/base/plug/thisPlugin.h>
+#include <pxr/base/tf/envSetting.h>
+#include <pxr/imaging/hd/rendererPluginRegistry.h>
+
+PXR_NAMESPACE_OPEN_SCOPE
+
+#ifdef WITH_CYCLES_LOGGING
+TF_DEFINE_ENV_SETTING(CYCLES_LOGGING, false, "Enable Cycles logging")
+TF_DEFINE_ENV_SETTING(CYCLES_LOGGING_SEVERITY, 1, "Cycles logging verbosity")
+#endif
+
+HdCyclesPlugin::HdCyclesPlugin()
+{
+  const PlugPluginPtr plugin = PLUG_THIS_PLUGIN;
+  // Initialize Cycles paths relative to the plugin resource path
+  std::string rootPath = PXR_NS::ArchAbsPath(plugin->GetResourcePath());
+  CCL_NS::path_init(std::move(rootPath));
+
+#ifdef WITH_CYCLES_LOGGING
+  if (TfGetEnvSetting(CYCLES_LOGGING)) {
+    CCL_NS::util_logging_start();
+    CCL_NS::util_logging_verbosity_set(TfGetEnvSetting(CYCLES_LOGGING_SEVERITY));
+  }
+#endif
+}
+
+HdCyclesPlugin::~HdCyclesPlugin()
+{
+}
+
+bool HdCyclesPlugin::IsSupported() const
+{
+  return true;
+}
+
+HdRenderDelegate *HdCyclesPlugin::CreateRenderDelegate()
+{
+  return CreateRenderDelegate({});
+}
+
+HdRenderDelegate *HdCyclesPlugin::CreateRenderDelegate(const HdRenderSettingsMap &settingsMap)
+{
+  return new HD_CYCLES_NS::HdCyclesDelegate(settingsMap);
+}
+
+void HdCyclesPlugin::DeleteRenderDelegate(HdRenderDelegate *renderDelegate)
+{
+  delete renderDelegate;
+}
+
+// USD's type system accounts for namespace, so we'd have to register our name as
+// HdCycles::HdCyclesPlugin in plugInfo.json, which isn't all that bad for JSON,
+// but those colons may cause issues for any USD specific tooling. So just put our
+// plugin class in the pxr namespace (which USD's type system will elide).
+TF_REGISTRY_FUNCTION(TfType)
+{
+  HdRendererPluginRegistry::Define<PXR_NS::HdCyclesPlugin>();
+}
+
+PXR_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/plugin.h

@@ -0,0 +1,25 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#pragma once
+
+#include "hydra/config.h"
+#include <pxr/imaging/hd/rendererPlugin.h>
+
+PXR_NAMESPACE_OPEN_SCOPE
+
+class HdCyclesPlugin final : public PXR_NS::HdRendererPlugin {
+ public:
+  HdCyclesPlugin();
+  ~HdCyclesPlugin() override;
+
+  bool IsSupported() const override;
+
+  PXR_NS::HdRenderDelegate *CreateRenderDelegate() override;
+  PXR_NS::HdRenderDelegate *CreateRenderDelegate(const PXR_NS::HdRenderSettingsMap &) override;
+
+  void DeleteRenderDelegate(PXR_NS::HdRenderDelegate *) override;
+};
+
+PXR_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/pointcloud.cpp

@@ -0,0 +1,199 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#include "hydra/pointcloud.h"
+#include "hydra/geometry.inl"
+#include "scene/pointcloud.h"
+
+#include <pxr/imaging/hd/extComputationUtils.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+HdCyclesPoints::HdCyclesPoints(const SdfPath &rprimId
+#if PXR_VERSION < 2102
+                               ,
+                               const SdfPath &instancerId
+#endif
+                               )
+    : HdCyclesGeometry(rprimId
+#if PXR_VERSION < 2102
+                       ,
+                       instancerId
+#endif
+      )
+{
+}
+
+HdCyclesPoints::~HdCyclesPoints()
+{
+}
+
+HdDirtyBits HdCyclesPoints::GetInitialDirtyBitsMask() const
+{
+  HdDirtyBits bits = HdCyclesGeometry::GetInitialDirtyBitsMask();
+  bits |= HdChangeTracker::DirtyPoints | HdChangeTracker::DirtyWidths |
+          HdChangeTracker::DirtyPrimvar;
+  return bits;
+}
+
+HdDirtyBits HdCyclesPoints::_PropagateDirtyBits(HdDirtyBits bits) const
+{
+  // Points and widths always have to be updated together
+  if (bits & (HdChangeTracker::DirtyPoints | HdChangeTracker::DirtyWidths)) {
+    bits |= HdChangeTracker::DirtyPoints | HdChangeTracker::DirtyWidths;
+  }
+
+  return bits;
+}
+
+void HdCyclesPoints::Populate(HdSceneDelegate *sceneDelegate, HdDirtyBits dirtyBits, bool &rebuild)
+{
+  if (dirtyBits & (HdChangeTracker::DirtyPoints | HdChangeTracker::DirtyWidths)) {
+    const size_t numPoints = _geom->num_points();
+
+    PopulatePoints(sceneDelegate);
+    PopulateWidths(sceneDelegate);
+
+    rebuild = _geom->num_points() != numPoints;
+
+    array<int> shaders;
+    shaders.reserve(_geom->num_points());
+    for (size_t i = 0; i < _geom->num_points(); ++i) {
+      shaders.push_back_reserved(0);
+    }
+
+    _geom->set_shader(shaders);
+  }
+
+  if (dirtyBits & HdChangeTracker::DirtyPrimvar) {
+    PopulatePrimvars(sceneDelegate);
+  }
+}
+
+void HdCyclesPoints::PopulatePoints(HdSceneDelegate *sceneDelegate)
+{
+  VtValue value;
+
+  for (const HdExtComputationPrimvarDescriptor &desc :
+       sceneDelegate->GetExtComputationPrimvarDescriptors(GetId(), HdInterpolationVertex)) {
+    if (desc.name == HdTokens->points) {
+      auto valueStore = HdExtComputationUtils::GetComputedPrimvarValues({desc}, sceneDelegate);
+      const auto valueStoreIt = valueStore.find(desc.name);
+      if (valueStoreIt != valueStore.end()) {
+        value = std::move(valueStoreIt->second);
+      }
+      break;
+    }
+  }
+
+  if (value.IsEmpty()) {
+    value = GetPrimvar(sceneDelegate, HdTokens->points);
+  }
+
+  if (!value.IsHolding<VtVec3fArray>()) {
+    TF_WARN("Invalid points data for %s", GetId().GetText());
+    return;
+  }
+
+  const auto &points = value.UncheckedGet<VtVec3fArray>();
+
+  array<float3> pointsDataCycles;
+  pointsDataCycles.reserve(points.size());
+
+  for (const GfVec3f &point : points) {
+    pointsDataCycles.push_back_reserved(make_float3(point[0], point[1], point[2]));
+  }
+
+  _geom->set_points(pointsDataCycles);
+}
+
+void HdCyclesPoints::PopulateWidths(HdSceneDelegate *sceneDelegate)
+{
+  VtValue value = GetPrimvar(sceneDelegate, HdTokens->widths);
+  const HdInterpolation interpolation = GetPrimvarInterpolation(sceneDelegate, HdTokens->widths);
+
+  if (!value.IsHolding<VtFloatArray>()) {
+    TF_WARN("Invalid widths data for %s", GetId().GetText());
+    return;
+  }
+
+  const auto &widths = value.UncheckedGet<VtFloatArray>();
+
+  array<float> radiusDataCycles;
+  radiusDataCycles.reserve(_geom->num_points());
+
+  if (interpolation == HdInterpolationConstant) {
+    TF_VERIFY(widths.size() == 1);
+
+    const float constantRadius = widths[0] * 0.5f;
+
+    for (size_t i = 0; i < _geom->num_points(); ++i) {
+      radiusDataCycles.push_back_reserved(constantRadius);
+    }
+  }
+  else if (interpolation == HdInterpolationVertex) {
+    TF_VERIFY(widths.size() == _geom->num_points());
+
+    for (size_t i = 0; i < _geom->num_points(); ++i) {
+      radiusDataCycles.push_back_reserved(widths[i] * 0.5f);
+    }
+  }
+
+  _geom->set_radius(radiusDataCycles);
+}
+
+void HdCyclesPoints::PopulatePrimvars(HdSceneDelegate *sceneDelegate)
+{
+  Scene *const scene = (Scene *)_geom->get_owner();
+
+  const std::pair<HdInterpolation, AttributeElement> interpolations[] = {
+      std::make_pair(HdInterpolationVertex, ATTR_ELEMENT_VERTEX),
+      std::make_pair(HdInterpolationConstant, ATTR_ELEMENT_OBJECT),
+  };
+
+  for (const auto &interpolation : interpolations) {
+    for (const HdPrimvarDescriptor &desc :
+         GetPrimvarDescriptors(sceneDelegate, interpolation.first)) {
+      // Skip special primvars that are handled separately
+      if (desc.name == HdTokens->points || desc.name == HdTokens->widths) {
+        continue;
+      }
+
+      VtValue value = GetPrimvar(sceneDelegate, desc.name);
+      if (value.IsEmpty()) {
+        continue;
+      }
+
+      const ustring name(desc.name.GetString());
+
+      AttributeStandard std = ATTR_STD_NONE;
+      if (desc.role == HdPrimvarRoleTokens->textureCoordinate) {
+        std = ATTR_STD_UV;
+      }
+      else if (interpolation.first == HdInterpolationVertex) {
+        if (desc.name == HdTokens->displayColor || desc.role == HdPrimvarRoleTokens->color) {
+          std = ATTR_STD_VERTEX_COLOR;
+        }
+        else if (desc.name == HdTokens->normals) {
+          std = ATTR_STD_VERTEX_NORMAL;
+        }
+      }
+      else if (desc.name == HdTokens->displayColor &&
+               interpolation.first == HdInterpolationConstant) {
+        if (value.IsHolding<VtVec3fArray>() && value.GetArraySize() == 1) {
+          const GfVec3f color = value.UncheckedGet<VtVec3fArray>()[0];
+          _instances[0]->set_color(make_float3(color[0], color[1], color[2]));
+        }
+      }
+
+      // Skip attributes that are not needed
+      if ((std != ATTR_STD_NONE && _geom->need_attribute(scene, std)) ||
+          _geom->need_attribute(scene, name)) {
+        ApplyPrimvars(_geom->attributes, name, value, interpolation.second, std);
+      }
+    }
+  }
+}
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/pointcloud.h

@@ -0,0 +1,40 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#pragma once
+
+#include "hydra/config.h"
+#include "hydra/geometry.h"
+
+#include <pxr/imaging/hd/points.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+class HdCyclesPoints final : public HdCyclesGeometry<PXR_NS::HdPoints, CCL_NS::PointCloud> {
+ public:
+  HdCyclesPoints(
+      const PXR_NS::SdfPath &rprimId
+#if PXR_VERSION < 2102
+      ,
+      const PXR_NS::SdfPath &instancerId = {}
+#endif
+  );
+  ~HdCyclesPoints() override;
+
+  PXR_NS::HdDirtyBits GetInitialDirtyBitsMask() const override;
+
+ private:
+  PXR_NS::HdDirtyBits _PropagateDirtyBits(PXR_NS::HdDirtyBits bits) const override;
+
+  void Populate(PXR_NS::HdSceneDelegate *sceneDelegate,
+                PXR_NS::HdDirtyBits dirtyBits,
+                bool &rebuild) override;
+
+  void PopulatePoints(PXR_NS::HdSceneDelegate *sceneDelegate);
+  void PopulateWidths(PXR_NS::HdSceneDelegate *sceneDelegate);
+
+  void PopulatePrimvars(PXR_NS::HdSceneDelegate *sceneDelegate);
+};
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/render_buffer.cpp

@@ -0,0 +1,276 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#include "hydra/render_buffer.h"
+#include "hydra/session.h"
+#include "util/half.h"
+
+#include <pxr/base/gf/vec3i.h>
+#include <pxr/base/gf/vec4f.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+HdCyclesRenderBuffer::HdCyclesRenderBuffer(const SdfPath &bprimId) : HdRenderBuffer(bprimId)
+{
+}
+
+HdCyclesRenderBuffer::~HdCyclesRenderBuffer()
+{
+}
+
+void HdCyclesRenderBuffer::Finalize(HdRenderParam *renderParam)
+{
+  // Remove this render buffer from AOV bindings
+  // This ensures that 'OutputDriver' does not attempt to write to it anymore
+  static_cast<HdCyclesSession *>(renderParam)->RemoveAovBinding(this);
+
+  HdRenderBuffer::Finalize(renderParam);
+}
+
+bool HdCyclesRenderBuffer::Allocate(const GfVec3i &dimensions, HdFormat format, bool multiSampled)
+{
+  if (dimensions[2] != 1) {
+    TF_RUNTIME_ERROR("HdCyclesRenderBuffer::Allocate called with dimensions that are not 2D.");
+    return false;
+  }
+
+  const size_t oldSize = _data.size();
+  const size_t newSize = dimensions[0] * dimensions[1] * HdDataSizeOfFormat(format);
+  if (oldSize == newSize) {
+    return true;
+  }
+
+  if (IsMapped()) {
+    TF_RUNTIME_ERROR("HdCyclesRenderBuffer::Allocate called while buffer is mapped.");
+    return false;
+  }
+
+  _width = dimensions[0];
+  _height = dimensions[1];
+  _format = format;
+
+  _data.resize(newSize);
+
+  return true;
+}
+
+void HdCyclesRenderBuffer::_Deallocate()
+{
+  _width = 0u;
+  _height = 0u;
+  _format = HdFormatInvalid;
+
+  _data.clear();
+  _data.shrink_to_fit();
+
+  _resource = VtValue();
+}
+
+void *HdCyclesRenderBuffer::Map()
+{
+  // Mapping is not implemented when a resource is set
+  if (!_resource.IsEmpty()) {
+    return nullptr;
+  }
+
+  ++_mapped;
+
+  return _data.data();
+}
+
+void HdCyclesRenderBuffer::Unmap()
+{
+  --_mapped;
+}
+
+bool HdCyclesRenderBuffer::IsMapped() const
+{
+  return _mapped != 0;
+}
+
+void HdCyclesRenderBuffer::Resolve()
+{
+}
+
+bool HdCyclesRenderBuffer::IsConverged() const
+{
+  return _converged;
+}
+
+void HdCyclesRenderBuffer::SetConverged(bool converged)
+{
+  _converged = converged;
+}
+
+VtValue HdCyclesRenderBuffer::GetResource(bool multiSampled) const
+{
+  TF_UNUSED(multiSampled);
+
+  return _resource;
+}
+
+void HdCyclesRenderBuffer::SetResource(const VtValue &resource)
+{
+  _resource = resource;
+}
+
+namespace {
+
+struct SimpleConversion {
+  static float convert(float value)
+  {
+    return value;
+  }
+};
+struct IdConversion {
+  static int32_t convert(float value)
+  {
+    return static_cast<int32_t>(value) - 1;
+  }
+};
+struct UInt8Conversion {
+  static uint8_t convert(float value)
+  {
+    return static_cast<uint8_t>(value * 255.f);
+  }
+};
+struct SInt8Conversion {
+  static int8_t convert(float value)
+  {
+    return static_cast<int8_t>(value * 127.f);
+  }
+};
+struct HalfConversion {
+  static half convert(float value)
+  {
+    return float_to_half_image(value);
+  }
+};
+
+template<typename SrcT, typename DstT, typename Convertor = SimpleConversion>
+void writePixels(const SrcT *srcPtr,
+                 const GfVec2i &srcSize,
+                 int srcChannelCount,
+                 DstT *dstPtr,
+                 const GfVec2i &dstSize,
+                 int dstChannelCount,
+                 const Convertor &convertor = {})
+{
+  const auto writeSize = GfVec2i(GfMin(srcSize[0], dstSize[0]), GfMin(srcSize[1], dstSize[1]));
+  const auto writeChannelCount = GfMin(srcChannelCount, dstChannelCount);
+
+  for (int y = 0; y < writeSize[1]; ++y) {
+    for (int x = 0; x < writeSize[0]; ++x) {
+      for (int c = 0; c < writeChannelCount; ++c) {
+        dstPtr[x * dstChannelCount + c] = convertor.convert(srcPtr[x * srcChannelCount + c]);
+      }
+    }
+    srcPtr += srcSize[0] * srcChannelCount;
+    dstPtr += dstSize[0] * dstChannelCount;
+  }
+}
+
+}  // namespace
+
+void HdCyclesRenderBuffer::WritePixels(const float *srcPixels,
+                                       const PXR_NS::GfVec2i &srcOffset,
+                                       const GfVec2i &srcDims,
+                                       int srcChannels,
+                                       bool isId)
+{
+  uint8_t *dstPixels = _data.data();
+
+  const size_t formatSize = HdDataSizeOfFormat(_format);
+  dstPixels += srcOffset[1] * (formatSize * _width) + srcOffset[0] * formatSize;
+
+  switch (_format) {
+    case HdFormatUNorm8:
+    case HdFormatUNorm8Vec2:
+    case HdFormatUNorm8Vec3:
+    case HdFormatUNorm8Vec4:
+      writePixels(srcPixels,
+                  srcDims,
+                  srcChannels,
+                  dstPixels,
+                  GfVec2i(_width, _height),
+                  1 + (_format - HdFormatUNorm8),
+                  UInt8Conversion());
+      break;
+
+    case HdFormatSNorm8:
+    case HdFormatSNorm8Vec2:
+    case HdFormatSNorm8Vec3:
+    case HdFormatSNorm8Vec4:
+      writePixels(srcPixels,
+                  srcDims,
+                  srcChannels,
+                  dstPixels,
+                  GfVec2i(_width, _height),
+                  1 + (_format - HdFormatSNorm8),
+                  SInt8Conversion());
+      break;
+
+    case HdFormatFloat16:
+    case HdFormatFloat16Vec2:
+    case HdFormatFloat16Vec3:
+    case HdFormatFloat16Vec4:
+      writePixels(srcPixels,
+                  srcDims,
+                  srcChannels,
+                  reinterpret_cast<half *>(dstPixels),
+                  GfVec2i(_width, _height),
+                  1 + (_format - HdFormatFloat16),
+                  HalfConversion());
+      break;
+
+    case HdFormatFloat32:
+    case HdFormatFloat32Vec2:
+    case HdFormatFloat32Vec3:
+    case HdFormatFloat32Vec4:
+      writePixels(srcPixels,
+                  srcDims,
+                  srcChannels,
+                  reinterpret_cast<float *>(dstPixels),
+                  GfVec2i(_width, _height),
+                  1 + (_format - HdFormatFloat32));
+      break;
+
+    case HdFormatInt32:
+      // Special case for ID AOVs (see 'HdCyclesMesh::Sync')
+      if (isId) {
+        writePixels(srcPixels,
+                    srcDims,
+                    srcChannels,
+                    reinterpret_cast<int *>(dstPixels),
+                    GfVec2i(_width, _height),
+                    1,
+                    IdConversion());
+      }
+      else {
+        writePixels(srcPixels,
+                    srcDims,
+                    srcChannels,
+                    reinterpret_cast<int *>(dstPixels),
+                    GfVec2i(_width, _height),
+                    1);
+      }
+      break;
+    case HdFormatInt32Vec2:
+    case HdFormatInt32Vec3:
+    case HdFormatInt32Vec4:
+      writePixels(srcPixels,
+                  srcDims,
+                  srcChannels,
+                  reinterpret_cast<int *>(dstPixels),
+                  GfVec2i(_width, _height),
+                  1 + (_format - HdFormatInt32));
+      break;
+
+    default:
+      TF_RUNTIME_ERROR("HdCyclesRenderBuffer::WritePixels called with unsupported format.");
+      break;
+  }
+}
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/render_buffer.h

@@ -0,0 +1,85 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#pragma once
+
+#include "hydra/config.h"
+
+#include <pxr/imaging/hd/renderBuffer.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+class HdCyclesRenderBuffer final : public PXR_NS::HdRenderBuffer {
+ public:
+  HdCyclesRenderBuffer(const PXR_NS::SdfPath &bprimId);
+  ~HdCyclesRenderBuffer() override;
+
+  void Finalize(PXR_NS::HdRenderParam *renderParam) override;
+
+  bool Allocate(const PXR_NS::GfVec3i &dimensions,
+                PXR_NS::HdFormat format,
+                bool multiSampled) override;
+
+  unsigned int GetWidth() const override
+  {
+    return _width;
+  }
+
+  unsigned int GetHeight() const override
+  {
+    return _height;
+  }
+
+  unsigned int GetDepth() const override
+  {
+    return 1u;
+  }
+
+  PXR_NS::HdFormat GetFormat() const override
+  {
+    return _format;
+  }
+
+  bool IsMultiSampled() const override
+  {
+    return false;
+  }
+
+  void *Map() override;
+
+  void Unmap() override;
+
+  bool IsMapped() const override;
+
+  void Resolve() override;
+
+  bool IsConverged() const override;
+
+  void SetConverged(bool converged);
+
+  PXR_NS::VtValue GetResource(bool multiSampled = false) const override;
+
+  void SetResource(const PXR_NS::VtValue &resource);
+
+  void WritePixels(const float *pixels,
+                   const PXR_NS::GfVec2i &offset,
+                   const PXR_NS::GfVec2i &dims,
+                   int channels,
+                   bool isId = false);
+
+ private:
+  void _Deallocate() override;
+
+  unsigned int _width = 0u;
+  unsigned int _height = 0u;
+  PXR_NS::HdFormat _format = PXR_NS::HdFormatInvalid;
+
+  std::vector<uint8_t> _data;
+  PXR_NS::VtValue _resource;
+
+  std::atomic_int _mapped = 0;
+  std::atomic_bool _converged = false;
+};
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/render_delegate.cpp

@@ -0,0 +1,514 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#include "hydra/render_delegate.h"
+#include "hydra/camera.h"
+#include "hydra/curves.h"
+#include "hydra/field.h"
+#include "hydra/instancer.h"
+#include "hydra/light.h"
+#include "hydra/material.h"
+#include "hydra/mesh.h"
+#include "hydra/node_util.h"
+#include "hydra/pointcloud.h"
+#include "hydra/render_buffer.h"
+#include "hydra/render_pass.h"
+#include "hydra/session.h"
+#include "hydra/volume.h"
+#include "scene/integrator.h"
+#include "scene/scene.h"
+#include "session/session.h"
+
+#include <pxr/base/tf/getenv.h>
+#include <pxr/imaging/hd/extComputation.h>
+#include <pxr/imaging/hgi/tokens.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+// clang-format off
+TF_DEFINE_PRIVATE_TOKENS(_tokens,
+    (cycles)
+    (openvdbAsset)
+);
+
+TF_DEFINE_PRIVATE_TOKENS(HdCyclesRenderSettingsTokens,
+    ((device, "cycles:device"))
+    ((threads, "cycles:threads"))
+    ((time_limit, "cycles:time_limit"))
+    ((samples, "cycles:samples"))
+    ((sample_offset, "cycles:sample_offset"))
+);
+// clang-format on
+
+namespace {
+
+const TfTokenVector kSupportedRPrimTypes = {
+    HdPrimTypeTokens->basisCurves,
+    HdPrimTypeTokens->mesh,
+    HdPrimTypeTokens->points,
+#ifdef WITH_OPENVDB
+    HdPrimTypeTokens->volume,
+#endif
+};
+
+const TfTokenVector kSupportedSPrimTypes = {
+    HdPrimTypeTokens->camera,
+    HdPrimTypeTokens->material,
+    HdPrimTypeTokens->diskLight,
+    HdPrimTypeTokens->distantLight,
+    HdPrimTypeTokens->domeLight,
+    HdPrimTypeTokens->rectLight,
+    HdPrimTypeTokens->sphereLight,
+    HdPrimTypeTokens->extComputation,
+};
+
+const TfTokenVector kSupportedBPrimTypes = {
+    HdPrimTypeTokens->renderBuffer,
+#ifdef WITH_OPENVDB
+    _tokens->openvdbAsset,
+#endif
+};
+
+SessionParams GetSessionParams(const HdRenderSettingsMap &settings)
+{
+  SessionParams params;
+  params.threads = 0;
+  params.background = false;
+  params.use_resolution_divider = false;
+
+  HdRenderSettingsMap::const_iterator it;
+
+  // Pull all setting that contribute to device creation first
+  it = settings.find(HdCyclesRenderSettingsTokens->threads);
+  if (it != settings.end()) {
+    params.threads = VtValue::Cast<int>(it->second).GetWithDefault(params.threads);
+  }
+
+  // Get the Cycles device from settings or environment, falling back to CPU
+  std::string deviceType = Device::string_from_type(DEVICE_CPU);
+  it = settings.find(HdCyclesRenderSettingsTokens->device);
+  if (it != settings.end()) {
+    deviceType = VtValue::Cast<std::string>(it->second).GetWithDefault(deviceType);
+  }
+  else {
+    const std::string deviceTypeEnv = TfGetenv("CYCLES_DEVICE");
+    if (!deviceTypeEnv.empty()) {
+      deviceType = deviceTypeEnv;
+    }
+  }
+
+  // Move to all uppercase for Device::type_from_string
+  std::transform(deviceType.begin(), deviceType.end(), deviceType.begin(), ::toupper);
+
+  vector<DeviceInfo> devices = Device::available_devices(
+      DEVICE_MASK(Device::type_from_string(deviceType.c_str())));
+  if (devices.empty()) {
+    devices = Device::available_devices(DEVICE_MASK_CPU);
+    if (!devices.empty()) {
+      params.device = devices.front();
+    }
+  }
+  else {
+    params.device = Device::get_multi_device(devices, params.threads, params.background);
+  }
+
+  return params;
+}
+
+}  // namespace
+
+HdCyclesDelegate::HdCyclesDelegate(const HdRenderSettingsMap &settingsMap, Session *session_)
+    : HdRenderDelegate()
+{
+  _renderParam = session_ ? std::make_unique<HdCyclesSession>(session_) :
+                            std::make_unique<HdCyclesSession>(GetSessionParams(settingsMap));
+
+  // If the delegate owns the session, pull any remaining settings
+  if (!session_) {
+    for (const auto &setting : settingsMap) {
+      // Skip over the settings known to be used for initialization only
+      if (setting.first == HdCyclesRenderSettingsTokens->device ||
+          setting.first == HdCyclesRenderSettingsTokens->threads) {
+        continue;
+      }
+
+      SetRenderSetting(setting.first, setting.second);
+    }
+  }
+}
+
+HdCyclesDelegate::~HdCyclesDelegate()
+{
+}
+
+void HdCyclesDelegate::SetDrivers(const HdDriverVector &drivers)
+{
+  for (HdDriver *hdDriver : drivers) {
+    if (hdDriver->name == HgiTokens->renderDriver && hdDriver->driver.IsHolding<Hgi *>()) {
+      _hgi = hdDriver->driver.UncheckedGet<Hgi *>();
+      break;
+    }
+  }
+}
+
+bool HdCyclesDelegate::IsDisplaySupported() const
+{
+#ifdef _WIN32
+  return _hgi && _hgi->GetAPIName() == HgiTokens->OpenGL;
+#else
+  return false;
+#endif
+}
+
+const TfTokenVector &HdCyclesDelegate::GetSupportedRprimTypes() const
+{
+  return kSupportedRPrimTypes;
+}
+
+const TfTokenVector &HdCyclesDelegate::GetSupportedSprimTypes() const
+{
+  return kSupportedSPrimTypes;
+}
+
+const TfTokenVector &HdCyclesDelegate::GetSupportedBprimTypes() const
+{
+  return kSupportedBPrimTypes;
+}
+
+HdRenderParam *HdCyclesDelegate::GetRenderParam() const
+{
+  return _renderParam.get();
+}
+
+HdResourceRegistrySharedPtr HdCyclesDelegate::GetResourceRegistry() const
+{
+  return HdResourceRegistrySharedPtr();
+}
+
+bool HdCyclesDelegate::IsPauseSupported() const
+{
+  return true;
+}
+
+bool HdCyclesDelegate::Pause()
+{
+  _renderParam->session->set_pause(true);
+  return true;
+}
+
+bool HdCyclesDelegate::Resume()
+{
+  _renderParam->session->set_pause(false);
+  return true;
+}
+
+HdRenderPassSharedPtr HdCyclesDelegate::CreateRenderPass(HdRenderIndex *index,
+                                                         const HdRprimCollection &collection)
+{
+  return HdRenderPassSharedPtr(new HdCyclesRenderPass(index, collection, _renderParam.get()));
+}
+
+HdInstancer *HdCyclesDelegate::CreateInstancer(HdSceneDelegate *delegate,
+                                               const SdfPath &instancerId
+#if PXR_VERSION < 2102
+                                               ,
+                                               const SdfPath &parentId
+#endif
+)
+{
+  return new HdCyclesInstancer(delegate,
+                               instancerId
+#if PXR_VERSION < 2102
+                               ,
+                               parentId
+#endif
+  );
+}
+
+void HdCyclesDelegate::DestroyInstancer(HdInstancer *instancer)
+{
+  delete instancer;
+}
+
+HdRprim *HdCyclesDelegate::CreateRprim(const TfToken &typeId,
+                                       const SdfPath &rprimId
+#if PXR_VERSION < 2102
+                                       ,
+                                       const SdfPath &instancerId
+#endif
+)
+{
+  if (typeId == HdPrimTypeTokens->mesh) {
+    return new HdCyclesMesh(rprimId
+#if PXR_VERSION < 2102
+                            ,
+                            instancerId
+#endif
+    );
+  }
+  if (typeId == HdPrimTypeTokens->basisCurves) {
+    return new HdCyclesCurves(rprimId
+#if PXR_VERSION < 2102
+                              ,
+                              instancerId
+#endif
+    );
+  }
+  if (typeId == HdPrimTypeTokens->points) {
+    return new HdCyclesPoints(rprimId
+#if PXR_VERSION < 2102
+                              ,
+                              instancerId
+#endif
+    );
+  }
+#ifdef WITH_OPENVDB
+  if (typeId == HdPrimTypeTokens->volume) {
+    return new HdCyclesVolume(rprimId
+#  if PXR_VERSION < 2102
+                              ,
+                              instancerId
+#  endif
+    );
+  }
+#endif
+
+  TF_CODING_ERROR("Unknown Rprim type %s", typeId.GetText());
+  return nullptr;
+}
+
+void HdCyclesDelegate::DestroyRprim(HdRprim *rPrim)
+{
+  delete rPrim;
+}
+
+HdSprim *HdCyclesDelegate::CreateSprim(const TfToken &typeId, const SdfPath &sprimId)
+{
+  if (typeId == HdPrimTypeTokens->camera) {
+    return new HdCyclesCamera(sprimId);
+  }
+  if (typeId == HdPrimTypeTokens->material) {
+    return new HdCyclesMaterial(sprimId);
+  }
+  if (typeId == HdPrimTypeTokens->diskLight || typeId == HdPrimTypeTokens->distantLight ||
+      typeId == HdPrimTypeTokens->domeLight || typeId == HdPrimTypeTokens->rectLight ||
+      typeId == HdPrimTypeTokens->sphereLight) {
+    return new HdCyclesLight(sprimId, typeId);
+  }
+  if (typeId == HdPrimTypeTokens->extComputation) {
+    return new HdExtComputation(sprimId);
+  }
+
+  TF_CODING_ERROR("Unknown Sprim type %s", typeId.GetText());
+  return nullptr;
+}
+
+HdSprim *HdCyclesDelegate::CreateFallbackSprim(const TfToken &typeId)
+{
+  return CreateSprim(typeId, SdfPath::EmptyPath());
+}
+
+void HdCyclesDelegate::DestroySprim(HdSprim *sPrim)
+{
+  delete sPrim;
+}
+
+HdBprim *HdCyclesDelegate::CreateBprim(const TfToken &typeId, const SdfPath &bprimId)
+{
+  if (typeId == HdPrimTypeTokens->renderBuffer) {
+    return new HdCyclesRenderBuffer(bprimId);
+  }
+#ifdef WITH_OPENVDB
+  if (typeId == _tokens->openvdbAsset) {
+    return new HdCyclesField(bprimId, typeId);
+  }
+#endif
+
+  TF_RUNTIME_ERROR("Unknown Bprim type %s", typeId.GetText());
+  return nullptr;
+}
+
+HdBprim *HdCyclesDelegate::CreateFallbackBprim(const TfToken &typeId)
+{
+  return CreateBprim(typeId, SdfPath::EmptyPath());
+}
+
+void HdCyclesDelegate::DestroyBprim(HdBprim *bPrim)
+{
+  delete bPrim;
+}
+
+void HdCyclesDelegate::CommitResources(HdChangeTracker *tracker)
+{
+  TF_UNUSED(tracker);
+
+  const SceneLock lock(_renderParam.get());
+
+  _renderParam->UpdateScene();
+}
+
+TfToken HdCyclesDelegate::GetMaterialBindingPurpose() const
+{
+  return HdTokens->full;
+}
+
+#if HD_API_VERSION < 41
+TfToken HdCyclesDelegate::GetMaterialNetworkSelector() const
+{
+  return _tokens->cycles;
+}
+#else
+TfTokenVector HdCyclesDelegate::GetMaterialRenderContexts() const
+{
+  return {_tokens->cycles};
+}
+#endif
+
+VtDictionary HdCyclesDelegate::GetRenderStats() const
+{
+  const Stats &stats = _renderParam->session->stats;
+  const Progress &progress = _renderParam->session->progress;
+
+  double totalTime, renderTime;
+  progress.get_time(totalTime, renderTime);
+  double fractionDone = progress.get_progress();
+
+  std::string status, substatus;
+  progress.get_status(status, substatus);
+  if (!substatus.empty()) {
+    status += " | " + substatus;
+  }
+
+  return {{"rendererName", VtValue("Cycles")},
+          {"rendererVersion", VtValue(GfVec3i(0, 0, 0))},
+          {"percentDone", VtValue(floor_to_int(fractionDone * 100))},
+          {"fractionDone", VtValue(fractionDone)},
+          {"loadClockTime", VtValue(totalTime - renderTime)},
+          {"peakMemory", VtValue(stats.mem_peak)},
+          {"totalClockTime", VtValue(totalTime)},
+          {"totalMemory", VtValue(stats.mem_used)},
+          {"renderProgressAnnotation", VtValue(status)}};
+}
+
+HdAovDescriptor HdCyclesDelegate::GetDefaultAovDescriptor(const TfToken &name) const
+{
+  if (name == HdAovTokens->color) {
+    HdFormat colorFormat = HdFormatFloat32Vec4;
+    if (IsDisplaySupported()) {
+      // Can use Cycles 'DisplayDriver' in OpenGL, but it only supports 'half4' format
+      colorFormat = HdFormatFloat16Vec4;
+    }
+
+    return HdAovDescriptor(colorFormat, false, VtValue(GfVec4f(0.0f)));
+  }
+  if (name == HdAovTokens->depth) {
+    return HdAovDescriptor(HdFormatFloat32, false, VtValue(1.0f));
+  }
+  if (name == HdAovTokens->normal) {
+    return HdAovDescriptor(HdFormatFloat32Vec3, false, VtValue(GfVec3f(0.0f)));
+  }
+  if (name == HdAovTokens->primId || name == HdAovTokens->instanceId ||
+      name == HdAovTokens->elementId) {
+    return HdAovDescriptor(HdFormatInt32, false, VtValue(-1));
+  }
+
+  return HdAovDescriptor();
+}
+
+HdRenderSettingDescriptorList HdCyclesDelegate::GetRenderSettingDescriptors() const
+{
+  Scene *const scene = _renderParam->session->scene;
+
+  HdRenderSettingDescriptorList descriptors;
+
+  descriptors.push_back({
+      "Time Limit",
+      HdCyclesRenderSettingsTokens->time_limit,
+      VtValue(0.0),
+  });
+  descriptors.push_back({
+      "Sample Count",
+      HdCyclesRenderSettingsTokens->samples,
+      VtValue(1024),
+  });
+  descriptors.push_back({
+      "Sample Offset",
+      HdCyclesRenderSettingsTokens->sample_offset,
+      VtValue(0),
+  });
+
+  for (const SocketType &socket : scene->integrator->type->inputs) {
+    descriptors.push_back({socket.ui_name.string(),
+                           TfToken("cycles:integrator:" + socket.name.string()),
+                           GetNodeValue(scene->integrator, socket)});
+  }
+
+  return descriptors;
+}
+
+void HdCyclesDelegate::SetRenderSetting(const PXR_NS::TfToken &key, const PXR_NS::VtValue &value)
+{
+  Scene *const scene = _renderParam->session->scene;
+  Session *const session = _renderParam->session;
+
+  if (key == HdCyclesRenderSettingsTokens->time_limit) {
+    session->set_time_limit(
+        VtValue::Cast<double>(value).GetWithDefault(session->params.time_limit));
+  }
+  else if (key == HdCyclesRenderSettingsTokens->samples) {
+    int samples = VtValue::Cast<int>(value).GetWithDefault(session->params.samples);
+    samples = std::min(std::max(1, samples), Integrator::MAX_SAMPLES);
+    session->set_samples(samples);
+  }
+  else if (key == HdCyclesRenderSettingsTokens->sample_offset) {
+    session->params.sample_offset = VtValue::Cast<int>(value).GetWithDefault(
+        session->params.sample_offset);
+    ++_settingsVersion;
+  }
+  else {
+    const std::string &keyString = key.GetString();
+    if (keyString.rfind("cycles:integrator:", 0) == 0) {
+      ustring socketName(keyString, sizeof("cycles:integrator:") - 1);
+      if (const SocketType *socket = scene->integrator->type->find_input(socketName)) {
+        SetNodeValue(scene->integrator, *socket, value);
+        ++_settingsVersion;
+      }
+    }
+  }
+}
+
+VtValue HdCyclesDelegate::GetRenderSetting(const TfToken &key) const
+{
+  Scene *const scene = _renderParam->session->scene;
+  Session *const session = _renderParam->session;
+
+  if (key == HdCyclesRenderSettingsTokens->device) {
+    return VtValue(TfToken(Device::string_from_type(session->params.device.type)));
+  }
+  else if (key == HdCyclesRenderSettingsTokens->threads) {
+    return VtValue(session->params.threads);
+  }
+  else if (key == HdCyclesRenderSettingsTokens->time_limit) {
+    return VtValue(session->params.time_limit);
+  }
+  else if (key == HdCyclesRenderSettingsTokens->samples) {
+    return VtValue(session->params.samples);
+  }
+  else if (key == HdCyclesRenderSettingsTokens->sample_offset) {
+    return VtValue(session->params.sample_offset);
+  }
+  else {
+    const std::string &keyString = key.GetString();
+    if (keyString.rfind("cycles:integrator:", 0) == 0) {
+      ustring socketName(keyString, sizeof("cycles:integrator:") - 1);
+      if (const SocketType *socket = scene->integrator->type->find_input(socketName)) {
+        return GetNodeValue(scene->integrator, *socket);
+      }
+    }
+  }
+
+  return VtValue();
+}
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/render_delegate.h

@@ -0,0 +1,98 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#pragma once
+
+#include "hydra/config.h"
+
+#include <pxr/imaging/hd/renderDelegate.h>
+#include <pxr/imaging/hgi/hgi.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+class HdCyclesDelegate final : public PXR_NS::HdRenderDelegate {
+ public:
+  HdCyclesDelegate(const PXR_NS::HdRenderSettingsMap &settingsMap,
+                   CCL_NS::Session *session_ = nullptr);
+  ~HdCyclesDelegate() override;
+
+  void SetDrivers(const PXR_NS::HdDriverVector &drivers) override;
+
+  bool IsDisplaySupported() const;
+
+  PXR_NS::Hgi *GetHgi() const
+  {
+    return _hgi;
+  }
+
+  const PXR_NS::TfTokenVector &GetSupportedRprimTypes() const override;
+  const PXR_NS::TfTokenVector &GetSupportedSprimTypes() const override;
+  const PXR_NS::TfTokenVector &GetSupportedBprimTypes() const override;
+
+  PXR_NS::HdRenderParam *GetRenderParam() const override;
+
+  PXR_NS::HdResourceRegistrySharedPtr GetResourceRegistry() const override;
+
+  PXR_NS::HdRenderSettingDescriptorList GetRenderSettingDescriptors() const override;
+
+  bool IsPauseSupported() const override;
+
+  bool Pause() override;
+  bool Resume() override;
+
+  PXR_NS::HdRenderPassSharedPtr CreateRenderPass(
+      PXR_NS::HdRenderIndex *index, const PXR_NS::HdRprimCollection &collection) override;
+
+  PXR_NS::HdInstancer *CreateInstancer(PXR_NS::HdSceneDelegate *delegate,
+                                       const PXR_NS::SdfPath &id
+#if PXR_VERSION < 2102
+                                       ,
+                                       const PXR_NS::SdfPath &instancerId
+#endif
+                                       ) override;
+  void DestroyInstancer(PXR_NS::HdInstancer *instancer) override;
+
+  PXR_NS::HdRprim *CreateRprim(const PXR_NS::TfToken &typeId,
+                               const PXR_NS::SdfPath &rprimId
+#if PXR_VERSION < 2102
+                               ,
+                               const PXR_NS::SdfPath &instancerId
+#endif
+                               ) override;
+  void DestroyRprim(PXR_NS::HdRprim *rPrim) override;
+
+  PXR_NS::HdSprim *CreateSprim(const PXR_NS::TfToken &typeId,
+                               const PXR_NS::SdfPath &sprimId) override;
+  PXR_NS::HdSprim *CreateFallbackSprim(const PXR_NS::TfToken &typeId) override;
+  void DestroySprim(PXR_NS::HdSprim *sPrim) override;
+
+  PXR_NS::HdBprim *CreateBprim(const PXR_NS::TfToken &typeId,
+                               const PXR_NS::SdfPath &bprimId) override;
+  PXR_NS::HdBprim *CreateFallbackBprim(const PXR_NS::TfToken &typeId) override;
+  void DestroyBprim(PXR_NS::HdBprim *bPrim) override;
+
+  void CommitResources(PXR_NS::HdChangeTracker *tracker) override;
+
+  PXR_NS::TfToken GetMaterialBindingPurpose() const override;
+
+#if HD_API_VERSION < 41
+  PXR_NS::TfToken GetMaterialNetworkSelector() const override;
+#else
+  PXR_NS::TfTokenVector GetMaterialRenderContexts() const override;
+#endif
+
+  PXR_NS::VtDictionary GetRenderStats() const override;
+
+  PXR_NS::HdAovDescriptor GetDefaultAovDescriptor(const PXR_NS::TfToken &name) const override;
+
+  void SetRenderSetting(const PXR_NS::TfToken &key, const PXR_NS::VtValue &value) override;
+
+  PXR_NS::VtValue GetRenderSetting(const PXR_NS::TfToken &key) const override;
+
+ private:
+  PXR_NS::Hgi *_hgi = nullptr;
+  std::unique_ptr<HdCyclesSession> _renderParam;
+};
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/render_pass.cpp

@@ -0,0 +1,175 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#include "hydra/render_pass.h"
+#include "hydra/camera.h"
+#include "hydra/display_driver.h"
+#include "hydra/output_driver.h"
+#include "hydra/render_buffer.h"
+#include "hydra/render_delegate.h"
+#include "hydra/session.h"
+#include "scene/camera.h"
+#include "scene/integrator.h"
+#include "scene/scene.h"
+#include "session/session.h"
+
+#include <pxr/imaging/hd/renderPassState.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+HdCyclesRenderPass::HdCyclesRenderPass(HdRenderIndex *index,
+                                       HdRprimCollection const &collection,
+                                       HdCyclesSession *renderParam)
+    : HdRenderPass(index, collection), _renderParam(renderParam)
+{
+  Session *const session = _renderParam->session;
+  // Reset cancel state so session thread can continue rendering
+  session->progress.reset();
+
+  session->set_output_driver(make_unique<HdCyclesOutputDriver>(renderParam));
+
+  const auto renderDelegate = static_cast<const HdCyclesDelegate *>(
+      GetRenderIndex()->GetRenderDelegate());
+  if (renderDelegate->IsDisplaySupported()) {
+    session->set_display_driver(
+        make_unique<HdCyclesDisplayDriver>(renderParam, renderDelegate->GetHgi()));
+  }
+}
+
+HdCyclesRenderPass::~HdCyclesRenderPass()
+{
+  Session *const session = _renderParam->session;
+  session->cancel(true);
+}
+
+bool HdCyclesRenderPass::IsConverged() const
+{
+  for (const HdRenderPassAovBinding &aovBinding : _renderParam->GetAovBindings()) {
+    if (aovBinding.renderBuffer && !aovBinding.renderBuffer->IsConverged()) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+void HdCyclesRenderPass::ResetConverged()
+{
+  for (const HdRenderPassAovBinding &aovBinding : _renderParam->GetAovBindings()) {
+    if (const auto renderBuffer = static_cast<HdCyclesRenderBuffer *>(aovBinding.renderBuffer)) {
+      renderBuffer->SetConverged(false);
+    }
+  }
+}
+
+void HdCyclesRenderPass::_Execute(const HdRenderPassStateSharedPtr &renderPassState,
+                                  const TfTokenVector &renderTags)
+{
+  Scene *const scene = _renderParam->session->scene;
+  Session *const session = _renderParam->session;
+
+  if (session->progress.get_cancel()) {
+    return;  // Something went wrong and cannot continue without recreating the session
+  }
+
+  if (scene->mutex.try_lock()) {
+    const auto renderDelegate = static_cast<HdCyclesDelegate *>(
+        GetRenderIndex()->GetRenderDelegate());
+
+    const unsigned int settingsVersion = renderDelegate->GetRenderSettingsVersion();
+
+    // Update requested AOV bindings
+    const HdRenderPassAovBindingVector &aovBindings = renderPassState->GetAovBindings();
+    if (_renderParam->GetAovBindings() != aovBindings ||
+        // Need to resync passes when denoising is enabled or disabled to update the pass mode
+        (settingsVersion != _lastSettingsVersion &&
+         scene->integrator->use_denoise_is_modified())) {
+      _renderParam->SyncAovBindings(aovBindings);
+
+      if (renderDelegate->IsDisplaySupported()) {
+        // Update display pass to the first requested color AOV
+        HdRenderPassAovBinding displayAovBinding = !aovBindings.empty() ? aovBindings.front() :
+                                                                          HdRenderPassAovBinding();
+        if (displayAovBinding.aovName == HdAovTokens->color && displayAovBinding.renderBuffer) {
+          _renderParam->SetDisplayAovBinding(displayAovBinding);
+        }
+        else {
+          _renderParam->SetDisplayAovBinding(HdRenderPassAovBinding());
+        }
+      }
+    }
+
+    // Update camera dimensions to the viewport size
+#if PXR_VERSION >= 2102
+    CameraUtilFraming framing = renderPassState->GetFraming();
+    if (!framing.IsValid()) {
+      const GfVec4f vp = renderPassState->GetViewport();
+      framing = CameraUtilFraming(GfRect2i(GfVec2i(0), int(vp[2]), int(vp[3])));
+    }
+
+    scene->camera->set_full_width(framing.dataWindow.GetWidth());
+    scene->camera->set_full_height(framing.dataWindow.GetHeight());
+#else
+    const GfVec4f vp = renderPassState->GetViewport();
+    scene->camera->set_full_width(int(vp[2]));
+    scene->camera->set_full_height(int(vp[3]));
+#endif
+
+    if (const auto camera = static_cast<const HdCyclesCamera *>(renderPassState->GetCamera())) {
+      camera->ApplyCameraSettings(scene->camera);
+    }
+    else {
+      HdCyclesCamera::ApplyCameraSettings(renderPassState->GetWorldToViewMatrix(),
+                                          renderPassState->GetProjectionMatrix(),
+                                          renderPassState->GetClipPlanes(),
+                                          scene->camera);
+    }
+
+    // Reset session if the session, scene, camera or AOV bindings changed
+    if (scene->need_reset() || settingsVersion != _lastSettingsVersion) {
+      _lastSettingsVersion = settingsVersion;
+
+      // Reset convergence state of all render buffers
+      ResetConverged();
+
+      BufferParams buffer_params;
+#if PXR_VERSION >= 2102
+      buffer_params.full_x = static_cast<int>(framing.displayWindow.GetMin()[0]);
+      buffer_params.full_y = static_cast<int>(framing.displayWindow.GetMin()[1]);
+      buffer_params.full_width = static_cast<int>(framing.displayWindow.GetSize()[0]);
+      buffer_params.full_height = static_cast<int>(framing.displayWindow.GetSize()[1]);
+
+      buffer_params.window_x = framing.dataWindow.GetMinX() - buffer_params.full_x;
+      buffer_params.window_y = framing.dataWindow.GetMinY() - buffer_params.full_y;
+      buffer_params.window_width = framing.dataWindow.GetWidth();
+      buffer_params.window_height = framing.dataWindow.GetHeight();
+
+      buffer_params.width = buffer_params.window_width;
+      buffer_params.height = buffer_params.window_height;
+#else
+      buffer_params.width = static_cast<int>(vp[2]);
+      buffer_params.height = static_cast<int>(vp[3]);
+      buffer_params.full_width = buffer_params.width;
+      buffer_params.full_height = buffer_params.height;
+      buffer_params.window_width = buffer_params.width;
+      buffer_params.window_height = buffer_params.height;
+#endif
+
+      session->reset(session->params, buffer_params);
+    }
+
+    scene->mutex.unlock();
+
+    // Start Cycles render thread if not already running
+    session->start();
+  }
+
+  session->draw();
+}
+
+void HdCyclesRenderPass::_MarkCollectionDirty()
+{
+}
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/render_pass.h

@@ -0,0 +1,34 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#pragma once
+
+#include "hydra/config.h"
+
+#include <pxr/imaging/hd/renderPass.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+class HdCyclesRenderPass final : public PXR_NS::HdRenderPass {
+ public:
+  HdCyclesRenderPass(PXR_NS::HdRenderIndex *index,
+                     const PXR_NS::HdRprimCollection &collection,
+                     HdCyclesSession *renderParam);
+  ~HdCyclesRenderPass() override;
+
+  bool IsConverged() const override;
+
+ private:
+  void ResetConverged();
+
+  void _Execute(const PXR_NS::HdRenderPassStateSharedPtr &renderPassState,
+                const PXR_NS::TfTokenVector &renderTags) override;
+
+  void _MarkCollectionDirty() override;
+
+  HdCyclesSession *_renderParam;
+  unsigned int _lastSettingsVersion = 0;
+};
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/resources/plugInfo.json

@@ -0,0 +1,22 @@
+{
+    "Plugins": [
+        {
+            "Info": {
+                "Types": {
+                    "HdCyclesPlugin": {
+                        "bases": [
+                            "HdRendererPlugin"
+                        ],
+                        "displayName": "Cycles",
+                        "priority": 0
+                    }
+                }
+            },
+            "LibraryPath": "@PLUG_INFO_LIBRARY_PATH@",
+            "Name": "hdCycles",
+            "ResourcePath": "@PLUG_INFO_RESOURCE_PATH@",
+            "Root": "@PLUG_INFO_ROOT@",
+            "Type": "library"
+        }
+    ]
+}

intern/cycles/hydra/session.cpp

@@ -0,0 +1,170 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#include "hydra/session.h"
+#include "scene/shader.h"
+// Have to include shader.h before background.h so that 'set_shader' uses the correct 'set'
+// overload taking a 'Node *', rather than the one taking a 'bool'
+#include "scene/background.h"
+#include "scene/light.h"
+#include "scene/shader_graph.h"
+#include "scene/shader_nodes.h"
+#include "session/session.h"
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+namespace {
+
+const std::unordered_map<TfToken, PassType, TfToken::HashFunctor> kAovToPass = {
+    {HdAovTokens->color, PASS_COMBINED},
+    {HdAovTokens->depth, PASS_DEPTH},
+    {HdAovTokens->normal, PASS_NORMAL},
+    {HdAovTokens->primId, PASS_OBJECT_ID},
+    {HdAovTokens->instanceId, PASS_AOV_VALUE},
+};
+
+}  // namespace
+
+SceneLock::SceneLock(const HdRenderParam *renderParam)
+    : scene(static_cast<const HdCyclesSession *>(renderParam)->session->scene),
+      sceneLock(scene->mutex)
+{
+}
+
+SceneLock::~SceneLock()
+{
+}
+
+HdCyclesSession::HdCyclesSession(Session *session_) : session(session_), _ownCyclesSession(false)
+{
+}
+
+HdCyclesSession::HdCyclesSession(const SessionParams &params)
+    : session(new Session(params, SceneParams())), _ownCyclesSession(true)
+{
+  Scene *const scene = session->scene;
+
+  // Create background with ambient light
+  {
+    ShaderGraph *graph = new ShaderGraph();
+
+    BackgroundNode *bgNode = graph->create_node<BackgroundNode>();
+    bgNode->set_color(one_float3());
+    graph->add(bgNode);
+
+    graph->connect(bgNode->output("Background"), graph->output()->input("Surface"));
+
+    scene->default_background->set_graph(graph);
+    scene->default_background->tag_update(scene);
+  }
+
+  // Wire up object color in default surface material
+  {
+    ShaderGraph *graph = new ShaderGraph();
+
+    ObjectInfoNode *objectNode = graph->create_node<ObjectInfoNode>();
+    graph->add(objectNode);
+
+    DiffuseBsdfNode *diffuseNode = graph->create_node<DiffuseBsdfNode>();
+    graph->add(diffuseNode);
+
+    graph->connect(objectNode->output("Color"), diffuseNode->input("Color"));
+    graph->connect(diffuseNode->output("BSDF"), graph->output()->input("Surface"));
+
+#if 1
+    // Create the instanceId AOV output
+    const ustring instanceId(HdAovTokens->instanceId.GetString());
+
+    OutputAOVNode *aovNode = graph->create_node<OutputAOVNode>();
+    aovNode->set_name(instanceId);
+    graph->add(aovNode);
+
+    AttributeNode *instanceIdNode = graph->create_node<AttributeNode>();
+    instanceIdNode->set_attribute(instanceId);
+    graph->add(instanceIdNode);
+
+    graph->connect(instanceIdNode->output("Fac"), aovNode->input("Value"));
+#endif
+
+    scene->default_surface->set_graph(graph);
+    scene->default_surface->tag_update(scene);
+  }
+}
+
+HdCyclesSession::~HdCyclesSession()
+{
+  if (_ownCyclesSession) {
+    delete session;
+  }
+}
+
+void HdCyclesSession::UpdateScene()
+{
+  Scene *const scene = session->scene;
+
+  // Update background depending on presence of a background light
+  if (scene->light_manager->need_update()) {
+    Light *background_light = nullptr;
+    for (Light *light : scene->lights) {
+      if (light->get_light_type() == LIGHT_BACKGROUND) {
+        background_light = light;
+        break;
+      }
+    }
+
+    if (!background_light) {
+      scene->background->set_shader(scene->default_background);
+      scene->background->set_transparent(true);
+    }
+    else {
+      scene->background->set_shader(background_light->get_shader());
+      scene->background->set_transparent(false);
+    }
+
+    scene->background->tag_update(scene);
+  }
+}
+
+void HdCyclesSession::SyncAovBindings(const HdRenderPassAovBindingVector &aovBindings)
+{
+  Scene *const scene = session->scene;
+
+  // Delete all existing passes
+  scene->delete_nodes(set<Pass *>(scene->passes.begin(), scene->passes.end()));
+
+  // Update passes with requested AOV bindings
+  _aovBindings = aovBindings;
+  for (const HdRenderPassAovBinding &aovBinding : aovBindings) {
+    const auto cyclesAov = kAovToPass.find(aovBinding.aovName);
+    if (cyclesAov == kAovToPass.end()) {
+      // TODO: Use PASS_AOV_COLOR and PASS_AOV_VALUE for these?
+      TF_WARN("Unknown pass %s", aovBinding.aovName.GetText());
+      continue;
+    }
+
+    const PassType type = cyclesAov->second;
+    const PassMode mode = PassMode::DENOISED;
+
+    Pass *pass = scene->create_node<Pass>();
+    pass->set_type(type);
+    pass->set_mode(mode);
+    pass->set_name(ustring(aovBinding.aovName.GetString()));
+  }
+}
+
+void HdCyclesSession::RemoveAovBinding(HdRenderBuffer *renderBuffer)
+{
+  for (HdRenderPassAovBinding &aovBinding : _aovBindings) {
+    if (renderBuffer == aovBinding.renderBuffer) {
+      aovBinding.renderBuffer = nullptr;
+      break;
+    }
+  }
+
+  if (renderBuffer == _displayAovBinding.renderBuffer) {
+    _displayAovBinding.renderBuffer = nullptr;
+  }
+}
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/session.h

@@ -0,0 +1,59 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#pragma once
+
+#include "hydra/config.h"
+#include "util/thread.h"
+
+#include <pxr/imaging/hd/renderDelegate.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+struct SceneLock {
+  SceneLock(const PXR_NS::HdRenderParam *renderParam);
+  ~SceneLock();
+
+  CCL_NS::Scene *scene;
+
+ private:
+  CCL_NS::thread_scoped_lock sceneLock;
+};
+
+class HdCyclesSession final : public PXR_NS::HdRenderParam {
+ public:
+  HdCyclesSession(CCL_NS::Session *session_);
+  HdCyclesSession(const CCL_NS::SessionParams &params);
+  ~HdCyclesSession() override;
+
+  void UpdateScene();
+
+  PXR_NS::HdRenderPassAovBinding GetDisplayAovBinding() const
+  {
+    return _displayAovBinding;
+  }
+
+  void SetDisplayAovBinding(const PXR_NS::HdRenderPassAovBinding &aovBinding)
+  {
+    _displayAovBinding = aovBinding;
+  }
+
+  const PXR_NS::HdRenderPassAovBindingVector &GetAovBindings() const
+  {
+    return _aovBindings;
+  }
+
+  void SyncAovBindings(const PXR_NS::HdRenderPassAovBindingVector &aovBindings);
+
+  void RemoveAovBinding(PXR_NS::HdRenderBuffer *renderBuffer);
+
+  CCL_NS::Session *session;
+
+ private:
+  const bool _ownCyclesSession;
+  PXR_NS::HdRenderPassAovBindingVector _aovBindings;
+  PXR_NS::HdRenderPassAovBinding _displayAovBinding;
+};
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/volume.cpp

@@ -0,0 +1,91 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#include "hydra/volume.h"
+#include "hydra/field.h"
+#include "hydra/geometry.inl"
+#include "scene/volume.h"
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+// clang-format off
+TF_DEFINE_PRIVATE_TOKENS(_tokens,
+   (openvdbAsset)
+);
+// clang-format on
+
+HdCyclesVolume::HdCyclesVolume(const SdfPath &rprimId
+#if PXR_VERSION < 2102
+                               ,
+                               const SdfPath &instancerId
+#endif
+                               )
+    : HdCyclesGeometry(rprimId
+#if PXR_VERSION < 2102
+                       ,
+                       instancerId
+#endif
+      )
+{
+}
+
+HdCyclesVolume::~HdCyclesVolume()
+{
+}
+
+HdDirtyBits HdCyclesVolume::GetInitialDirtyBitsMask() const
+{
+  HdDirtyBits bits = HdCyclesGeometry::GetInitialDirtyBitsMask();
+  bits |= HdChangeTracker::DirtyVolumeField;
+  return bits;
+}
+
+void HdCyclesVolume::Populate(HdSceneDelegate *sceneDelegate, HdDirtyBits dirtyBits, bool &rebuild)
+{
+  Scene *const scene = (Scene *)_geom->get_owner();
+
+  if (dirtyBits & HdChangeTracker::DirtyVolumeField) {
+    for (const HdVolumeFieldDescriptor &field :
+         sceneDelegate->GetVolumeFieldDescriptors(GetId())) {
+      if (const auto openvdbAsset = static_cast<HdCyclesField *>(
+              sceneDelegate->GetRenderIndex().GetBprim(_tokens->openvdbAsset, field.fieldId))) {
+        const ustring name(field.fieldName.GetString());
+
+        AttributeStandard std = ATTR_STD_NONE;
+        if (name == Attribute::standard_name(ATTR_STD_VOLUME_DENSITY)) {
+          std = ATTR_STD_VOLUME_DENSITY;
+        }
+        else if (name == Attribute::standard_name(ATTR_STD_VOLUME_COLOR)) {
+          std = ATTR_STD_VOLUME_COLOR;
+        }
+        else if (name == Attribute::standard_name(ATTR_STD_VOLUME_FLAME)) {
+          std = ATTR_STD_VOLUME_FLAME;
+        }
+        else if (name == Attribute::standard_name(ATTR_STD_VOLUME_HEAT)) {
+          std = ATTR_STD_VOLUME_HEAT;
+        }
+        else if (name == Attribute::standard_name(ATTR_STD_VOLUME_TEMPERATURE)) {
+          std = ATTR_STD_VOLUME_TEMPERATURE;
+        }
+        else if (name == Attribute::standard_name(ATTR_STD_VOLUME_VELOCITY)) {
+          std = ATTR_STD_VOLUME_VELOCITY;
+        }
+
+        // Skip attributes that are not needed
+        if ((std != ATTR_STD_NONE && _geom->need_attribute(scene, std)) ||
+            _geom->need_attribute(scene, name)) {
+          Attribute *const attr = (std != ATTR_STD_NONE) ?
+                                      _geom->attributes.add(std) :
+                                      _geom->attributes.add(
+                                          name, TypeDesc::TypeFloat, ATTR_ELEMENT_VOXEL);
+          attr->data_voxel() = openvdbAsset->GetImageHandle();
+        }
+      }
+    }
+
+    rebuild = true;
+  }
+}
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/hydra/volume.h

@@ -0,0 +1,33 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2022 NVIDIA Corporation
+ * Copyright 2022 Blender Foundation */
+
+#pragma once
+
+#include "hydra/config.h"
+#include "hydra/geometry.h"
+
+#include <pxr/imaging/hd/volume.h>
+
+HDCYCLES_NAMESPACE_OPEN_SCOPE
+
+class HdCyclesVolume final : public HdCyclesGeometry<PXR_NS::HdVolume, CCL_NS::Volume> {
+ public:
+  HdCyclesVolume(
+      const PXR_NS::SdfPath &rprimId
+#if PXR_VERSION < 2102
+      ,
+      const PXR_NS::SdfPath &instancerId = {}
+#endif
+  );
+  ~HdCyclesVolume() override;
+
+  PXR_NS::HdDirtyBits GetInitialDirtyBitsMask() const override;
+
+ private:
+  void Populate(PXR_NS::HdSceneDelegate *sceneDelegate,
+                PXR_NS::HdDirtyBits dirtyBits,
+                bool &rebuild) override;
+};
+
+HDCYCLES_NAMESPACE_CLOSE_SCOPE

intern/cycles/integrator/denoiser.cpp

@@ -80,7 +80,8 @@ static bool is_single_supported_device(Device *device, DenoiserType type)
 
   if (!device->info.multi_devices.empty()) {
     /* Some configurations will use multi_devices, but keep the type of an individual device.
-     * This does simplify checks for homogenous setups, but here we really need a single device. */
+     * This does simplify checks for homogeneous setups, but here we really need a single device.
+     */
     return false;
   }
 

intern/cycles/integrator/path_trace.cpp

@@ -466,7 +466,7 @@ void PathTrace::set_denoiser_params(const DenoiseParams &params)
   denoiser_ = Denoiser::create(device_, params);
 
   /* Only take into account the "immediate" cancel to have interactive rendering responding to
-   * navigation as quickly as possible, but allow to run denoiser after user hit Esc button while
+   * navigation as quickly as possible, but allow to run denoiser after user hit Escape key while
    * doing offline rendering. */
   denoiser_->is_cancelled_cb = [this]() { return render_cancel_.is_requested; };
 }

intern/cycles/integrator/render_scheduler.cpp

@@ -20,7 +20,7 @@ RenderScheduler::RenderScheduler(TileManager &tile_manager, const SessionParams
       background_(params.background),
       pixel_size_(params.pixel_size),
       tile_manager_(tile_manager),
-      default_start_resolution_divider_(pixel_size_ * 8)
+      default_start_resolution_divider_(params.use_resolution_divider ? pixel_size_ * 8 : 0)
 {
   use_progressive_noise_floor_ = !background_;
 }
@@ -119,7 +119,7 @@ void RenderScheduler::reset(const BufferParams &buffer_params, int num_samples,
 
   /* In background mode never do lower resolution render preview, as it is not really supported
    * by the software. */
-  if (background_) {
+  if (background_ || start_resolution_divider_ == 0) {
     state_.resolution_divider = 1;
   }
   else {
@@ -1050,6 +1050,10 @@ bool RenderScheduler::work_need_rebalance()
 
 void RenderScheduler::update_start_resolution_divider()
 {
+  if (default_start_resolution_divider_ == 0) {
+    return;
+  }
+
   if (start_resolution_divider_ == 0) {
     /* Resolution divider has never been calculated before: use default resolution, so that we have
      * somewhat good initial behavior, giving a chance to collect real numbers. */

intern/cycles/kernel/CMakeLists.txt

@@ -50,7 +50,6 @@ set(SRC_KERNEL_DEVICE_GPU_HEADERS
   device/gpu/kernel.h
   device/gpu/parallel_active_index.h
   device/gpu/parallel_prefix_sum.h
-  device/gpu/parallel_reduce.h
   device/gpu/parallel_sorted_index.h
   device/gpu/work_stealing.h
 )

intern/cycles/kernel/bvh/shadow_all.h

@@ -29,8 +29,8 @@ ccl_device_inline
                                      IntegratorShadowState state,
                                      const uint visibility,
                                      const uint max_hits,
-                                     ccl_private uint *num_recorded_hits,
-                                     ccl_private float *throughput)
+                                     ccl_private uint *r_num_recorded_hits,
+                                     ccl_private float *r_throughput)
 {
   /* todo:
    * - likely and unlikely for if() statements
@@ -60,15 +60,18 @@ ccl_device_inline
    * recorded hits is exceeded and we no longer need to find hits beyond the max
    * distance found. */
   float t_max_world = ray->t;
-  /* Equal to t_max_world when traversing top level BVH, transformed into local
-   * space when entering instances. */
-  float t_max_current = t_max_world;
+
+  /* Current maximum distance to the intersection.
+   * Is calculated as a ray length, transformed to an object space when entering
+   * instance node. */
+  float t_max_current = ray->t;
+
   /* Conversion from world to local space for the current instance if any, 1.0
    * otherwise. */
   float t_world_to_instance = 1.0f;
 
-  *num_recorded_hits = 0;
-  *throughput = 1.0f;
+  *r_num_recorded_hits = 0;
+  *r_throughput = 1.0f;
 
   /* traversal loop */
   do {
@@ -237,10 +240,10 @@ ccl_device_inline
 
               /* Always use baked shadow transparency for curves. */
               if (isect.type & PRIMITIVE_CURVE) {
-                *throughput *= intersection_curve_shadow_transparency(
+                *r_throughput *= intersection_curve_shadow_transparency(
                     kg, isect.object, isect.prim, isect.u);
 
-                if (*throughput < CURVE_SHADOW_TRANSPARENCY_CUTOFF) {
+                if (*r_throughput < CURVE_SHADOW_TRANSPARENCY_CUTOFF) {
                   return true;
                 }
                 else {
@@ -249,37 +252,39 @@ ccl_device_inline
               }
 
               if (record_intersection) {
-                /* Increase the number of hits, possibly beyond max_hits, we will
-                 * simply not record those and only keep the max_hits closest. */
-                uint record_index = (*num_recorded_hits)++;
-
+                /* Test if we need to record this transparent intersection. */
                 const uint max_record_hits = min(max_hits, INTEGRATOR_SHADOW_ISECT_SIZE);
-                if (record_index >= max_record_hits - 1) {
-                  /* If maximum number of hits reached, find the intersection with
-                   * the largest distance to potentially replace when another hit
-                   * is found. */
-                  const int num_recorded_hits = min(max_record_hits, record_index);
-                  float max_recorded_t = INTEGRATOR_STATE_ARRAY(state, shadow_isect, 0, t);
-                  int max_recorded_hit = 0;
+                if (*r_num_recorded_hits < max_record_hits || isect.t < t_max_world) {
+                  /* If maximum number of hits was reached, replace the intersection with the
+                   * highest distance. We want to find the N closest intersections. */
+                  const uint num_recorded_hits = min(*r_num_recorded_hits, max_record_hits);
+                  uint isect_index = num_recorded_hits;
+                  if (num_recorded_hits + 1 >= max_record_hits) {
+                    float max_t = INTEGRATOR_STATE_ARRAY(state, shadow_isect, 0, t);
+                    uint max_recorded_hit = 0;
 
-                  for (int i = 1; i < num_recorded_hits; i++) {
-                    const float isect_t = INTEGRATOR_STATE_ARRAY(state, shadow_isect, i, t);
-                    if (isect_t > max_recorded_t) {
-                      max_recorded_t = isect_t;
-                      max_recorded_hit = i;
+                    for (uint i = 1; i < num_recorded_hits; ++i) {
+                      const float isect_t = INTEGRATOR_STATE_ARRAY(state, shadow_isect, i, t);
+                      if (isect_t > max_t) {
+                        max_recorded_hit = i;
+                        max_t = isect_t;
+                      }
                     }
+
+                    if (num_recorded_hits >= max_record_hits) {
+                      isect_index = max_recorded_hit;
+                    }
+
+                    /* Limit the ray distance and stop counting hits beyond this. */
+                    t_max_world = max(isect.t, max_t);
                   }
 
-                  if (record_index >= max_record_hits) {
-                    record_index = max_recorded_hit;
-                  }
-
-                  /* Limit the ray distance and stop counting hits beyond this. */
-                  t_max_world = max(max_recorded_t, isect.t);
-                  t_max_current = t_max_world * t_world_to_instance;
+                  integrator_state_write_shadow_isect(state, &isect, isect_index);
                 }
 
-                integrator_state_write_shadow_isect(state, &isect, record_index);
+                /* Always increase the number of recorded hits, even beyond the maximum,
+                 * so that we can detect this and trace another ray if needed. */
+                ++(*r_num_recorded_hits);
               }
             }
           }
@@ -318,7 +323,7 @@ ccl_device_inline
 #endif
 
       /* Restore world space ray length. */
-      t_max_current = t_max_world;
+      t_max_current = ray->t;
 
       object = OBJECT_NONE;
       t_world_to_instance = 1.0f;

intern/cycles/kernel/device/cpu/image.h

@@ -31,7 +31,17 @@ ccl_device_inline float frac(float x, int *ix)
   return x - (float)i;
 }
 
-template<typename T> struct TextureInterpolator {
+template<typename TexT, typename OutT = float4> struct TextureInterpolator {
+
+  static ccl_always_inline OutT zero()
+  {
+    if constexpr (std::is_same<OutT, float4>::value) {
+      return zero_float4();
+    }
+    else {
+      return 0.0f;
+    }
+  }
 
   static ccl_always_inline float4 read(float4 r)
   {
@@ -40,21 +50,18 @@ template<typename T> struct TextureInterpolator {
 
   static ccl_always_inline float4 read(uchar4 r)
   {
-    float f = 1.0f / 255.0f;
+    const float f = 1.0f / 255.0f;
     return make_float4(r.x * f, r.y * f, r.z * f, r.w * f);
   }
 
-  static ccl_always_inline float4 read(uchar r)
+  static ccl_always_inline float read(uchar r)
   {
-    float f = r * (1.0f / 255.0f);
-    return make_float4(f, f, f, 1.0f);
+    return r * (1.0f / 255.0f);
   }
 
-  static ccl_always_inline float4 read(float r)
+  static ccl_always_inline float read(float r)
   {
-    /* TODO(dingto): Optimize this, so interpolation
-     * happens on float instead of float4 */
-    return make_float4(r, r, r, 1.0f);
+    return r;
   }
 
   static ccl_always_inline float4 read(half4 r)
@@ -62,37 +69,131 @@ template<typename T> struct TextureInterpolator {
     return half4_to_float4_image(r);
   }
 
-  static ccl_always_inline float4 read(half r)
+  static ccl_always_inline float read(half r)
   {
-    float f = half_to_float_image(r);
-    return make_float4(f, f, f, 1.0f);
+    return half_to_float_image(r);
   }
 
-  static ccl_always_inline float4 read(uint16_t r)
+  static ccl_always_inline float read(uint16_t r)
   {
-    float f = r * (1.0f / 65535.0f);
-    return make_float4(f, f, f, 1.0f);
+    return r * (1.0f / 65535.0f);
   }
 
   static ccl_always_inline float4 read(ushort4 r)
   {
-    float f = 1.0f / 65535.0f;
+    const float f = 1.0f / 65535.0f;
     return make_float4(r.x * f, r.y * f, r.z * f, r.w * f);
   }
 
-  static ccl_always_inline float4 read(const T *data, int x, int y, int width, int height)
+  /* Read 2D Texture Data
+   * Does not check if data request is in bounds. */
+  static ccl_always_inline OutT read(const TexT *data, int x, int y, int width, int height)
   {
-    if (x < 0 || y < 0 || x >= width || y >= height) {
-      return make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+    return read(data[y * width + x]);
+  }
+
+  /* Read 2D Texture Data Clip
+   * Returns transparent black if data request is out of bounds. */
+  static ccl_always_inline OutT read_clip(const TexT *data, int x, int y, int width, int height)
+  {
+    if (x < 0 || x >= width || y < 0 || y >= height) {
+      return zero();
     }
     return read(data[y * width + x]);
   }
 
+  /* Read 3D Texture Data
+   * Does not check if data request is in bounds. */
+  static ccl_always_inline OutT
+  read(const TexT *data, int x, int y, int z, int width, int height, int depth)
+  {
+    return read(data[x + y * width + z * width * height]);
+  }
+
+  /* Read 3D Texture Data Clip
+   * Returns transparent black if data request is out of bounds. */
+  static ccl_always_inline OutT
+  read_clip(const TexT *data, int x, int y, int z, int width, int height, int depth)
+  {
+    if (x < 0 || x >= width || y < 0 || y >= height || z < 0 || z >= depth) {
+      return zero();
+    }
+    return read(data[x + y * width + z * width * height]);
+  }
+
+  /* Trilinear Interpolation */
+  static ccl_always_inline OutT
+  trilinear_lookup(const TexT *data,
+                   float tx,
+                   float ty,
+                   float tz,
+                   int ix,
+                   int iy,
+                   int iz,
+                   int nix,
+                   int niy,
+                   int niz,
+                   int width,
+                   int height,
+                   int depth,
+                   OutT read(const TexT *, int, int, int, int, int, int))
+  {
+    OutT r = (1.0f - tz) * (1.0f - ty) * (1.0f - tx) *
+             read(data, ix, iy, iz, width, height, depth);
+    r += (1.0f - tz) * (1.0f - ty) * tx * read(data, nix, iy, iz, width, height, depth);
+    r += (1.0f - tz) * ty * (1.0f - tx) * read(data, ix, niy, iz, width, height, depth);
+    r += (1.0f - tz) * ty * tx * read(data, nix, niy, iz, width, height, depth);
+
+    r += tz * (1.0f - ty) * (1.0f - tx) * read(data, ix, iy, niz, width, height, depth);
+    r += tz * (1.0f - ty) * tx * read(data, nix, iy, niz, width, height, depth);
+    r += tz * ty * (1.0f - tx) * read(data, ix, niy, niz, width, height, depth);
+    r += tz * ty * tx * read(data, nix, niy, niz, width, height, depth);
+    return r;
+  }
+
+  /** Tricubic Interpolation */
+  static ccl_always_inline OutT
+  tricubic_lookup(const TexT *data,
+                  float tx,
+                  float ty,
+                  float tz,
+                  const int xc[4],
+                  const int yc[4],
+                  const int zc[4],
+                  int width,
+                  int height,
+                  int depth,
+                  OutT read(const TexT *, int, int, int, int, int, int))
+  {
+    float u[4], v[4], w[4];
+
+    /* Some helper macros to keep code size reasonable.
+     * Lets the compiler inline all the matrix multiplications.
+     */
+#define DATA(x, y, z) (read(data, xc[x], yc[y], zc[z], width, height, depth))
+#define COL_TERM(col, row) \
+  (v[col] * (u[0] * DATA(0, col, row) + u[1] * DATA(1, col, row) + u[2] * DATA(2, col, row) + \
+             u[3] * DATA(3, col, row)))
+#define ROW_TERM(row) \
+  (w[row] * (COL_TERM(0, row) + COL_TERM(1, row) + COL_TERM(2, row) + COL_TERM(3, row)))
+
+    SET_CUBIC_SPLINE_WEIGHTS(u, tx);
+    SET_CUBIC_SPLINE_WEIGHTS(v, ty);
+    SET_CUBIC_SPLINE_WEIGHTS(w, tz);
+    /* Actual interpolation. */
+    return ROW_TERM(0) + ROW_TERM(1) + ROW_TERM(2) + ROW_TERM(3);
+
+#undef COL_TERM
+#undef ROW_TERM
+#undef DATA
+  }
+
   static ccl_always_inline int wrap_periodic(int x, int width)
   {
     x %= width;
-    if (x < 0)
+    if (x < 0) {
       x += width;
+    }
     return x;
   }
 
@@ -103,9 +204,8 @@ template<typename T> struct TextureInterpolator {
 
   /* ********  2D interpolation ******** */
 
-  static ccl_always_inline float4 interp_closest(const TextureInfo &info, float x, float y)
+  static ccl_always_inline OutT interp_closest(const TextureInfo &info, float x, float y)
   {
-    const T *data = (const T *)info.data;
     const int width = info.width;
     const int height = info.height;
     int ix, iy;
@@ -117,105 +217,134 @@ template<typename T> struct TextureInterpolator {
         iy = wrap_periodic(iy, height);
         break;
       case EXTENSION_CLIP:
-        if (x < 0.0f || y < 0.0f || x > 1.0f || y > 1.0f) {
-          return make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+        /* No samples are inside the clip region. */
+        if (ix < 0 || ix >= width || iy < 0 || iy >= height) {
+          return zero();
         }
-        ATTR_FALLTHROUGH;
+        break;
       case EXTENSION_EXTEND:
         ix = wrap_clamp(ix, width);
         iy = wrap_clamp(iy, height);
         break;
       default:
         kernel_assert(0);
-        return make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+        return zero();
     }
-    return read(data[ix + iy * width]);
+
+    const TexT *data = (const TexT *)info.data;
+    return read((const TexT *)data, ix, iy, width, height);
   }
 
-  static ccl_always_inline float4 interp_linear(const TextureInfo &info, float x, float y)
+  static ccl_always_inline OutT interp_linear(const TextureInfo &info, float x, float y)
   {
-    const T *data = (const T *)info.data;
     const int width = info.width;
     const int height = info.height;
-    int ix, iy, nix, niy;
+
+    /* A -0.5 offset is used to center the linear samples around the sample point. */
+    int ix, iy;
+    int nix, niy;
     const float tx = frac(x * (float)width - 0.5f, &ix);
     const float ty = frac(y * (float)height - 0.5f, &iy);
+
     switch (info.extension) {
       case EXTENSION_REPEAT:
         ix = wrap_periodic(ix, width);
-        iy = wrap_periodic(iy, height);
         nix = wrap_periodic(ix + 1, width);
+
+        iy = wrap_periodic(iy, height);
         niy = wrap_periodic(iy + 1, height);
         break;
       case EXTENSION_CLIP:
+        /* No linear samples are inside the clip region. */
+        if (ix < -1 || ix >= width || iy < -1 || iy >= height) {
+          return zero();
+        }
         nix = ix + 1;
         niy = iy + 1;
         break;
       case EXTENSION_EXTEND:
         nix = wrap_clamp(ix + 1, width);
-        niy = wrap_clamp(iy + 1, height);
         ix = wrap_clamp(ix, width);
+        niy = wrap_clamp(iy + 1, height);
         iy = wrap_clamp(iy, height);
         break;
       default:
         kernel_assert(0);
-        return make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+        return zero();
     }
-    return (1.0f - ty) * (1.0f - tx) * read(data, ix, iy, width, height) +
-           (1.0f - ty) * tx * read(data, nix, iy, width, height) +
-           ty * (1.0f - tx) * read(data, ix, niy, width, height) +
-           ty * tx * read(data, nix, niy, width, height);
+
+    const TexT *data = (const TexT *)info.data;
+    return (1.0f - ty) * (1.0f - tx) * read_clip(data, ix, iy, width, height) +
+           (1.0f - ty) * tx * read_clip(data, nix, iy, width, height) +
+           ty * (1.0f - tx) * read_clip(data, ix, niy, width, height) +
+           ty * tx * read_clip(data, nix, niy, width, height);
   }
 
-  static ccl_always_inline float4 interp_cubic(const TextureInfo &info, float x, float y)
+  static ccl_always_inline OutT interp_cubic(const TextureInfo &info, float x, float y)
   {
-    const T *data = (const T *)info.data;
     const int width = info.width;
     const int height = info.height;
-    int ix, iy, nix, niy;
+
+    /* A -0.5 offset is used to center the cubic samples around the sample point. */
+    int ix, iy;
     const float tx = frac(x * (float)width - 0.5f, &ix);
     const float ty = frac(y * (float)height - 0.5f, &iy);
-    int pix, piy, nnix, nniy;
+
+    int pix, piy;
+    int nix, niy;
+    int nnix, nniy;
+
     switch (info.extension) {
       case EXTENSION_REPEAT:
         ix = wrap_periodic(ix, width);
-        iy = wrap_periodic(iy, height);
         pix = wrap_periodic(ix - 1, width);
-        piy = wrap_periodic(iy - 1, height);
         nix = wrap_periodic(ix + 1, width);
-        niy = wrap_periodic(iy + 1, height);
         nnix = wrap_periodic(ix + 2, width);
+
+        iy = wrap_periodic(iy, height);
+        piy = wrap_periodic(iy - 1, height);
+        niy = wrap_periodic(iy + 1, height);
         nniy = wrap_periodic(iy + 2, height);
         break;
       case EXTENSION_CLIP:
+        /* No cubic samples are inside the clip region. */
+        if (ix < -2 || ix > width || iy < -2 || iy > height) {
+          return zero();
+        }
+
         pix = ix - 1;
-        piy = iy - 1;
         nix = ix + 1;
-        niy = iy + 1;
         nnix = ix + 2;
+
+        piy = iy - 1;
+        niy = iy + 1;
         nniy = iy + 2;
         break;
       case EXTENSION_EXTEND:
         pix = wrap_clamp(ix - 1, width);
-        piy = wrap_clamp(iy - 1, height);
         nix = wrap_clamp(ix + 1, width);
-        niy = wrap_clamp(iy + 1, height);
         nnix = wrap_clamp(ix + 2, width);
-        nniy = wrap_clamp(iy + 2, height);
         ix = wrap_clamp(ix, width);
+
+        piy = wrap_clamp(iy - 1, height);
+        niy = wrap_clamp(iy + 1, height);
+        nniy = wrap_clamp(iy + 2, height);
         iy = wrap_clamp(iy, height);
         break;
       default:
         kernel_assert(0);
-        return make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+        return zero();
     }
+
+    const TexT *data = (const TexT *)info.data;
     const int xc[4] = {pix, ix, nix, nnix};
     const int yc[4] = {piy, iy, niy, nniy};
     float u[4], v[4];
-    /* Some helper macro to keep code reasonable size,
-     * let compiler to inline all the matrix multiplications.
+
+    /* Some helper macros to keep code size reasonable.
+     * Lets the compiler inline all the matrix multiplications.
      */
-#define DATA(x, y) (read(data, xc[x], yc[y], width, height))
+#define DATA(x, y) (read_clip(data, xc[x], yc[y], width, height))
 #define TERM(col) \
   (v[col] * \
    (u[0] * DATA(0, col) + u[1] * DATA(1, col) + u[2] * DATA(2, col) + u[3] * DATA(3, col)))
@@ -229,11 +358,8 @@ template<typename T> struct TextureInterpolator {
 #undef DATA
   }
 
-  static ccl_always_inline float4 interp(const TextureInfo &info, float x, float y)
+  static ccl_always_inline OutT interp(const TextureInfo &info, float x, float y)
   {
-    if (UNLIKELY(!info.data)) {
-      return make_float4(0.0f, 0.0f, 0.0f, 0.0f);
-    }
     switch (info.interpolation) {
       case INTERPOLATION_CLOSEST:
         return interp_closest(info, x, y);
@@ -246,14 +372,14 @@ template<typename T> struct TextureInterpolator {
 
   /* ********  3D interpolation ******** */
 
-  static ccl_always_inline float4 interp_3d_closest(const TextureInfo &info,
-                                                    float x,
-                                                    float y,
-                                                    float z)
+  static ccl_always_inline OutT interp_3d_closest(const TextureInfo &info,
+                                                  float x,
+                                                  float y,
+                                                  float z)
   {
-    int width = info.width;
-    int height = info.height;
-    int depth = info.depth;
+    const int width = info.width;
+    const int height = info.height;
+    const int depth = info.depth;
     int ix, iy, iz;
 
     frac(x * (float)width, &ix);
@@ -267,10 +393,11 @@ template<typename T> struct TextureInterpolator {
         iz = wrap_periodic(iz, depth);
         break;
       case EXTENSION_CLIP:
-        if (x < 0.0f || y < 0.0f || z < 0.0f || x > 1.0f || y > 1.0f || z > 1.0f) {
-          return make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+        /* No samples are inside the clip region. */
+        if (ix < 0 || ix >= width || iy < 0 || iy >= height || iz < 0 || iz >= depth) {
+          return zero();
         }
-        ATTR_FALLTHROUGH;
+        break;
       case EXTENSION_EXTEND:
         ix = wrap_clamp(ix, width);
         iy = wrap_clamp(iy, height);
@@ -278,24 +405,25 @@ template<typename T> struct TextureInterpolator {
         break;
       default:
         kernel_assert(0);
-        return make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+        return zero();
     }
 
-    const T *data = (const T *)info.data;
-    return read(data[ix + iy * width + iz * width * height]);
+    const TexT *data = (const TexT *)info.data;
+    return read(data, ix, iy, iz, width, height, depth);
   }
 
-  static ccl_always_inline float4 interp_3d_linear(const TextureInfo &info,
-                                                   float x,
-                                                   float y,
-                                                   float z)
+  static ccl_always_inline OutT interp_3d_linear(const TextureInfo &info,
+                                                 float x,
+                                                 float y,
+                                                 float z)
   {
-    int width = info.width;
-    int height = info.height;
-    int depth = info.depth;
+    const int width = info.width;
+    const int height = info.height;
+    const int depth = info.depth;
     int ix, iy, iz;
     int nix, niy, niz;
 
+    /* A -0.5 offset is used to center the linear samples around the sample point. */
     float tx = frac(x * (float)width - 0.5f, &ix);
     float ty = frac(y * (float)height - 0.5f, &iy);
     float tz = frac(z * (float)depth - 0.5f, &iz);
@@ -303,50 +431,79 @@ template<typename T> struct TextureInterpolator {
     switch (info.extension) {
       case EXTENSION_REPEAT:
         ix = wrap_periodic(ix, width);
-        iy = wrap_periodic(iy, height);
-        iz = wrap_periodic(iz, depth);
-
         nix = wrap_periodic(ix + 1, width);
+
+        iy = wrap_periodic(iy, height);
         niy = wrap_periodic(iy + 1, height);
+
+        iz = wrap_periodic(iz, depth);
         niz = wrap_periodic(iz + 1, depth);
         break;
       case EXTENSION_CLIP:
-        if (x < 0.0f || y < 0.0f || z < 0.0f || x > 1.0f || y > 1.0f || z > 1.0f) {
-          return make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+        /* No linear samples are inside the clip region. */
+        if (ix < -1 || ix >= width || iy < -1 || iy >= height || iz < -1 || iz >= depth) {
+          return zero();
         }
-        ATTR_FALLTHROUGH;
+
+        nix = ix + 1;
+        niy = iy + 1;
+        niz = iz + 1;
+
+        /* All linear samples are inside the clip region. */
+        if (ix >= 0 && nix < width && iy >= 0 && niy < height && iz >= 0 && niz < depth) {
+          break;
+        }
+
+        /* The linear samples span the clip border.
+         * #read_clip is used to ensure proper interpolation across the clip border. */
+        return trilinear_lookup((const TexT *)info.data,
+                                tx,
+                                ty,
+                                tz,
+                                ix,
+                                iy,
+                                iz,
+                                nix,
+                                niy,
+                                niz,
+                                width,
+                                height,
+                                depth,
+                                read_clip);
       case EXTENSION_EXTEND:
         nix = wrap_clamp(ix + 1, width);
-        niy = wrap_clamp(iy + 1, height);
-        niz = wrap_clamp(iz + 1, depth);
-
         ix = wrap_clamp(ix, width);
+
+        niy = wrap_clamp(iy + 1, height);
         iy = wrap_clamp(iy, height);
+
+        niz = wrap_clamp(iz + 1, depth);
         iz = wrap_clamp(iz, depth);
         break;
       default:
         kernel_assert(0);
-        return make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+        return zero();
     }
 
-    const T *data = (const T *)info.data;
-    float4 r;
-
-    r = (1.0f - tz) * (1.0f - ty) * (1.0f - tx) *
-        read(data[ix + iy * width + iz * width * height]);
-    r += (1.0f - tz) * (1.0f - ty) * tx * read(data[nix + iy * width + iz * width * height]);
-    r += (1.0f - tz) * ty * (1.0f - tx) * read(data[ix + niy * width + iz * width * height]);
-    r += (1.0f - tz) * ty * tx * read(data[nix + niy * width + iz * width * height]);
-
-    r += tz * (1.0f - ty) * (1.0f - tx) * read(data[ix + iy * width + niz * width * height]);
-    r += tz * (1.0f - ty) * tx * read(data[nix + iy * width + niz * width * height]);
-    r += tz * ty * (1.0f - tx) * read(data[ix + niy * width + niz * width * height]);
-    r += tz * ty * tx * read(data[nix + niy * width + niz * width * height]);
-
-    return r;
+    return trilinear_lookup((const TexT *)info.data,
+                            tx,
+                            ty,
+                            tz,
+                            ix,
+                            iy,
+                            iz,
+                            nix,
+                            niy,
+                            niz,
+                            width,
+                            height,
+                            depth,
+                            read);
   }
 
-  /* TODO(sergey): For some unspeakable reason both GCC-6 and Clang-3.9 are
+  /* Tricubic b-spline interpolation.
+   *
+   * TODO(sergey): For some unspeakable reason both GCC-6 and Clang-3.9 are
    * causing stack overflow issue in this function unless it is inlined.
    *
    * Only happens for AVX2 kernel and global __KERNEL_SSE__ vectorization
@@ -357,100 +514,101 @@ template<typename T> struct TextureInterpolator {
 #else
   static ccl_never_inline
 #endif
-      float4
+      OutT
       interp_3d_cubic(const TextureInfo &info, float x, float y, float z)
   {
     int width = info.width;
     int height = info.height;
     int depth = info.depth;
     int ix, iy, iz;
-    int nix, niy, niz;
-    /* Tricubic b-spline interpolation. */
+
+    /* A -0.5 offset is used to center the cubic samples around the sample point. */
     const float tx = frac(x * (float)width - 0.5f, &ix);
     const float ty = frac(y * (float)height - 0.5f, &iy);
     const float tz = frac(z * (float)depth - 0.5f, &iz);
-    int pix, piy, piz, nnix, nniy, nniz;
+
+    int pix, piy, piz;
+    int nix, niy, niz;
+    int nnix, nniy, nniz;
 
     switch (info.extension) {
       case EXTENSION_REPEAT:
         ix = wrap_periodic(ix, width);
-        iy = wrap_periodic(iy, height);
-        iz = wrap_periodic(iz, depth);
-
         pix = wrap_periodic(ix - 1, width);
-        piy = wrap_periodic(iy - 1, height);
-        piz = wrap_periodic(iz - 1, depth);
-
         nix = wrap_periodic(ix + 1, width);
-        niy = wrap_periodic(iy + 1, height);
-        niz = wrap_periodic(iz + 1, depth);
-
         nnix = wrap_periodic(ix + 2, width);
+
+        iy = wrap_periodic(iy, height);
+        niy = wrap_periodic(iy + 1, height);
+        piy = wrap_periodic(iy - 1, height);
         nniy = wrap_periodic(iy + 2, height);
+
+        iz = wrap_periodic(iz, depth);
+        piz = wrap_periodic(iz - 1, depth);
+        niz = wrap_periodic(iz + 1, depth);
         nniz = wrap_periodic(iz + 2, depth);
         break;
-      case EXTENSION_CLIP:
-        if (x < 0.0f || y < 0.0f || z < 0.0f || x > 1.0f || y > 1.0f || z > 1.0f) {
-          return make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+      case EXTENSION_CLIP: {
+        /* No cubic samples are inside the clip region. */
+        if (ix < -2 || ix > width || iy < -2 || iy > height || iz < -2 || iz > depth) {
+          return zero();
         }
-        ATTR_FALLTHROUGH;
+
+        pix = ix - 1;
+        nnix = ix + 2;
+        nix = ix + 1;
+
+        piy = iy - 1;
+        niy = iy + 1;
+        nniy = iy + 2;
+
+        piz = iz - 1;
+        niz = iz + 1;
+        nniz = iz + 2;
+
+        /* All cubic samples are inside the clip region. */
+        if (pix >= 0 && nnix < width && piy >= 0 && nniy < height && piz >= 0 && nniz < depth) {
+          break;
+        }
+
+        /* The Cubic samples span the clip border.
+         * read_clip is used to ensure proper interpolation across the clip border. */
+        const int xc[4] = {pix, ix, nix, nnix};
+        const int yc[4] = {piy, iy, niy, nniy};
+        const int zc[4] = {piz, iz, niz, nniz};
+        return tricubic_lookup(
+            (const TexT *)info.data, tx, ty, tz, xc, yc, zc, width, height, depth, read_clip);
+      }
       case EXTENSION_EXTEND:
         pix = wrap_clamp(ix - 1, width);
-        piy = wrap_clamp(iy - 1, height);
-        piz = wrap_clamp(iz - 1, depth);
-
         nix = wrap_clamp(ix + 1, width);
-        niy = wrap_clamp(iy + 1, height);
-        niz = wrap_clamp(iz + 1, depth);
-
         nnix = wrap_clamp(ix + 2, width);
-        nniy = wrap_clamp(iy + 2, height);
-        nniz = wrap_clamp(iz + 2, depth);
-
         ix = wrap_clamp(ix, width);
+
+        piy = wrap_clamp(iy - 1, height);
+        niy = wrap_clamp(iy + 1, height);
+        nniy = wrap_clamp(iy + 2, height);
         iy = wrap_clamp(iy, height);
+
+        piz = wrap_clamp(iz - 1, depth);
+        niz = wrap_clamp(iz + 1, depth);
+        nniz = wrap_clamp(iz + 2, depth);
         iz = wrap_clamp(iz, depth);
         break;
       default:
         kernel_assert(0);
-        return make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+        return zero();
     }
-
     const int xc[4] = {pix, ix, nix, nnix};
-    const int yc[4] = {width * piy, width * iy, width * niy, width * nniy};
-    const int zc[4] = {
-        width * height * piz, width * height * iz, width * height * niz, width * height * nniz};
-    float u[4], v[4], w[4];
-
-    /* Some helper macro to keep code reasonable size,
-     * let compiler to inline all the matrix multiplications.
-     */
-#define DATA(x, y, z) (read(data[xc[x] + yc[y] + zc[z]]))
-#define COL_TERM(col, row) \
-  (v[col] * (u[0] * DATA(0, col, row) + u[1] * DATA(1, col, row) + u[2] * DATA(2, col, row) + \
-             u[3] * DATA(3, col, row)))
-#define ROW_TERM(row) \
-  (w[row] * (COL_TERM(0, row) + COL_TERM(1, row) + COL_TERM(2, row) + COL_TERM(3, row)))
-
-    SET_CUBIC_SPLINE_WEIGHTS(u, tx);
-    SET_CUBIC_SPLINE_WEIGHTS(v, ty);
-    SET_CUBIC_SPLINE_WEIGHTS(w, tz);
-
-    /* Actual interpolation. */
-    const T *data = (const T *)info.data;
-    return ROW_TERM(0) + ROW_TERM(1) + ROW_TERM(2) + ROW_TERM(3);
-
-#undef COL_TERM
-#undef ROW_TERM
-#undef DATA
+    const int yc[4] = {piy, iy, niy, nniy};
+    const int zc[4] = {piz, iz, niz, nniz};
+    const TexT *data = (const TexT *)info.data;
+    return tricubic_lookup(data, tx, ty, tz, xc, yc, zc, width, height, depth, read);
   }
 
-  static ccl_always_inline float4
+  static ccl_always_inline OutT
   interp_3d(const TextureInfo &info, float x, float y, float z, InterpolationType interp)
   {
-    if (UNLIKELY(!info.data))
-      return make_float4(0.0f, 0.0f, 0.0f, 0.0f);
-
     switch ((interp == INTERPOLATION_NONE) ? info.interpolation : interp) {
       case INTERPOLATION_CLOSEST:
         return interp_3d_closest(info, x, y, z);
@@ -463,13 +621,13 @@ template<typename T> struct TextureInterpolator {
 };
 
 #ifdef WITH_NANOVDB
-template<typename T> struct NanoVDBInterpolator {
+template<typename TexT, typename OutT = float4> struct NanoVDBInterpolator {
 
-  typedef typename nanovdb::NanoGrid<T>::AccessorType AccessorType;
+  typedef typename nanovdb::NanoGrid<TexT>::AccessorType AccessorType;
 
-  static ccl_always_inline float4 read(float r)
+  static ccl_always_inline float read(float r)
   {
-    return make_float4(r, r, r, 1.0f);
+    return r;
   }
 
   static ccl_always_inline float4 read(nanovdb::Vec3f r)
@@ -477,40 +635,43 @@ template<typename T> struct NanoVDBInterpolator {
     return make_float4(r[0], r[1], r[2], 1.0f);
   }
 
-  static ccl_always_inline float4 interp_3d_closest(const AccessorType &acc,
-                                                    float x,
-                                                    float y,
-                                                    float z)
+  static ccl_always_inline OutT interp_3d_closest(const AccessorType &acc,
+                                                  float x,
+                                                  float y,
+                                                  float z)
   {
     const nanovdb::Vec3f xyz(x, y, z);
     return read(nanovdb::SampleFromVoxels<AccessorType, 0, false>(acc)(xyz));
   }
 
-  static ccl_always_inline float4 interp_3d_linear(const AccessorType &acc,
-                                                   float x,
-                                                   float y,
-                                                   float z)
+  static ccl_always_inline OutT interp_3d_linear(const AccessorType &acc,
+                                                 float x,
+                                                 float y,
+                                                 float z)
   {
     const nanovdb::Vec3f xyz(x - 0.5f, y - 0.5f, z - 0.5f);
     return read(nanovdb::SampleFromVoxels<AccessorType, 1, false>(acc)(xyz));
   }
 
+  /* Tricubic b-spline interpolation. */
 #  if defined(__GNUC__) || defined(__clang__)
   static ccl_always_inline
 #  else
   static ccl_never_inline
 #  endif
-      float4
+      OutT
       interp_3d_cubic(const AccessorType &acc, float x, float y, float z)
   {
     int ix, iy, iz;
     int nix, niy, niz;
     int pix, piy, piz;
     int nnix, nniy, nniz;
-    /* Tricubic b-spline interpolation. */
+
+    /* A -0.5 offset is used to center the cubic samples around the sample point. */
     const float tx = frac(x - 0.5f, &ix);
     const float ty = frac(y - 0.5f, &iy);
     const float tz = frac(z - 0.5f, &iz);
+
     pix = ix - 1;
     piy = iy - 1;
     piz = iz - 1;
@@ -526,8 +687,8 @@ template<typename T> struct NanoVDBInterpolator {
     const int zc[4] = {piz, iz, niz, nniz};
     float u[4], v[4], w[4];
 
-    /* Some helper macro to keep code reasonable size,
-     * let compiler to inline all the matrix multiplications.
+    /* Some helper macros to keep code size reasonable.
+     * Lets the compiler inline all the matrix multiplications.
      */
 #  define DATA(x, y, z) (read(acc.getValue(nanovdb::Coord(xc[x], yc[y], zc[z]))))
 #  define COL_TERM(col, row) \
@@ -548,12 +709,12 @@ template<typename T> struct NanoVDBInterpolator {
 #  undef DATA
   }
 
-  static ccl_always_inline float4
+  static ccl_always_inline OutT
   interp_3d(const TextureInfo &info, float x, float y, float z, InterpolationType interp)
   {
     using namespace nanovdb;
 
-    NanoGrid<T> *const grid = (NanoGrid<T> *)info.data;
+    NanoGrid<TexT> *const grid = (NanoGrid<TexT> *)info.data;
     AccessorType acc = grid->getAccessor();
 
     switch ((interp == INTERPOLATION_NONE) ? info.interpolation : interp) {
@@ -574,15 +735,27 @@ ccl_device float4 kernel_tex_image_interp(KernelGlobals kg, int id, float x, flo
 {
   const TextureInfo &info = kernel_tex_fetch(__texture_info, id);
 
+  if (UNLIKELY(!info.data)) {
+    return zero_float4();
+  }
+
   switch (info.data_type) {
-    case IMAGE_DATA_TYPE_HALF:
-      return TextureInterpolator<half>::interp(info, x, y);
-    case IMAGE_DATA_TYPE_BYTE:
-      return TextureInterpolator<uchar>::interp(info, x, y);
-    case IMAGE_DATA_TYPE_USHORT:
-      return TextureInterpolator<uint16_t>::interp(info, x, y);
-    case IMAGE_DATA_TYPE_FLOAT:
-      return TextureInterpolator<float>::interp(info, x, y);
+    case IMAGE_DATA_TYPE_HALF: {
+      const float f = TextureInterpolator<half, float>::interp(info, x, y);
+      return make_float4(f, f, f, 1.0f);
+    }
+    case IMAGE_DATA_TYPE_BYTE: {
+      const float f = TextureInterpolator<uchar, float>::interp(info, x, y);
+      return make_float4(f, f, f, 1.0f);
+    }
+    case IMAGE_DATA_TYPE_USHORT: {
+      const float f = TextureInterpolator<uint16_t, float>::interp(info, x, y);
+      return make_float4(f, f, f, 1.0f);
+    }
+    case IMAGE_DATA_TYPE_FLOAT: {
+      const float f = TextureInterpolator<float, float>::interp(info, x, y);
+      return make_float4(f, f, f, 1.0f);
+    }
     case IMAGE_DATA_TYPE_HALF4:
       return TextureInterpolator<half4>::interp(info, x, y);
     case IMAGE_DATA_TYPE_BYTE4:
@@ -605,19 +778,30 @@ ccl_device float4 kernel_tex_image_interp_3d(KernelGlobals kg,
 {
   const TextureInfo &info = kernel_tex_fetch(__texture_info, id);
 
+  if (UNLIKELY(!info.data)) {
+    return zero_float4();
+  }
+
   if (info.use_transform_3d) {
     P = transform_point(&info.transform_3d, P);
   }
-
   switch (info.data_type) {
-    case IMAGE_DATA_TYPE_HALF:
-      return TextureInterpolator<half>::interp_3d(info, P.x, P.y, P.z, interp);
-    case IMAGE_DATA_TYPE_BYTE:
-      return TextureInterpolator<uchar>::interp_3d(info, P.x, P.y, P.z, interp);
-    case IMAGE_DATA_TYPE_USHORT:
-      return TextureInterpolator<uint16_t>::interp_3d(info, P.x, P.y, P.z, interp);
-    case IMAGE_DATA_TYPE_FLOAT:
-      return TextureInterpolator<float>::interp_3d(info, P.x, P.y, P.z, interp);
+    case IMAGE_DATA_TYPE_HALF: {
+      const float f = TextureInterpolator<half, float>::interp_3d(info, P.x, P.y, P.z, interp);
+      return make_float4(f, f, f, 1.0f);
+    }
+    case IMAGE_DATA_TYPE_BYTE: {
+      const float f = TextureInterpolator<uchar, float>::interp_3d(info, P.x, P.y, P.z, interp);
+      return make_float4(f, f, f, 1.0f);
+    }
+    case IMAGE_DATA_TYPE_USHORT: {
+      const float f = TextureInterpolator<uint16_t, float>::interp_3d(info, P.x, P.y, P.z, interp);
+      return make_float4(f, f, f, 1.0f);
+    }
+    case IMAGE_DATA_TYPE_FLOAT: {
+      const float f = TextureInterpolator<float, float>::interp_3d(info, P.x, P.y, P.z, interp);
+      return make_float4(f, f, f, 1.0f);
+    }
     case IMAGE_DATA_TYPE_HALF4:
       return TextureInterpolator<half4>::interp_3d(info, P.x, P.y, P.z, interp);
     case IMAGE_DATA_TYPE_BYTE4:
@@ -627,8 +811,10 @@ ccl_device float4 kernel_tex_image_interp_3d(KernelGlobals kg,
     case IMAGE_DATA_TYPE_FLOAT4:
       return TextureInterpolator<float4>::interp_3d(info, P.x, P.y, P.z, interp);
 #ifdef WITH_NANOVDB
-    case IMAGE_DATA_TYPE_NANOVDB_FLOAT:
-      return NanoVDBInterpolator<float>::interp_3d(info, P.x, P.y, P.z, interp);
+    case IMAGE_DATA_TYPE_NANOVDB_FLOAT: {
+      const float f = NanoVDBInterpolator<float, float>::interp_3d(info, P.x, P.y, P.z, interp);
+      return make_float4(f, f, f, 1.0f);
+    }
     case IMAGE_DATA_TYPE_NANOVDB_FLOAT3:
       return NanoVDBInterpolator<nanovdb::Vec3f>::interp_3d(info, P.x, P.y, P.z, interp);
 #endif

intern/cycles/kernel/device/cuda/compat.h

@@ -72,7 +72,6 @@ typedef unsigned long long uint64_t;
 
 #define ccl_gpu_syncthreads() __syncthreads()
 #define ccl_gpu_ballot(predicate) __ballot_sync(0xFFFFFFFF, predicate)
-#define ccl_gpu_shfl_down_sync(mask, var, detla) __shfl_down_sync(mask, var, detla)
 
 /* GPU texture objects */
 

intern/cycles/kernel/device/gpu/image.h

@@ -186,7 +186,7 @@ ccl_device float4 kernel_tex_image_interp(KernelGlobals kg, int id, float x, flo
   const int texture_type = info.data_type;
   if (texture_type == IMAGE_DATA_TYPE_FLOAT4 || texture_type == IMAGE_DATA_TYPE_BYTE4 ||
       texture_type == IMAGE_DATA_TYPE_HALF4 || texture_type == IMAGE_DATA_TYPE_USHORT4) {
-    if (info.interpolation == INTERPOLATION_CUBIC) {
+    if (info.interpolation == INTERPOLATION_CUBIC || info.interpolation == INTERPOLATION_SMART) {
       return kernel_tex_image_interp_bicubic<float4>(info, x, y);
     }
     else {
@@ -198,7 +198,7 @@ ccl_device float4 kernel_tex_image_interp(KernelGlobals kg, int id, float x, flo
   else {
     float f;
 
-    if (info.interpolation == INTERPOLATION_CUBIC) {
+    if (info.interpolation == INTERPOLATION_CUBIC || info.interpolation == INTERPOLATION_SMART) {
       f = kernel_tex_image_interp_bicubic<float>(info, x, y);
     }
     else {
@@ -241,7 +241,7 @@ ccl_device float4 kernel_tex_image_interp_3d(KernelGlobals kg,
 #endif
   if (texture_type == IMAGE_DATA_TYPE_FLOAT4 || texture_type == IMAGE_DATA_TYPE_BYTE4 ||
       texture_type == IMAGE_DATA_TYPE_HALF4 || texture_type == IMAGE_DATA_TYPE_USHORT4) {
-    if (interpolation == INTERPOLATION_CUBIC) {
+    if (interpolation == INTERPOLATION_CUBIC || interpolation == INTERPOLATION_SMART) {
       return kernel_tex_image_interp_tricubic<float4>(info, x, y, z);
     }
     else {
@@ -252,7 +252,7 @@ ccl_device float4 kernel_tex_image_interp_3d(KernelGlobals kg,
   else {
     float f;
 
-    if (interpolation == INTERPOLATION_CUBIC) {
+    if (interpolation == INTERPOLATION_CUBIC || interpolation == INTERPOLATION_SMART) {
       f = kernel_tex_image_interp_tricubic<float>(info, x, y, z);
     }
     else {

intern/cycles/kernel/device/gpu/parallel_reduce.h

@@ -1,74 +0,0 @@
-/* SPDX-License-Identifier: Apache-2.0
- * Copyright 2021-2022 Blender Foundation */
-
-#pragma once
-
-CCL_NAMESPACE_BEGIN
-
-/* Parallel sum of array input_data with size n into output_sum.
- *
- * Adapted from "Optimizing Parallel Reduction in GPU", Mark Harris.
- *
- * This version adds multiple elements per thread sequentially.  This reduces
- * the overall cost of the algorithm while keeping the work complexity O(n) and
- * the step complexity O(log n). (Brent's Theorem optimization) */
-
-#ifdef __HIP__
-#  define GPU_PARALLEL_SUM_DEFAULT_BLOCK_SIZE 1024
-#else
-#  define GPU_PARALLEL_SUM_DEFAULT_BLOCK_SIZE 512
-#endif
-
-template<uint blocksize, typename InputT, typename OutputT, typename ConvertOp>
-__device__ void gpu_parallel_sum(
-    const InputT *input_data, const uint n, OutputT *output_sum, OutputT zero, ConvertOp convert)
-{
-  extern ccl_gpu_shared OutputT shared_data[];
-
-  const uint tid = ccl_gpu_thread_idx_x;
-  const uint gridsize = blocksize * ccl_gpu_grid_dim_x();
-
-  OutputT sum = zero;
-  for (uint i = ccl_gpu_block_idx_x * blocksize + tid; i < n; i += gridsize) {
-    sum += convert(input_data[i]);
-  }
-  shared_data[tid] = sum;
-
-  ccl_gpu_syncthreads();
-
-  if (blocksize >= 512 && tid < 256) {
-    shared_data[tid] = sum = sum + shared_data[tid + 256];
-  }
-
-  ccl_gpu_syncthreads();
-
-  if (blocksize >= 256 && tid < 128) {
-    shared_data[tid] = sum = sum + shared_data[tid + 128];
-  }
-
-  ccl_gpu_syncthreads();
-
-  if (blocksize >= 128 && tid < 64) {
-    shared_data[tid] = sum = sum + shared_data[tid + 64];
-  }
-
-  ccl_gpu_syncthreads();
-
-  if (blocksize >= 64 && tid < 32) {
-    shared_data[tid] = sum = sum + shared_data[tid + 32];
-  }
-
-  ccl_gpu_syncthreads();
-
-  if (tid < 32) {
-    for (int offset = ccl_gpu_warp_size / 2; offset > 0; offset /= 2) {
-      sum += ccl_shfl_down_sync(0xFFFFFFFF, sum, offset);
-    }
-  }
-
-  if (tid == 0) {
-    output_sum[ccl_gpu_block_idx_x] = sum;
-  }
-}
-
-CCL_NAMESPACE_END

intern/cycles/kernel/device/hip/compat.h

@@ -62,7 +62,7 @@ typedef unsigned long long uint64_t;
 #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_thread_mask(thread_warp) uint64_t(0xFFFFFFFFFFFFFFFF >> (64 - 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)
@@ -71,7 +71,6 @@ typedef unsigned long long uint64_t;
 
 #define ccl_gpu_syncthreads() __syncthreads()
 #define ccl_gpu_ballot(predicate) __ballot(predicate)
-#define ccl_gpu_shfl_down_sync(mask, var, detla) __shfl_down(var, detla)
 
 /* GPU texture objects */
 typedef hipTextureObject_t ccl_gpu_tex_object;

intern/cycles/kernel/device/optix/compat.h

@@ -74,7 +74,6 @@ typedef unsigned long long uint64_t;
 
 #define ccl_gpu_syncthreads() __syncthreads()
 #define ccl_gpu_ballot(predicate) __ballot_sync(0xFFFFFFFF, predicate)
-#define ccl_gpu_shfl_down_sync(mask, var, detla) __shfl_down_sync(mask, var, detla)
 
 /* GPU texture objects */
 

intern/cycles/kernel/film/accumulate.h

@@ -352,6 +352,12 @@ ccl_device_inline void kernel_accum_emission_or_background_pass(KernelGlobals kg
     pass_offset = pass;
   }
   else if (kernel_data.kernel_features & KERNEL_FEATURE_LIGHT_PASSES) {
+    /* Don't write any light passes for shadow catcher, for easier
+     * compositing back together of the combined pass. */
+    if (path_flag & PATH_RAY_SHADOW_CATCHER_HIT) {
+      return;
+    }
+
     if (path_flag & PATH_RAY_SURFACE_PASS) {
       /* Indirectly visible through reflection. */
       const float3 diffuse_weight = INTEGRATOR_STATE(state, path, pass_diffuse_weight);
@@ -437,6 +443,12 @@ ccl_device_inline void kernel_accum_light(KernelGlobals kg,
   if (kernel_data.film.light_pass_flag & PASS_ANY) {
     const uint32_t path_flag = INTEGRATOR_STATE(state, shadow_path, flag);
 
+    /* Don't write any light passes for shadow catcher, for easier
+     * compositing back together of the combined pass. */
+    if (path_flag & PATH_RAY_SHADOW_CATCHER_HIT) {
+      return;
+    }
+
     if (kernel_data.kernel_features & KERNEL_FEATURE_LIGHT_PASSES) {
       int pass_offset = PASS_UNUSED;
 

intern/cycles/kernel/film/read.h

@@ -451,7 +451,7 @@ ccl_device_inline float4 film_calculate_shadow_catcher_matte_with_shadow(
 
   float scale, scale_exposure;
   if (!film_get_scale_and_scale_exposure(kfilm_convert, buffer, &scale, &scale_exposure)) {
-    return make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+    return zero_float4();
   }
 
   ccl_global const float *in_matte = buffer + kfilm_convert->pass_shadow_catcher_matte;

intern/cycles/kernel/geom/curve.h

@@ -164,7 +164,7 @@ ccl_device float4 curve_attribute_float4(KernelGlobals kg,
     if (dx)
       *dx = sd->du.dx * (f1 - f0);
     if (dy)
-      *dy = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+      *dy = zero_float4();
 #  endif
 
     return (1.0f - sd->u) * f0 + sd->u * f1;
@@ -172,9 +172,9 @@ ccl_device float4 curve_attribute_float4(KernelGlobals kg,
   else {
 #  ifdef __RAY_DIFFERENTIALS__
     if (dx)
-      *dx = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+      *dx = zero_float4();
     if (dy)
-      *dy = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+      *dy = zero_float4();
 #  endif
 
     if (desc.element & (ATTR_ELEMENT_CURVE | ATTR_ELEMENT_OBJECT | ATTR_ELEMENT_MESH)) {
@@ -183,7 +183,7 @@ ccl_device float4 curve_attribute_float4(KernelGlobals kg,
       return kernel_tex_fetch(__attributes_float4, offset);
     }
     else {
-      return make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+      return zero_float4();
     }
   }
 }

intern/cycles/kernel/geom/object.h

@@ -263,6 +263,16 @@ ccl_device_inline float3 object_color(KernelGlobals kg, int object)
   return make_float3(kobject->color[0], kobject->color[1], kobject->color[2]);
 }
 
+/* Alpha of the object */
+
+ccl_device_inline float object_alpha(KernelGlobals kg, int object)
+{
+  if (object == OBJECT_NONE)
+    return 0.0f;
+
+  return kernel_tex_fetch(__objects, object).alpha;
+}
+
 /* Pass ID number of object */
 
 ccl_device_inline float object_pass_id(KernelGlobals kg, int object)

intern/cycles/kernel/geom/patch.h

@@ -391,11 +391,11 @@ ccl_device float4 patch_eval_float4(KernelGlobals kg,
   int num_control = patch_eval_control_verts(
       kg, sd->object, patch, u, v, channel, indices, weights, weights_du, weights_dv);
 
-  float4 val = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+  float4 val = zero_float4();
   if (du)
-    *du = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+    *du = zero_float4();
   if (dv)
-    *dv = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+    *dv = zero_float4();
 
   for (int i = 0; i < num_control; i++) {
     float4 v = kernel_tex_fetch(__attributes_float4, offset + indices[i]);
@@ -428,11 +428,11 @@ ccl_device float4 patch_eval_uchar4(KernelGlobals kg,
   int num_control = patch_eval_control_verts(
       kg, sd->object, patch, u, v, channel, indices, weights, weights_du, weights_dv);
 
-  float4 val = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+  float4 val = zero_float4();
   if (du)
-    *du = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+    *du = zero_float4();
   if (dv)
-    *dv = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+    *dv = zero_float4();
 
   for (int i = 0; i < num_control; i++) {
     float4 v = color_srgb_to_linear_v4(

intern/cycles/kernel/geom/point.h

@@ -83,16 +83,16 @@ ccl_device float4 point_attribute_float4(KernelGlobals kg,
 {
 #  ifdef __RAY_DIFFERENTIALS__
   if (dx)
-    *dx = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+    *dx = zero_float4();
   if (dy)
-    *dy = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+    *dy = zero_float4();
 #  endif
 
   if (desc.element == ATTR_ELEMENT_VERTEX) {
     return kernel_tex_fetch(__attributes_float4, desc.offset + sd->prim);
   }
   else {
-    return make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+    return zero_float4();
   }
 }
 

intern/cycles/kernel/geom/primitive.h

@@ -135,10 +135,10 @@ ccl_device_forceinline float4 primitive_surface_attribute_float4(KernelGlobals k
 #endif
   else {
     if (dx)
-      *dx = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+      *dx = zero_float4();
     if (dy)
-      *dy = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
-    return make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+      *dy = zero_float4();
+    return zero_float4();
   }
 }
 
@@ -187,7 +187,7 @@ ccl_device_inline float4 primitive_volume_attribute_float4(KernelGlobals kg,
     return volume_attribute_float4(kg, sd, desc);
   }
   else {
-    return make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+    return zero_float4();
   }
 }
 #endif

intern/cycles/kernel/geom/subd_triangle.h

@@ -566,9 +566,9 @@ ccl_device_noinline float4 subd_triangle_attribute_float4(KernelGlobals kg,
 #endif /* __PATCH_EVAL__ */
       if (desc.element == ATTR_ELEMENT_FACE) {
     if (dx)
-      *dx = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+      *dx = zero_float4();
     if (dy)
-      *dy = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+      *dy = zero_float4();
 
     return kernel_tex_fetch(__attributes_float4,
                             desc.offset + subd_triangle_patch_face(kg, patch));
@@ -648,19 +648,19 @@ ccl_device_noinline float4 subd_triangle_attribute_float4(KernelGlobals kg,
   }
   else if (desc.element == ATTR_ELEMENT_OBJECT || desc.element == ATTR_ELEMENT_MESH) {
     if (dx)
-      *dx = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+      *dx = zero_float4();
     if (dy)
-      *dy = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+      *dy = zero_float4();
 
     return kernel_tex_fetch(__attributes_float4, desc.offset);
   }
   else {
     if (dx)
-      *dx = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+      *dx = zero_float4();
     if (dy)
-      *dy = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+      *dy = zero_float4();
 
-    return make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+    return zero_float4();
   }
 }
 

intern/cycles/kernel/geom/triangle.h

@@ -338,9 +338,9 @@ ccl_device float4 triangle_attribute_float4(KernelGlobals kg,
   else {
 #ifdef __RAY_DIFFERENTIALS__
     if (dx)
-      *dx = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+      *dx = zero_float4();
     if (dy)
-      *dy = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+      *dy = zero_float4();
 #endif
 
     if (desc.element & (ATTR_ELEMENT_FACE | ATTR_ELEMENT_OBJECT | ATTR_ELEMENT_MESH)) {
@@ -349,7 +349,7 @@ ccl_device float4 triangle_attribute_float4(KernelGlobals kg,
       return kernel_tex_fetch(__attributes_float4, offset);
     }
     else {
-      return make_float4(0.0f, 0.0f, 0.0f, 0.0f);
+      return zero_float4();
     }
   }
 }