cleanup

Iterate over meta strip content and duplicate animation for all strips.
recursively.

.clang-format

@@ -205,6 +205,7 @@ ForEachMacros:
   - FOREACH_SCENE_COLLECTION_BEGIN
   - FOREACH_SCENE_OBJECT_BEGIN
   - FOREACH_SELECTED_BASE_BEGIN
+  - FOREACH_SELECTED_BEZT_BEGIN
   - FOREACH_SELECTED_EDITABLE_OBJECT_BEGIN
   - FOREACH_SELECTED_OBJECT_BEGIN
   - FOREACH_TRANS_DATA_CONTAINER
@@ -268,6 +269,7 @@ ForEachMacros:
 StatementMacros:
   - PyObject_HEAD
   - PyObject_VAR_HEAD
+  - ccl_gpu_kernel_postfix
 
 MacroBlockBegin: "^BSDF_CLOSURE_CLASS_BEGIN$"
 MacroBlockEnd: "^BSDF_CLOSURE_CLASS_END$"

CMakeLists.txt

@@ -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()
@@ -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)
@@ -1884,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)
@@ -1948,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()

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/build_environment/install_deps.sh

@@ -432,8 +432,8 @@ PYTHON_MODULES_PIP=(
 )
 
 
-BOOST_VERSION="1.73.0"
-BOOST_VERSION_SHORT="1.73"
+BOOST_VERSION="1.78.0"
+BOOST_VERSION_SHORT="1.78"
 BOOST_VERSION_MIN="1.49"
 BOOST_VERSION_MEX="2.0"
 BOOST_FORCE_BUILD=false
@@ -442,15 +442,15 @@ BOOST_SKIP=false
 
 TBB_VERSION="2020"
 TBB_VERSION_SHORT="2020"
-TBB_VERSION_UPDATE="_U2"  # Used for source packages...
+TBB_VERSION_UPDATE="_U3"  # Used for source packages...
 TBB_VERSION_MIN="2018"
 TBB_VERSION_MEX="2022"
 TBB_FORCE_BUILD=false
 TBB_FORCE_REBUILD=false
 TBB_SKIP=false
 
-OCIO_VERSION="2.0.0"
-OCIO_VERSION_SHORT="2.0"
+OCIO_VERSION="2.1.1"
+OCIO_VERSION_SHORT="2.1"
 OCIO_VERSION_MIN="2.0"
 OCIO_VERSION_MEX="3.0"
 OCIO_FORCE_BUILD=false
@@ -466,10 +466,10 @@ OPENEXR_FORCE_REBUILD=false
 OPENEXR_SKIP=false
 _with_built_openexr=false
 
-OIIO_VERSION="2.2.15.1"
-OIIO_VERSION_SHORT="2.2"
+OIIO_VERSION="2.3.13.0"
+OIIO_VERSION_SHORT="2.3"
 OIIO_VERSION_MIN="2.1.12"
-OIIO_VERSION_MEX="2.3.0"
+OIIO_VERSION_MEX="2.4.0"
 OIIO_FORCE_BUILD=false
 OIIO_FORCE_REBUILD=false
 OIIO_SKIP=false
@@ -493,7 +493,7 @@ OSL_FORCE_REBUILD=false
 OSL_SKIP=false
 
 # OpenSubdiv needs to be compiled for now
-OSD_VERSION="3.4.3"
+OSD_VERSION="3.4.4"
 OSD_VERSION_SHORT="3.4"
 OSD_VERSION_MIN="3.4"
 OSD_VERSION_MEX="4.0"
@@ -502,19 +502,19 @@ OSD_FORCE_REBUILD=false
 OSD_SKIP=false
 
 # OpenVDB needs to be compiled for now
-OPENVDB_BLOSC_VERSION="1.5.0"
+OPENVDB_BLOSC_VERSION="1.21.1"
 
-OPENVDB_VERSION="8.0.1"
-OPENVDB_VERSION_SHORT="8.0"
-OPENVDB_VERSION_MIN="8.0"
-OPENVDB_VERSION_MEX="8.1"
+OPENVDB_VERSION="9.0.0"
+OPENVDB_VERSION_SHORT="9.0"
+OPENVDB_VERSION_MIN="9.0"
+OPENVDB_VERSION_MEX="9.1"
 OPENVDB_FORCE_BUILD=false
 OPENVDB_FORCE_REBUILD=false
 OPENVDB_SKIP=false
 
 # Alembic needs to be compiled for now
-ALEMBIC_VERSION="1.7.16"
-ALEMBIC_VERSION_SHORT="1.7"
+ALEMBIC_VERSION="1.8.3"
+ALEMBIC_VERSION_SHORT="1.8"
 ALEMBIC_VERSION_MIN="1.7"
 ALEMBIC_VERSION_MEX="2.0"
 ALEMBIC_FORCE_BUILD=false
@@ -537,15 +537,15 @@ OPENCOLLADA_FORCE_BUILD=false
 OPENCOLLADA_FORCE_REBUILD=false
 OPENCOLLADA_SKIP=false
 
-EMBREE_VERSION="3.10.0"
-EMBREE_VERSION_SHORT="3.10"
-EMBREE_VERSION_MIN="3.10"
+EMBREE_VERSION="3.13.3"
+EMBREE_VERSION_SHORT="3.13"
+EMBREE_VERSION_MIN="3.13"
 EMBREE_VERSION_MEX="4.0"
 EMBREE_FORCE_BUILD=false
 EMBREE_FORCE_REBUILD=false
 EMBREE_SKIP=false
 
-OIDN_VERSION="1.4.1"
+OIDN_VERSION="1.4.3"
 OIDN_VERSION_SHORT="1.4"
 OIDN_VERSION_MIN="1.4.0"
 OIDN_VERSION_MEX="1.5"
@@ -553,7 +553,7 @@ OIDN_FORCE_BUILD=false
 OIDN_FORCE_REBUILD=false
 OIDN_SKIP=false
 
-ISPC_VERSION="1.16.0"
+ISPC_VERSION="1.17.0"
 
 FFMPEG_VERSION="4.4"
 FFMPEG_VERSION_SHORT="4.4"
@@ -1029,7 +1029,7 @@ OPENEXR_SOURCE_REPO_UID="0ac2ea34c8f3134148a5df4052e40f155b76f6fb"
 #~ OPENEXR_SOURCE=( "https://github.com/openexr/openexr/archive/$OPENEXR_SOURCE_REPO_UID.tar.gz" )
 
 OIIO_USE_REPO=false
-OIIO_SOURCE=( "https://github.com/OpenImageIO/oiio/archive/Release-$OIIO_VERSION.tar.gz" )
+OIIO_SOURCE=( "https://github.com/OpenImageIO/oiio/archive/refs/tags/v$OIIO_VERSION.tar.gz" )
 #~ OIIO_SOURCE_REPO=( "https://github.com/OpenImageIO/oiio.git" )
 #~ OIIO_SOURCE_REPO_UID="c9e67275a0b248ead96152f6d2221cc0c0f278a4"
 
@@ -2034,7 +2034,7 @@ compile_OIIO() {
       else
         download OIIO_SOURCE[@] "$_src.tar.gz"
         INFO "Unpacking OpenImageIO-$OIIO_VERSION"
-        tar -C $SRC --transform "s,(.*/?)oiio-Release-[^/]*(.*),\1OpenImageIO-$OIIO_VERSION\2,x" -xf $_src.tar.gz
+        tar -C $SRC --transform "s,(.*/?)oiio-[^/]*(.*),\1OpenImageIO-$OIIO_VERSION\2,x" -xf $_src.tar.gz
       fi
     fi
 

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

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)
-  if(NOT FFMPEG_FOUND)
-    warn_hardcoded_paths(ffmpeg)
+  windows_find_package(FFmpeg)
+  if(NOT FFmpeg_FOUND)
+    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)
-  if(NOT OPENEXR_FOUND)
+  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)
@@ -520,17 +531,20 @@ if(WITH_BOOST)
     set(BOOST_LIBRARIES ${Boost_LIBRARIES})
     set(BOOST_LIBPATH ${Boost_LIBRARY_DIRS})
   endif()
+
   set(BOOST_DEFINITIONS "-DBOOST_ALL_NO_LIB")
 endif()
 
 if(WITH_OPENIMAGEIO)
   windows_find_package(OpenImageIO)
-  set(OPENIMAGEIO ${LIBDIR}/OpenImageIO)
-  set(OPENIMAGEIO_LIBPATH ${OPENIMAGEIO}/lib)
-  set(OPENIMAGEIO_INCLUDE_DIRS ${OPENIMAGEIO}/include)
-  set(OIIO_OPTIMIZED optimized ${OPENIMAGEIO_LIBPATH}/OpenImageIO.lib optimized ${OPENIMAGEIO_LIBPATH}/OpenImageIO_Util.lib)
-  set(OIIO_DEBUG debug ${OPENIMAGEIO_LIBPATH}/OpenImageIO_d.lib debug ${OPENIMAGEIO_LIBPATH}/OpenImageIO_Util_d.lib)
-  set(OPENIMAGEIO_LIBRARIES ${OIIO_OPTIMIZED} ${OIIO_DEBUG})
+  if(NOT OpenImageIO_FOUND)
+    set(OPENIMAGEIO ${LIBDIR}/OpenImageIO)
+    set(OPENIMAGEIO_LIBPATH ${OPENIMAGEIO}/lib)
+    set(OPENIMAGEIO_INCLUDE_DIRS ${OPENIMAGEIO}/include)
+    set(OIIO_OPTIMIZED optimized ${OPENIMAGEIO_LIBPATH}/OpenImageIO.lib optimized ${OPENIMAGEIO_LIBPATH}/OpenImageIO_Util.lib)
+    set(OIIO_DEBUG debug ${OPENIMAGEIO_LIBPATH}/OpenImageIO_d.lib debug ${OPENIMAGEIO_LIBPATH}/OpenImageIO_Util_d.lib)
+    set(OPENIMAGEIO_LIBRARIES ${OIIO_OPTIMIZED} ${OIIO_DEBUG})
+  endif()
 
   set(OPENIMAGEIO_DEFINITIONS "-DUSE_TBB=0")
   set(OPENIMAGEIO_IDIFF "${OPENIMAGEIO}/bin/idiff.exe")
@@ -561,31 +575,38 @@ if(WITH_LLVM)
     message(WARNING "LLVM debug libs not present on this system. Using release libs for debug builds.")
     set(LLVM_LIBRARY ${LLVM_LIBRARY_OPTIMIZED})
   endif()
-
 endif()
 
 if(WITH_OPENCOLORIO)
-  set(OPENCOLORIO ${LIBDIR}/OpenColorIO)
-  set(OPENCOLORIO_INCLUDE_DIRS ${OPENCOLORIO}/include)
-  set(OPENCOLORIO_LIBPATH ${OPENCOLORIO}/lib)
-  set(OPENCOLORIO_LIBRARIES
-    optimized ${OPENCOLORIO_LIBPATH}/OpenColorIO.lib
-    optimized ${OPENCOLORIO_LIBPATH}/libyaml-cpp.lib
-    optimized ${OPENCOLORIO_LIBPATH}/libexpatMD.lib
-    optimized ${OPENCOLORIO_LIBPATH}/pystring.lib
-    debug ${OPENCOLORIO_LIBPATH}/OpencolorIO_d.lib
-    debug ${OPENCOLORIO_LIBPATH}/libyaml-cpp_d.lib
-    debug ${OPENCOLORIO_LIBPATH}/libexpatdMD.lib
-    debug ${OPENCOLORIO_LIBPATH}/pystring_d.lib
-  )
+  windows_find_package(OpenColorIO)
+  if(NOT OpenColorIO_FOUND)
+    set(OPENCOLORIO ${LIBDIR}/OpenColorIO)
+    set(OPENCOLORIO_INCLUDE_DIRS ${OPENCOLORIO}/include)
+    set(OPENCOLORIO_LIBPATH ${OPENCOLORIO}/lib)
+    set(OPENCOLORIO_LIBRARIES
+      optimized ${OPENCOLORIO_LIBPATH}/OpenColorIO.lib
+      optimized ${OPENCOLORIO_LIBPATH}/libyaml-cpp.lib
+      optimized ${OPENCOLORIO_LIBPATH}/libexpatMD.lib
+      optimized ${OPENCOLORIO_LIBPATH}/pystring.lib
+      debug ${OPENCOLORIO_LIBPATH}/OpencolorIO_d.lib
+      debug ${OPENCOLORIO_LIBPATH}/libyaml-cpp_d.lib
+      debug ${OPENCOLORIO_LIBPATH}/libexpatdMD.lib
+      debug ${OPENCOLORIO_LIBPATH}/pystring_d.lib
+    )
+  endif()
+
   set(OPENCOLORIO_DEFINITIONS "-DOpenColorIO_SKIP_IMPORTS")
 endif()
 
 if(WITH_OPENVDB)
-  set(OPENVDB ${LIBDIR}/openVDB)
-  set(OPENVDB_LIBPATH ${OPENVDB}/lib)
-  set(OPENVDB_INCLUDE_DIRS ${OPENVDB}/include)
-  set(OPENVDB_LIBRARIES optimized ${OPENVDB_LIBPATH}/openvdb.lib debug ${OPENVDB_LIBPATH}/openvdb_d.lib )
+  windows_find_package(OpenVDB)
+  if(NOT OpenVDB_FOUND)
+    set(OPENVDB ${LIBDIR}/openVDB)
+    set(OPENVDB_LIBPATH ${OPENVDB}/lib)
+    set(OPENVDB_INCLUDE_DIRS ${OPENVDB}/include)
+    set(OPENVDB_LIBRARIES optimized ${OPENVDB_LIBPATH}/openvdb.lib debug ${OPENVDB_LIBPATH}/openvdb_d.lib)
+  endif()
+
   set(OPENVDB_DEFINITIONS -DNOMINMAX -D_USE_MATH_DEFINES)
 endif()
 
@@ -624,21 +645,24 @@ 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 ${LIBDIR}/opensubdiv)
+    set(OPENSUBDIV_INCLUDE_DIRS ${OPENSUBDIV}/include)
+    set(OPENSUBDIV_LIBPATH ${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 +683,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()
 
@@ -683,7 +710,6 @@ if(WITH_OPENAL)
   else()
     set(OPENAL_LIBRARY ${OPENAL_LIBPATH}/wrap_oal.lib)
   endif()
-
 endif()
 
 if(WITH_CODEC_SNDFILE)
@@ -728,7 +754,7 @@ endif()
 
 if(WITH_CYCLES AND WITH_CYCLES_EMBREE)
   windows_find_package(Embree)
-  if(NOT EMBREE_FOUND)
+  if(NOT Embree_FOUND)
     set(EMBREE_INCLUDE_DIRS ${LIBDIR}/embree/include)
     set(EMBREE_LIBRARIES
       optimized ${LIBDIR}/embree/lib/embree3.lib
@@ -756,7 +782,6 @@ endif()
 if(WITH_USD)
   windows_find_package(USD)
   if(NOT USD_FOUND)
-    set(USD_FOUND ON)
     set(USD_INCLUDE_DIRS ${LIBDIR}/usd/include)
     set(USD_RELEASE_LIB ${LIBDIR}/usd/lib/libusd_m.lib)
     set(USD_DEBUG_LIB ${LIBDIR}/usd/lib/libusd_m_d.lib)

doc/doxygen/Doxyfile

@@ -1,4 +1,4 @@
-# Doxyfile 1.9.1
+# Doxyfile 1.9.3
 
 # This file describes the settings to be used by the documentation system
 # doxygen (www.doxygen.org) for a project.
@@ -93,14 +93,6 @@ ALLOW_UNICODE_NAMES    = NO
 
 OUTPUT_LANGUAGE        = English
 
-# The OUTPUT_TEXT_DIRECTION tag is used to specify the direction in which all
-# documentation generated by doxygen is written. Doxygen will use this
-# information to generate all generated output in the proper direction.
-# Possible values are: None, LTR, RTL and Context.
-# The default value is: None.
-
-OUTPUT_TEXT_DIRECTION  = None
-
 # If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member
 # descriptions after the members that are listed in the file and class
 # documentation (similar to Javadoc). Set to NO to disable this.
@@ -258,16 +250,16 @@ TAB_SIZE               = 4
 # the documentation. An alias has the form:
 # name=value
 # For example adding
-# "sideeffect=@par Side Effects:\n"
+# "sideeffect=@par Side Effects:^^"
 # will allow you to put the command \sideeffect (or @sideeffect) in the
 # documentation, which will result in a user-defined paragraph with heading
-# "Side Effects:". You can put \n's in the value part of an alias to insert
-# newlines (in the resulting output). You can put ^^ in the value part of an
-# alias to insert a newline as if a physical newline was in the original file.
-# When you need a literal { or } or , in the value part of an alias you have to
-# escape them by means of a backslash (\), this can lead to conflicts with the
-# commands \{ and \} for these it is advised to use the version @{ and @} or use
-# a double escape (\\{ and \\})
+# "Side Effects:". Note that you cannot put \n's in the value part of an alias
+# to insert newlines (in the resulting output). You can put ^^ in the value part
+# of an alias to insert a newline as if a physical newline was in the original
+# file. When you need a literal { or } or , in the value part of an alias you
+# have to escape them by means of a backslash (\), this can lead to conflicts
+# with the commands \{ and \} for these it is advised to use the version @{ and
+# @} or use a double escape (\\{ and \\})
 
 ALIASES                =
 
@@ -312,8 +304,8 @@ OPTIMIZE_OUTPUT_SLICE  = NO
 # extension. Doxygen has a built-in mapping, but you can override or extend it
 # using this tag. The format is ext=language, where ext is a file extension, and
 # language is one of the parsers supported by doxygen: IDL, Java, JavaScript,
-# Csharp (C#), C, C++, D, PHP, md (Markdown), Objective-C, Python, Slice, VHDL,
-# Fortran (fixed format Fortran: FortranFixed, free formatted Fortran:
+# Csharp (C#), C, C++, Lex, D, PHP, md (Markdown), Objective-C, Python, Slice,
+# VHDL, Fortran (fixed format Fortran: FortranFixed, free formatted Fortran:
 # FortranFree, unknown formatted Fortran: Fortran. In the later case the parser
 # tries to guess whether the code is fixed or free formatted code, this is the
 # default for Fortran type files). For instance to make doxygen treat .inc files
@@ -466,7 +458,7 @@ LOOKUP_CACHE_SIZE      = 3
 # than 0 to get more control over the balance between CPU load and processing
 # speed. At this moment only the input processing can be done using multiple
 # threads. Since this is still an experimental feature the default is set to 1,
-# which efficively disables parallel processing. Please report any issues you
+# which effectively disables parallel processing. Please report any issues you
 # encounter. Generating dot graphs in parallel is controlled by the
 # DOT_NUM_THREADS setting.
 # Minimum value: 0, maximum value: 32, default value: 1.
@@ -610,6 +602,12 @@ HIDE_SCOPE_NAMES       = NO
 
 HIDE_COMPOUND_REFERENCE= NO
 
+# If the SHOW_HEADERFILE tag is set to YES then the documentation for a class
+# will show which file needs to be included to use the class.
+# The default value is: YES.
+
+SHOW_HEADERFILE        = YES
+
 # If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
 # the files that are included by a file in the documentation of that file.
 # The default value is: YES.
@@ -767,7 +765,8 @@ FILE_VERSION_FILTER    =
 # output files in an output format independent way. To create the layout file
 # that represents doxygen's defaults, run doxygen with the -l option. You can
 # optionally specify a file name after the option, if omitted DoxygenLayout.xml
-# will be used as the name of the layout file.
+# will be used as the name of the layout file. See also section "Changing the
+# layout of pages" for information.
 #
 # Note that if you run doxygen from a directory containing a file called
 # DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
@@ -813,18 +812,26 @@ WARNINGS               = YES
 WARN_IF_UNDOCUMENTED   = NO
 
 # If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
-# potential errors in the documentation, such as not documenting some parameters
-# in a documented function, or documenting parameters that don't exist or using
-# markup commands wrongly.
+# potential errors in the documentation, such as documenting some parameters in
+# a documented function twice, or documenting parameters that don't exist or
+# using markup commands wrongly.
 # The default value is: YES.
 
 WARN_IF_DOC_ERROR      = YES
 
+# If WARN_IF_INCOMPLETE_DOC is set to YES, doxygen will warn about incomplete
+# function parameter documentation. If set to NO, doxygen will accept that some
+# parameters have no documentation without warning.
+# The default value is: YES.
+
+WARN_IF_INCOMPLETE_DOC = YES
+
 # This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
 # are documented, but have no documentation for their parameters or return
-# value. If set to NO, doxygen will only warn about wrong or incomplete
-# parameter documentation, but not about the absence of documentation. If
-# EXTRACT_ALL is set to YES then this flag will automatically be disabled.
+# value. If set to NO, doxygen will only warn about wrong parameter
+# documentation, but not about the absence of documentation. If EXTRACT_ALL is
+# set to YES then this flag will automatically be disabled. See also
+# WARN_IF_INCOMPLETE_DOC
 # The default value is: NO.
 
 WARN_NO_PARAMDOC       = NO
@@ -850,7 +857,10 @@ WARN_FORMAT            = "$file:$line: $text"
 
 # The WARN_LOGFILE tag can be used to specify a file to which warning and error
 # messages should be written. If left blank the output is written to standard
-# error (stderr).
+# error (stderr). In case the file specified cannot be opened for writing the
+# warning and error messages are written to standard error. When as file - is
+# specified the warning and error messages are written to standard output
+# (stdout).
 
 WARN_LOGFILE           =
 
@@ -894,10 +904,10 @@ INPUT_ENCODING         = UTF-8
 #
 # If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
 # *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
-# *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc,
-# *.m, *.markdown, *.md, *.mm, *.dox (to be provided as doxygen C comment),
-# *.py, *.pyw, *.f90, *.f95, *.f03, *.f08, *.f18, *.f, *.for, *.vhd, *.vhdl,
-# *.ucf, *.qsf and *.ice.
+# *.hh, *.hxx, *.hpp, *.h++, *.l, *.cs, *.d, *.php, *.php4, *.php5, *.phtml,
+# *.inc, *.m, *.markdown, *.md, *.mm, *.dox (to be provided as doxygen C
+# comment), *.py, *.pyw, *.f90, *.f95, *.f03, *.f08, *.f18, *.f, *.for, *.vhd,
+# *.vhdl, *.ucf, *.qsf and *.ice.
 
 FILE_PATTERNS          =
 
@@ -939,7 +949,7 @@ EXCLUDE_PATTERNS       = .svn \
 # (namespaces, classes, functions, etc.) that should be excluded from the
 # output. The symbol name can be a fully qualified name, a word, or if the
 # wildcard * is used, a substring. Examples: ANamespace, AClass,
-# AClass::ANamespace, ANamespace::*Test
+# ANamespace::AClass, ANamespace::*Test
 #
 # Note that the wildcards are matched against the file with absolute path, so to
 # exclude all test directories use the pattern */test/*
@@ -1224,7 +1234,7 @@ HTML_EXTRA_FILES       =
 
 # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
 # will adjust the colors in the style sheet and background images according to
-# this color. Hue is specified as an angle on a colorwheel, see
+# this color. Hue is specified as an angle on a color-wheel, see
 # https://en.wikipedia.org/wiki/Hue for more information. For instance the value
 # 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
 # purple, and 360 is red again.
@@ -1234,7 +1244,7 @@ HTML_EXTRA_FILES       =
 HTML_COLORSTYLE_HUE    = 220
 
 # The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
-# in the HTML output. For a value of 0 the output will use grayscales only. A
+# in the HTML output. For a value of 0 the output will use gray-scales only. A
 # value of 255 will produce the most vivid colors.
 # Minimum value: 0, maximum value: 255, default value: 100.
 # This tag requires that the tag GENERATE_HTML is set to YES.
@@ -1316,6 +1326,13 @@ GENERATE_DOCSET        = NO
 
 DOCSET_FEEDNAME        = "Doxygen generated docs"
 
+# This tag determines the URL of the docset feed. A documentation feed provides
+# an umbrella under which multiple documentation sets from a single provider
+# (such as a company or product suite) can be grouped.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_FEEDURL         =
+
 # This tag specifies a string that should uniquely identify the documentation
 # set bundle. This should be a reverse domain-name style string, e.g.
 # com.mycompany.MyDocSet. Doxygen will append .docset to the name.
@@ -1341,8 +1358,12 @@ DOCSET_PUBLISHER_NAME  = Publisher
 # If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
 # additional HTML index files: index.hhp, index.hhc, and index.hhk. The
 # index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
-# (see:
-# https://www.microsoft.com/en-us/download/details.aspx?id=21138) on Windows.
+# on Windows. In the beginning of 2021 Microsoft took the original page, with
+# a.o. the download links, offline the HTML help workshop was already many years
+# in maintenance mode). You can download the HTML help workshop from the web
+# archives at Installation executable (see:
+# http://web.archive.org/web/20160201063255/http://download.microsoft.com/downlo
+# ad/0/A/9/0A939EF6-E31C-430F-A3DF-DFAE7960D564/htmlhelp.exe).
 #
 # The HTML Help Workshop contains a compiler that can convert all HTML output
 # generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
@@ -1501,16 +1522,28 @@ DISABLE_INDEX          = NO
 # to work a browser that supports JavaScript, DHTML, CSS and frames is required
 # (i.e. any modern browser). Windows users are probably better off using the
 # HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can
-# further fine-tune the look of the index. As an example, the default style
-# sheet generated by doxygen has an example that shows how to put an image at
-# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
-# the same information as the tab index, you could consider setting
-# DISABLE_INDEX to YES when enabling this option.
+# further fine tune the look of the index (see "Fine-tuning the output"). As an
+# example, the default style sheet generated by doxygen has an example that
+# shows how to put an image at the root of the tree instead of the PROJECT_NAME.
+# Since the tree basically has the same information as the tab index, you could
+# consider setting DISABLE_INDEX to YES when enabling this option.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 GENERATE_TREEVIEW      = NO
 
+# When both GENERATE_TREEVIEW and DISABLE_INDEX are set to YES, then the
+# FULL_SIDEBAR option determines if the side bar is limited to only the treeview
+# area (value NO) or if it should extend to the full height of the window (value
+# YES). Setting this to YES gives a layout similar to
+# https://docs.readthedocs.io with more room for contents, but less room for the
+# project logo, title, and description. If either GENERATE_TREEVIEW or
+# DISABLE_INDEX is set to NO, this option has no effect.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FULL_SIDEBAR           = NO
+
 # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
 # doxygen will group on one line in the generated HTML documentation.
 #
@@ -1535,6 +1568,13 @@ TREEVIEW_WIDTH         = 246
 
 EXT_LINKS_IN_WINDOW    = NO
 
+# If the OBFUSCATE_EMAILS tag is set to YES, doxygen will obfuscate email
+# addresses.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+OBFUSCATE_EMAILS       = YES
+
 # If the HTML_FORMULA_FORMAT option is set to svg, doxygen will use the pdf2svg
 # tool (see https://github.com/dawbarton/pdf2svg) or inkscape (see
 # https://inkscape.org) to generate formulas as SVG images instead of PNGs for
@@ -1583,11 +1623,29 @@ FORMULA_MACROFILE      =
 
 USE_MATHJAX            = NO
 
+# With MATHJAX_VERSION it is possible to specify the MathJax version to be used.
+# Note that the different versions of MathJax have different requirements with
+# regards to the different settings, so it is possible that also other MathJax
+# settings have to be changed when switching between the different MathJax
+# versions.
+# Possible values are: MathJax_2 and MathJax_3.
+# The default value is: MathJax_2.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_VERSION        = MathJax_2
+
 # When MathJax is enabled you can set the default output format to be used for
-# the MathJax output. See the MathJax site (see:
-# http://docs.mathjax.org/en/v2.7-latest/output.html) for more details.
+# the MathJax output. For more details about the output format see MathJax
+# version 2 (see:
+# http://docs.mathjax.org/en/v2.7-latest/output.html) and MathJax version 3
+# (see:
+# http://docs.mathjax.org/en/latest/web/components/output.html).
 # Possible values are: HTML-CSS (which is slower, but has the best
-# compatibility), NativeMML (i.e. MathML) and SVG.
+# compatibility. This is the name for Mathjax version 2, for MathJax version 3
+# this will be translated into chtml), NativeMML (i.e. MathML. Only supported
+# for NathJax 2. For MathJax version 3 chtml will be used instead.), chtml (This
+# is the name for Mathjax version 3, for MathJax version 2 this will be
+# translated into HTML-CSS) and SVG.
 # The default value is: HTML-CSS.
 # This tag requires that the tag USE_MATHJAX is set to YES.
 
@@ -1600,15 +1658,21 @@ MATHJAX_FORMAT         = HTML-CSS
 # MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
 # Content Delivery Network so you can quickly see the result without installing
 # MathJax. However, it is strongly recommended to install a local copy of
-# MathJax from https://www.mathjax.org before deployment.
-# The default value is: https://cdn.jsdelivr.net/npm/mathjax@2.
+# MathJax from https://www.mathjax.org before deployment. The default value is:
+# - in case of MathJax version 2: https://cdn.jsdelivr.net/npm/mathjax@2
+# - in case of MathJax version 3: https://cdn.jsdelivr.net/npm/mathjax@3
 # This tag requires that the tag USE_MATHJAX is set to YES.
 
 MATHJAX_RELPATH        = http://www.mathjax.org/mathjax
 
 # The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
 # extension names that should be enabled during MathJax rendering. For example
+# for MathJax version 2 (see
+# https://docs.mathjax.org/en/v2.7-latest/tex.html#tex-and-latex-extensions):
 # MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
+# For example for MathJax version 3 (see
+# http://docs.mathjax.org/en/latest/input/tex/extensions/index.html):
+# MATHJAX_EXTENSIONS = ams
 # This tag requires that the tag USE_MATHJAX is set to YES.
 
 MATHJAX_EXTENSIONS     =
@@ -1788,29 +1852,31 @@ PAPER_TYPE             = a4
 
 EXTRA_PACKAGES         =
 
-# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
-# generated LaTeX document. The header should contain everything until the first
-# chapter. If it is left blank doxygen will generate a standard header. See
-# section "Doxygen usage" for information on how to let doxygen write the
-# default header to a separate file.
+# The LATEX_HEADER tag can be used to specify a user-defined LaTeX header for
+# the generated LaTeX document. The header should contain everything until the
+# first chapter. If it is left blank doxygen will generate a standard header. It
+# is highly recommended to start with a default header using
+# doxygen -w latex new_header.tex new_footer.tex new_stylesheet.sty
+# and then modify the file new_header.tex. See also section "Doxygen usage" for
+# information on how to generate the default header that doxygen normally uses.
 #
-# Note: Only use a user-defined header if you know what you are doing! The
-# following commands have a special meaning inside the header: $title,
-# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
-# $projectbrief, $projectlogo. Doxygen will replace $title with the empty
-# string, for the replacement values of the other commands the user is referred
-# to HTML_HEADER.
+# Note: Only use a user-defined header if you know what you are doing!
+# Note: The header is subject to change so you typically have to regenerate the
+# default header when upgrading to a newer version of doxygen. The following
+# commands have a special meaning inside the header (and footer): For a
+# description of the possible markers and block names see the documentation.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_HEADER           =
 
-# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
-# generated LaTeX document. The footer should contain everything after the last
-# chapter. If it is left blank doxygen will generate a standard footer. See
+# The LATEX_FOOTER tag can be used to specify a user-defined LaTeX footer for
+# the generated LaTeX document. The footer should contain everything after the
+# last chapter. If it is left blank doxygen will generate a standard footer. See
 # LATEX_HEADER for more information on how to generate a default footer and what
-# special commands can be used inside the footer.
-#
-# Note: Only use a user-defined footer if you know what you are doing!
+# special commands can be used inside the footer. See also section "Doxygen
+# usage" for information on how to generate the default footer that doxygen
+# normally uses. Note: Only use a user-defined footer if you know what you are
+# doing!
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 LATEX_FOOTER           =
@@ -1855,8 +1921,7 @@ USE_PDFLATEX           = NO
 
 # If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
 # command to the generated LaTeX files. This will instruct LaTeX to keep running
-# if errors occur, instead of asking the user for help. This option is also used
-# when generating formulas in HTML.
+# if errors occur, instead of asking the user for help.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
@@ -1869,16 +1934,6 @@ LATEX_BATCHMODE        = NO
 
 LATEX_HIDE_INDICES     = NO
 
-# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
-# code with syntax highlighting in the LaTeX output.
-#
-# Note that which sources are shown also depends on other settings such as
-# SOURCE_BROWSER.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_SOURCE_CODE      = NO
-
 # The LATEX_BIB_STYLE tag can be used to specify the style to use for the
 # bibliography, e.g. plainnat, or ieeetr. See
 # https://en.wikipedia.org/wiki/BibTeX and \cite for more info.
@@ -1959,16 +2014,6 @@ RTF_STYLESHEET_FILE    =
 
 RTF_EXTENSIONS_FILE    =
 
-# If the RTF_SOURCE_CODE tag is set to YES then doxygen will include source code
-# with syntax highlighting in the RTF output.
-#
-# Note that which sources are shown also depends on other settings such as
-# SOURCE_BROWSER.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_SOURCE_CODE        = NO
-
 #---------------------------------------------------------------------------
 # Configuration options related to the man page output
 #---------------------------------------------------------------------------
@@ -2065,15 +2110,6 @@ GENERATE_DOCBOOK       = NO
 
 DOCBOOK_OUTPUT         = docbook
 
-# If the DOCBOOK_PROGRAMLISTING tag is set to YES, doxygen will include the
-# program listings (including syntax highlighting and cross-referencing
-# information) to the DOCBOOK output. Note that enabling this will significantly
-# increase the size of the DOCBOOK output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
-
-DOCBOOK_PROGRAMLISTING = NO
-
 #---------------------------------------------------------------------------
 # Configuration options for the AutoGen Definitions output
 #---------------------------------------------------------------------------
@@ -2254,15 +2290,6 @@ EXTERNAL_PAGES         = YES
 # Configuration options related to the dot tool
 #---------------------------------------------------------------------------
 
-# If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram
-# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
-# NO turns the diagrams off. Note that this option also works with HAVE_DOT
-# disabled, but it is recommended to install and use dot, since it yields more
-# powerful graphs.
-# The default value is: YES.
-
-CLASS_DIAGRAMS         = NO
-
 # You can include diagrams made with dia in doxygen documentation. Doxygen will
 # then run dia to produce the diagram and insert it in the documentation. The
 # DIA_PATH tag allows you to specify the directory where the dia binary resides.
@@ -2319,13 +2346,16 @@ DOT_FONTSIZE           = 10
 
 DOT_FONTPATH           =
 
-# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
-# each documented class showing the direct and indirect inheritance relations.
-# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
+# If the CLASS_GRAPH tag is set to YES (or GRAPH) then doxygen will generate a
+# graph for each documented class showing the direct and indirect inheritance
+# relations. In case HAVE_DOT is set as well dot will be used to draw the graph,
+# otherwise the built-in generator will be used. If the CLASS_GRAPH tag is set
+# to TEXT the direct and indirect inheritance relations will be shown as texts /
+# links.
+# Possible values are: NO, YES, TEXT and GRAPH.
 # The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
 
-CLASS_GRAPH            = YES
+CLASS_GRAPH            = TEXT
 
 # If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
 # graph for each documented class showing the direct and indirect implementation
@@ -2452,6 +2482,13 @@ GRAPHICAL_HIERARCHY    = YES
 
 DIRECTORY_GRAPH        = YES
 
+# The DIR_GRAPH_MAX_DEPTH tag can be used to limit the maximum number of levels
+# of child directories generated in directory dependency graphs by dot.
+# Minimum value: 1, maximum value: 25, default value: 1.
+# This tag requires that the tag DIRECTORY_GRAPH is set to YES.
+
+DIR_GRAPH_MAX_DEPTH    = 1
+
 # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
 # generated by dot. For an explanation of the image formats see the section
 # output formats in the documentation of the dot tool (Graphviz (see:
@@ -2505,10 +2542,10 @@ MSCFILE_DIRS           =
 DIAFILE_DIRS           =
 
 # When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
-# path where java can find the plantuml.jar file. If left blank, it is assumed
-# PlantUML is not used or called during a preprocessing step. Doxygen will
-# generate a warning when it encounters a \startuml command in this case and
-# will not generate output for the diagram.
+# path where java can find the plantuml.jar file or to the filename of jar file
+# to be used. If left blank, it is assumed PlantUML is not used or called during
+# a preprocessing step. Doxygen will generate a warning when it encounters a
+# \startuml command in this case and will not generate output for the diagram.
 
 PLANTUML_JAR_PATH      =
 
@@ -2570,6 +2607,8 @@ DOT_MULTI_TARGETS      = YES
 # If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
 # explaining the meaning of the various boxes and arrows in the dot generated
 # graphs.
+# Note: This tag requires that UML_LOOK isn't set, i.e. the doxygen internal
+# graphical representation for inheritance and collaboration diagrams is used.
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
 
@@ -2578,8 +2617,8 @@ GENERATE_LEGEND        = YES
 # If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate
 # files that are used to generate the various graphs.
 #
-# Note: This setting is not only used for dot files but also for msc and
-# plantuml temporary files.
+# Note: This setting is not only used for dot files but also for msc temporary
+# files.
 # The default value is: YES.
 
 DOT_CLEANUP            = YES

doc/python_api/examples/bpy.types.UIList.1.py

@@ -41,7 +41,7 @@ class MATERIAL_UL_matslots_example(bpy.types.UIList):
             else:
                 layout.label(text="", translate=False, icon_value=icon)
         # 'GRID' layout type should be as compact as possible (typically a single icon!).
-        elif self.layout_type in {'GRID'}:
+        elif self.layout_type == 'GRID':
             layout.alignment = 'CENTER'
             layout.label(text="", icon_value=icon)
 

doc/python_api/examples/bpy.types.UIList.2.py

@@ -73,7 +73,7 @@ class MESH_UL_vgroups_slow(bpy.types.UIList):
                 layout.prop(vgroup, "name", text="", emboss=False, icon_value=icon)
             icon = 'LOCKED' if vgroup.lock_weight else 'UNLOCKED'
             layout.prop(vgroup, "lock_weight", text="", icon=icon, emboss=False)
-        elif self.layout_type in {'GRID'}:
+        elif self.layout_type == 'GRID':
             layout.alignment = 'CENTER'
             if flt_flag & self.VGROUP_EMPTY:
                 layout.enabled = False

doc/python_api/sphinx_doc_gen.py

@@ -63,6 +63,7 @@ import os
 import sys
 import inspect
 import shutil
+import time
 import logging
 import warnings
 
@@ -399,6 +400,7 @@ MODULE_GROUPING = {
 
 # converting bytes to strings, due to T30154
 BLENDER_REVISION = str(bpy.app.build_hash, 'utf_8')
+BLENDER_REVISION_TIMESTAMP = bpy.app.build_commit_timestamp
 
 # '2.83.0 Beta' or '2.83.0' or '2.83.1'
 BLENDER_VERSION_STRING = bpy.app.version_string
@@ -407,9 +409,13 @@ BLENDER_VERSION_DOTS = "%d.%d" % (bpy.app.version[0], bpy.app.version[1])
 if BLENDER_REVISION != "Unknown":
     # SHA1 Git hash
     BLENDER_VERSION_HASH = BLENDER_REVISION
+    BLENDER_VERSION_HASH_HTML_LINK = "<a href=https://developer.blender.org/rB%s>%s</a>" % (BLENDER_VERSION_HASH, BLENDER_VERSION_HASH)
+    BLENDER_VERSION_DATE = time.strftime("%d/%m/%Y", time.localtime(BLENDER_REVISION_TIMESTAMP))
 else:
     # Fallback: Should not be used
     BLENDER_VERSION_HASH = "Hash Unknown"
+    BLENDER_VERSION_HASH_HTML_LINK = BLENDER_VERSION_HASH
+    BLENDER_VERSION_DATE = time.strftime("%Y-%m-%d")
 
 # '2_83'
 BLENDER_VERSION_PATH = "%d_%d" % (bpy.app.version[0], bpy.app.version[1])
@@ -1752,11 +1758,12 @@ except ModuleNotFoundError:
     fw("html_split_index = True\n")
     fw("html_static_path = ['static']\n")
     fw("templates_path = ['templates']\n")
-    fw("html_context = {'commit': '%s'}\n" % BLENDER_VERSION_HASH)
+    fw("html_context = {'commit': '%s - %s'}\n" % (BLENDER_VERSION_HASH_HTML_LINK, BLENDER_VERSION_DATE))
     fw("html_extra_path = ['static/favicon.ico', 'static/blender_logo.svg']\n")
     fw("html_favicon = 'static/favicon.ico'\n")
     fw("html_logo = 'static/blender_logo.svg'\n")
-    fw("html_last_updated_fmt = '%m/%d/%Y'\n\n")
+    # Disable default `last_updated` value, since this is the date of doc generation, not the one of the source commit.
+    fw("html_last_updated_fmt = None\n\n")
     fw("if html_theme == 'sphinx_rtd_theme':\n")
     fw("    html_css_files = ['css/version_switch.css']\n")
     fw("    html_js_files = ['js/version_switch.js']\n")

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/cycles/CMakeLists.txt

@@ -2,7 +2,7 @@
 # Copyright 2011-2022 Blender Foundation
 
 # Standalone or with Blender
-if(NOT WITH_BLENDER AND WITH_CYCLES_STANDALONE)
+if(NOT WITH_BLENDER)
   set(CYCLES_INSTALL_PATH ${CMAKE_INSTALL_PREFIX})
 else()
   set(WITH_CYCLES_BLENDER ON)
@@ -215,6 +215,15 @@ add_definitions(
   -DCCL_NAMESPACE_END=}
 )
 
+include_directories(
+  SYSTEM
+  ${BOOST_INCLUDE_DIR}
+  ${OPENIMAGEIO_INCLUDE_DIRS}
+  ${OPENEXR_INCLUDE_DIRS}
+  ${PUGIXML_INCLUDE_DIR}
+  ${TBB_INCLUDE_DIRS}
+)
+
 if(WITH_CYCLES_DEBUG)
   add_definitions(-DWITH_CYCLES_DEBUG)
 endif()
@@ -255,7 +264,6 @@ endif()
 
 if(WITH_CYCLES_EMBREE)
   add_definitions(-DWITH_EMBREE)
-  add_definitions(-DEMBREE_STATIC_LIB)
   include_directories(
     SYSTEM
     ${EMBREE_INCLUDE_DIRS}
@@ -280,7 +288,6 @@ endif()
 
 if(WITH_OPENIMAGEDENOISE)
   add_definitions(-DWITH_OPENIMAGEDENOISE)
-  add_definitions(-DOIDN_STATIC_LIB)
   include_directories(
     SYSTEM
     ${OPENIMAGEDENOISE_INCLUDE_DIRS}
@@ -308,17 +315,6 @@ if(NOT OPENIMAGEIO_PUGIXML_FOUND)
   add_definitions(-DWITH_SYSTEM_PUGIXML)
 endif()
 
-include_directories(
-  SYSTEM
-  ${BOOST_INCLUDE_DIR}
-  ${OPENIMAGEIO_INCLUDE_DIRS}
-  ${OPENIMAGEIO_INCLUDE_DIRS}/OpenImageIO
-  ${OPENEXR_INCLUDE_DIR}
-  ${OPENEXR_INCLUDE_DIRS}
-  ${PUGIXML_INCLUDE_DIR}
-  ${TBB_INCLUDE_DIRS}
-)
-
 if(CYCLES_STANDALONE_REPOSITORY)
   include_directories(../third_party/atomic)
 else()
@@ -335,6 +331,14 @@ 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_HYDRA_RENDER_DELEGATE AND (NOT WITH_BLENDER) AND (NOT WITH_CYCLES_STANDALONE))
+  set(CYCLES_INSTALL_PATH ${CYCLES_INSTALL_PATH}/hdCycles/resources)
+endif()
+
 if(WITH_CYCLES_CUDA_BINARIES AND (NOT WITH_CYCLES_CUBIN_COMPILER))
   if(MSVC)
     set(MAX_MSVC 1800)
@@ -395,6 +399,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/engine.py

@@ -228,6 +228,10 @@ def list_render_passes(scene, srl):
         else:
             yield (aov.name, "RGB", 'COLOR')
 
+    # Light groups.
+    for lightgroup in srl.lightgroups:
+        yield ("Combined_%s" % lightgroup.name, "RGB", 'COLOR')
+
 
 def register_passes(engine, scene, view_layer):
     for name, channelids, channeltype in list_render_passes(scene, view_layer):

intern/cycles/blender/addon/properties.py

@@ -1012,6 +1012,12 @@ class CyclesLightSettings(bpy.types.PropertyGroup):
         "note that this will make the light invisible",
         default=False,
     )
+    is_caustics_light: BoolProperty(
+        name="Shadow Caustics",
+        description="Generate approximate caustics in shadows of refractive surfaces. "
+        "Lights, caster and receiver objects must have shadow caustics options set to enable this",
+        default=False,
+    )
 
     @classmethod
     def register(cls):
@@ -1028,6 +1034,12 @@ class CyclesLightSettings(bpy.types.PropertyGroup):
 
 class CyclesWorldSettings(bpy.types.PropertyGroup):
 
+    is_caustics_light: BoolProperty(
+        name="Shadow Caustics",
+        description="Generate approximate caustics in shadows of refractive surfaces. "
+        "Lights, caster and receiver objects must have shadow caustics options set to enable this",
+        default=False,
+    )
     sampling_method: EnumProperty(
         name="Sampling Method",
         description="How to sample the background light",
@@ -1226,6 +1238,21 @@ class CyclesObjectSettings(bpy.types.PropertyGroup):
         subtype='DISTANCE',
     )
 
+    is_caustics_caster: BoolProperty(
+        name="Cast Shadow Caustics",
+        description="With refractive materials, generate approximate caustics in shadows of this object. "
+        "Up to 10 bounces inside this object are taken into account. Lights, caster and receiver objects "
+        "must have shadow caustics options set to enable this",
+        default=False,
+    )
+
+    is_caustics_receiver: BoolProperty(
+        name="Receive Shadow Caustics",
+        description="Receive approximate caustics from refractive materials in shadows on this object. "
+        "Lights, caster and receiver objects must have shadow caustics options set to enable this",
+        default=False,
+    )
+
     @classmethod
     def register(cls):
         bpy.types.Object.cycles = PointerProperty(
@@ -1480,7 +1507,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

@@ -12,7 +12,7 @@ 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
+from bl_ui.properties_view_layer import ViewLayerCryptomattePanel, ViewLayerAOVPanel, ViewLayerLightgroupsPanel
 
 class CyclesPresetPanel(PresetPanel, Panel):
     COMPAT_ENGINES = {'CYCLES'}
@@ -883,6 +883,12 @@ class CYCLES_RENDER_PT_passes_aov(CyclesButtonsPanel, ViewLayerAOVPanel):
     bl_parent_id = "CYCLES_RENDER_PT_passes"
 
 
+class CYCLES_RENDER_PT_passes_lightgroups(CyclesButtonsPanel, ViewLayerLightgroupsPanel):
+    bl_label = "Light Groups"
+    bl_context = "view_layer"
+    bl_parent_id = "CYCLES_RENDER_PT_passes"
+
+
 class CYCLES_PT_post_processing(CyclesButtonsPanel, Panel):
     bl_label = "Post Processing"
     bl_options = {'DEFAULT_CLOSED'}
@@ -1093,6 +1099,10 @@ class CYCLES_OBJECT_PT_shading_shadow_terminator(CyclesButtonsPanel, Panel):
     bl_parent_id = "CYCLES_OBJECT_PT_shading"
     bl_context = "object"
 
+    @classmethod
+    def poll(cls, context):
+        return context.object.type != 'LIGHT'
+
     def draw(self, context):
         layout = self.layout
         layout.use_property_split = True
@@ -1110,6 +1120,10 @@ class CYCLES_OBJECT_PT_shading_gi_approximation(CyclesButtonsPanel, Panel):
     bl_parent_id = "CYCLES_OBJECT_PT_shading"
     bl_context = "object"
 
+    @classmethod
+    def poll(cls, context):
+        return context.object.type != 'LIGHT'
+
     def draw(self, context):
         layout = self.layout
         layout.use_property_split = True
@@ -1125,6 +1139,45 @@ class CYCLES_OBJECT_PT_shading_gi_approximation(CyclesButtonsPanel, Panel):
         col.prop(cob, "ao_distance")
 
 
+class CYCLES_OBJECT_PT_shading_caustics(CyclesButtonsPanel, Panel):
+    bl_label = "Caustics"
+    bl_parent_id = "CYCLES_OBJECT_PT_shading"
+    bl_context = "object"
+
+    @classmethod
+    def poll(cls, context):
+        return CyclesButtonsPanel.poll(context) and not use_metal(context) and context.object.type != 'LIGHT'
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+        layout.use_property_decorate = False
+
+        col = layout.column()
+
+        ob = context.object
+        cob = ob.cycles
+        col.prop(cob, "is_caustics_caster")
+        col.prop(cob, "is_caustics_receiver")
+
+
+class CYCLES_OBJECT_PT_lightgroup(CyclesButtonsPanel, Panel):
+    bl_label = "Light Group"
+    bl_parent_id = "CYCLES_OBJECT_PT_shading"
+    bl_context = "object"
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+
+        ob = context.object
+
+        view_layer = context.view_layer
+
+        col = layout.column(align=True)
+        col.prop_search(ob, "lightgroup", view_layer, "lightgroups", text="Light Group")
+
+
 class CYCLES_OBJECT_PT_visibility(CyclesButtonsPanel, Panel):
     bl_label = "Visibility"
     bl_context = "object"
@@ -1300,6 +1353,8 @@ class CYCLES_LIGHT_PT_light(CyclesButtonsPanel, Panel):
         sub.active = not (light.type == 'AREA' and clamp.is_portal)
         sub.prop(clamp, "cast_shadow")
         sub.prop(clamp, "use_multiple_importance_sampling", text="Multiple Importance")
+        if not use_metal(context):
+            sub.prop(clamp, "is_caustics_light", text="Shadow Caustics")
 
         if light.type == 'AREA':
             col.prop(clamp, "is_portal", text="Portal")
@@ -1375,10 +1430,14 @@ class CYCLES_WORLD_PT_surface(CyclesButtonsPanel, Panel):
         layout.use_property_split = True
 
         world = context.world
+        view_layer = context.view_layer
 
         if not panel_node_draw(layout, world, 'OUTPUT_WORLD', 'Surface'):
             layout.prop(world, "color")
 
+        col = layout.column(align=True)
+        col.prop_search(world, "lightgroup", view_layer, "lightgroups", text="Light Group")
+
 
 class CYCLES_WORLD_PT_volume(CyclesButtonsPanel, Panel):
     bl_label = "Volume"
@@ -1496,6 +1555,8 @@ class CYCLES_WORLD_PT_settings_surface(CyclesButtonsPanel, Panel):
         subsub.active = cworld.sampling_method == 'MANUAL'
         subsub.prop(cworld, "sample_map_resolution")
         sub.prop(cworld, "max_bounces")
+        sub.prop(cworld, "is_caustics_light", text="Shadow Caustics")
+
 
 
 class CYCLES_WORLD_PT_settings_volume(CyclesButtonsPanel, Panel):
@@ -2183,6 +2244,7 @@ classes = (
     CYCLES_RENDER_PT_passes_light,
     CYCLES_RENDER_PT_passes_crypto,
     CYCLES_RENDER_PT_passes_aov,
+    CYCLES_RENDER_PT_passes_lightgroups,
     CYCLES_RENDER_PT_filter,
     CYCLES_RENDER_PT_override,
     CYCLES_PT_post_processing,
@@ -2193,6 +2255,8 @@ classes = (
     CYCLES_OBJECT_PT_shading,
     CYCLES_OBJECT_PT_shading_shadow_terminator,
     CYCLES_OBJECT_PT_shading_gi_approximation,
+    CYCLES_OBJECT_PT_shading_caustics,
+    CYCLES_OBJECT_PT_lightgroup,
     CYCLES_OBJECT_PT_visibility,
     CYCLES_OBJECT_PT_visibility_ray_visibility,
     CYCLES_OBJECT_PT_visibility_culling,

intern/cycles/blender/light.cpp

@@ -114,6 +114,9 @@ void BlenderSync::sync_light(BL::Object &b_parent,
   light->set_cast_shadow(get_boolean(clight, "cast_shadow"));
   light->set_use_mis(get_boolean(clight, "use_multiple_importance_sampling"));
 
+  /* caustics light */
+  light->set_use_caustics(get_boolean(clight, "is_caustics_light"));
+
   light->set_max_bounces(get_int(clight, "max_bounces"));
 
   if (b_ob_info.real_object != b_ob_info.iter_object) {
@@ -140,6 +143,9 @@ void BlenderSync::sync_light(BL::Object &b_parent,
   light->set_use_scatter((visibility & PATH_RAY_VOLUME_SCATTER) != 0);
   light->set_is_shadow_catcher(b_ob_info.real_object.is_shadow_catcher());
 
+  /* lightgroup */
+  light->set_lightgroup(ustring(b_ob_info.real_object.lightgroup()));
+
   /* tag */
   light->tag_update(scene);
 }
@@ -176,6 +182,9 @@ void BlenderSync::sync_background_light(BL::SpaceView3D &b_v3d, bool use_portal)
         /* force enable light again when world is resynced */
         light->set_is_enabled(true);
 
+        /* caustic light */
+        light->set_use_caustics(get_boolean(cworld, "is_caustics_light"));
+
         light->tag_update(scene);
         light_map.set_recalc(b_world);
       }

intern/cycles/blender/object.cpp

@@ -66,9 +66,8 @@ bool BlenderSync::object_is_geometry(BObjectInfo &b_ob_info)
   }
 
   /* Other object types that are not meshes but evaluate to meshes are presented to render engines
-   * as separate instance objects. Metaballs and surface objects have not been affected by that
-   * change yet. */
-  if (type == BL::Object::type_SURFACE || type == BL::Object::type_META) {
+   * as separate instance objects. Metaballs have not been affected by that change yet. */
+  if (type == BL::Object::type_META) {
     return true;
   }
 
@@ -298,6 +297,12 @@ Object *BlenderSync::sync_object(BL::Depsgraph &b_depsgraph,
   }
   object->set_ao_distance(ao_distance);
 
+  bool is_caustics_caster = get_boolean(cobject, "is_caustics_caster");
+  object->set_is_caustics_caster(is_caustics_caster);
+
+  bool is_caustics_receiver = get_boolean(cobject, "is_caustics_receiver");
+  object->set_is_caustics_receiver(is_caustics_receiver);
+
   /* sync the asset name for Cryptomatte */
   BL::Object parent = b_ob.parent();
   ustring parent_name;
@@ -337,6 +342,9 @@ Object *BlenderSync::sync_object(BL::Depsgraph &b_depsgraph,
       object->set_random_id(hash_uint2(hash_string(object->name.c_str()), 0));
     }
 
+    /* lightgroup */
+    object->set_lightgroup(ustring(b_ob.lightgroup()));
+
     object->tag_update(scene);
   }
 
@@ -422,7 +430,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)
@@ -621,10 +629,8 @@ void BlenderSync::sync_objects(BL::Depsgraph &b_depsgraph,
       bool has_subdivision_modifier = false;
       BL::MeshSequenceCacheModifier b_mesh_cache(PointerRNA_NULL);
 
-      /* Experimental as Blender does not have good support for procedurals at the moment, also
-       * only available in preview renders since currently do not have a good cache policy, the
-       * data being loaded at once for all the frames. */
-      if (experimental && b_v3d) {
+      /* Experimental as Blender does not have good support for procedurals at the moment. */
+      if (experimental) {
         b_mesh_cache = object_mesh_cache_find(b_ob, &has_subdivision_modifier);
         use_procedural = b_mesh_cache && b_mesh_cache.cache_file().use_render_procedural();
       }

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)) {
@@ -1529,6 +1532,8 @@ void BlenderSync::sync_world(BL::Depsgraph &b_depsgraph, BL::SpaceView3D &b_v3d,
   background->set_use_shader(view_layer.use_background_shader ||
                              viewport_parameters.use_custom_shader());
 
+  background->set_lightgroup(ustring(b_world ? b_world.lightgroup() : ""));
+
   background->tag_update(scene);
 }
 

intern/cycles/blender/sync.cpp

@@ -745,6 +745,20 @@ void BlenderSync::sync_render_passes(BL::RenderLayer &b_rlay, BL::ViewLayer &b_v
     }
   }
 
+  /* Light Group passes. */
+  BL::ViewLayer::lightgroups_iterator b_lightgroup_iter;
+  for (b_view_layer.lightgroups.begin(b_lightgroup_iter);
+       b_lightgroup_iter != b_view_layer.lightgroups.end();
+       ++b_lightgroup_iter) {
+    BL::Lightgroup b_lightgroup(*b_lightgroup_iter);
+
+    string name = string_printf("Combined_%s", b_lightgroup.name().c_str());
+
+    b_engine.add_pass(name.c_str(), 3, "RGB", b_view_layer.name().c_str());
+    Pass *pass = pass_add(scene, PASS_COMBINED, name.c_str(), PassMode::NOISY);
+    pass->set_lightgroup(ustring(b_lightgroup.name()));
+  }
+
   scene->film->set_pass_alpha_threshold(b_view_layer.pass_alpha_threshold());
 }
 

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/external_libs.cmake

@@ -69,6 +69,7 @@ if(CYCLES_STANDALONE_REPOSITORY)
     _set_default(OPENVDB_ROOT_DIR "${_cycles_lib_dir}/openvdb")
     _set_default(OSL_ROOT_DIR "${_cycles_lib_dir}/osl")
     _set_default(PNG_ROOT "${_cycles_lib_dir}/png")
+    _set_default(PUGIXML_ROOT_DIR "${_cycles_lib_dir}/pugixml")
     _set_default(TBB_ROOT_DIR "${_cycles_lib_dir}/tbb")
     _set_default(TIFF_ROOT "${_cycles_lib_dir}/tiff")
     _set_default(ZLIB_ROOT "${_cycles_lib_dir}/zlib")
@@ -80,6 +81,23 @@ if(CYCLES_STANDALONE_REPOSITORY)
   endif()
 endif()
 
+###########################################################################
+# USD
+###########################################################################
+
+if(CYCLES_STANDALONE_REPOSITORY AND WITH_CYCLES_HYDRA_RENDER_DELEGATE)
+  set(WITH_USD ON)
+endif()
+if(WITH_CYCLES_HYDRA_RENDER_DELEGATE)
+  find_package(pxr CONFIG REQUIRED PATHS ${PXR_ROOT} ${USD_ROOT} NO_DEFAULT_PATH)
+  if(pxr_FOUND)
+    set(PXR_LIBRARY_DIR ${PXR_CMAKE_DIR}/lib)
+    set(USD_INCLUDE_DIRS ${PXR_INCLUDE_DIRS})
+  else()
+    set(WITH_USD OFF)
+  endif()
+endif()
+
 ###########################################################################
 # Zlib
 ###########################################################################
@@ -126,31 +144,40 @@ if(CYCLES_STANDALONE_REPOSITORY)
       -DOIIO_STATIC_DEFINE
     )
 
+    set(OPENIMAGEIO_INCLUDE_DIR ${OPENIMAGEIO_ROOT_DIR}/include) 
+    set(OPENIMAGEIO_INCLUDE_DIRS ${OPENIMAGEIO_INCLUDE_DIR} ${OPENIMAGEIO_INCLUDE_DIR}/OpenImageIO) 
     # Special exceptions for libraries which needs explicit debug version
-    set(OPENIMAGEIO_LIBRARY
+    set(OPENIMAGEIO_LIBRARIES
       optimized ${OPENIMAGEIO_ROOT_DIR}/lib/OpenImageIO.lib
       optimized ${OPENIMAGEIO_ROOT_DIR}/lib/OpenImageIO_Util.lib
       debug ${OPENIMAGEIO_ROOT_DIR}/lib/OpenImageIO_d.lib
       debug ${OPENIMAGEIO_ROOT_DIR}/lib/OpenImageIO_Util_d.lib
     )
-  endif()
 
-  find_package(OpenImageIO REQUIRED)
-  if(OPENIMAGEIO_PUGIXML_FOUND)
-    set(PUGIXML_INCLUDE_DIR "${OPENIMAGEIO_INCLUDE_DIR/OpenImageIO}")
-    set(PUGIXML_LIBRARIES "")
+    set(PUGIXML_INCLUDE_DIR ${PUGIXML_ROOT_DIR}/include)
+    set(PUGIXML_LIBRARIES
+      optimized ${PUGIXML_ROOT_DIR}/lib/pugixml.lib
+      debug ${PUGIXML_ROOT_DIR}/lib/pugixml_d.lib
+    )
   else()
-    find_package(PugiXML REQUIRED)
+    find_package(OpenImageIO REQUIRED)
+    if(OPENIMAGEIO_PUGIXML_FOUND)
+      set(PUGIXML_INCLUDE_DIR "${OPENIMAGEIO_INCLUDE_DIR}/OpenImageIO")
+      set(PUGIXML_LIBRARIES "")
+    else()
+      find_package(PugiXML REQUIRED)
+    endif()
   endif()
 
   # Dependencies
   if(MSVC AND EXISTS ${_cycles_lib_dir})
     set(OPENJPEG_INCLUDE_DIR ${OPENJPEG}/include/openjpeg-2.3)
-    set(OPENJPEG_LIBRARY ${_cycles_lib_dir}/openjpeg/lib/openjp2${CMAKE_STATIC_LIBRARY_SUFFIX})
+    set(OPENJPEG_LIBRARIES ${_cycles_lib_dir}/openjpeg/lib/openjp2${CMAKE_STATIC_LIBRARY_SUFFIX})
+  else()
+    find_package(OpenJPEG REQUIRED)
   endif()
 
   find_package(JPEG REQUIRED)
-  find_package(OpenJPEG REQUIRED)
   find_package(TIFF REQUIRED)
   find_package(PNG REQUIRED)
 endif()
@@ -161,76 +188,70 @@ endif()
 
 if(CYCLES_STANDALONE_REPOSITORY)
   if(MSVC AND EXISTS ${_cycles_lib_dir})
-    set(OPENEXR_IEX_LIBRARY
+    set(OPENEXR_INCLUDE_DIR ${OPENEXR_ROOT_DIR}/include)
+    set(OPENEXR_INCLUDE_DIRS ${OPENEXR_INCLUDE_DIR} ${OPENEXR_ROOT_DIR}/include/OpenEXR)
+    set(OPENEXR_LIBRARIES
       optimized ${OPENEXR_ROOT_DIR}/lib/Iex_s.lib
-      debug ${OPENEXR_ROOT_DIR}/lib/Iex_s_d.lib
-    )
-    set(OPENEXR_HALF_LIBRARY
       optimized ${OPENEXR_ROOT_DIR}/lib/Half_s.lib
-      debug ${OPENEXR_ROOT_DIR}/lib/Half_s_d.lib
-    )
-    set(OPENEXR_ILMIMF_LIBRARY
       optimized ${OPENEXR_ROOT_DIR}/lib/IlmImf_s.lib
-      debug ${OPENEXR_ROOT_DIR}/lib/IlmImf_s_d.lib
-    )
-    set(OPENEXR_IMATH_LIBRARY
       optimized ${OPENEXR_ROOT_DIR}/lib/Imath_s.lib
-      debug ${OPENEXR_ROOT_DIR}/lib/Imath_s_d.lib
-    )
-    set(OPENEXR_ILMTHREAD_LIBRARY
       optimized ${OPENEXR_ROOT_DIR}/lib/IlmThread_s.lib
+      debug ${OPENEXR_ROOT_DIR}/lib/Iex_s_d.lib
+      debug ${OPENEXR_ROOT_DIR}/lib/Half_s_d.lib
+      debug ${OPENEXR_ROOT_DIR}/lib/IlmImf_s_d.lib
+      debug ${OPENEXR_ROOT_DIR}/lib/Imath_s_d.lib
       debug ${OPENEXR_ROOT_DIR}/lib/IlmThread_s_d.lib
     )
+  else()
+    find_package(OpenEXR REQUIRED)
   endif()
-
-  find_package(OpenEXR REQUIRED)
 endif()
 
 ###########################################################################
 # OpenShadingLanguage & LLVM
 ###########################################################################
 
-if(WITH_CYCLES_OSL)
-  if(CYCLES_STANDALONE_REPOSITORY)
-    if(EXISTS ${_cycles_lib_dir})
-      set(LLVM_STATIC ON)
-    endif()
+if(CYCLES_STANDALONE_REPOSITORY AND WITH_CYCLES_OSL)
+  if(EXISTS ${_cycles_lib_dir})
+    set(LLVM_STATIC ON)
+  endif()
 
+  if(MSVC AND EXISTS ${_cycles_lib_dir})
+    # TODO(sergey): On Windows llvm-config doesn't give proper results for the
+    # library names, use hardcoded libraries for now.
+    file(GLOB _llvm_libs_release ${LLVM_ROOT_DIR}/lib/*.lib)
+    file(GLOB _llvm_libs_debug ${LLVM_ROOT_DIR}/debug/lib/*.lib)
+    set(_llvm_libs)
+    foreach(_llvm_lib_path ${_llvm_libs_release})
+      get_filename_component(_llvm_lib_name ${_llvm_lib_path} ABSOLUTE)
+      list(APPEND _llvm_libs optimized ${_llvm_lib_name})
+    endforeach()
+    foreach(_llvm_lib_path ${_llvm_libs_debug})
+      get_filename_component(_llvm_lib_name ${_llvm_lib_path} ABSOLUTE)
+      list(APPEND _llvm_libs debug ${_llvm_lib_name})
+    endforeach()
+    set(LLVM_LIBRARY ${_llvm_libs})
+    unset(_llvm_lib_name)
+    unset(_llvm_lib_path)
+    unset(_llvm_libs)
+    unset(_llvm_libs_debug)
+    unset(_llvm_libs_release)
+
+    set(OSL_INCLUDE_DIR ${OSL_ROOT_DIR}/include)
+    set(OSL_LIBRARIES
+      optimized ${OSL_ROOT_DIR}/lib/oslcomp.lib
+      optimized ${OSL_ROOT_DIR}/lib/oslexec.lib
+      optimized ${OSL_ROOT_DIR}/lib/oslquery.lib
+      debug ${OSL_ROOT_DIR}/lib/oslcomp_d.lib
+      debug ${OSL_ROOT_DIR}/lib/oslexec_d.lib
+      debug ${OSL_ROOT_DIR}/lib/oslquery_d.lib
+      ${PUGIXML_LIBRARIES}
+    )
+
+    find_program(OSL_COMPILER NAMES oslc PATHS ${OSL_ROOT_DIR}/bin)
+  else()
     find_package(OSL REQUIRED)
     find_package(LLVM REQUIRED)
-
-    if(MSVC AND EXISTS ${_cycles_lib_dir})
-      # TODO(sergey): On Windows llvm-config doesn't give proper results for the
-      # library names, use hardcoded libraries for now.
-      file(GLOB _llvm_libs_release ${LLVM_ROOT_DIR}/lib/*.lib)
-      file(GLOB _llvm_libs_debug ${LLVM_ROOT_DIR}/debug/lib/*.lib)
-      set(_llvm_libs)
-      foreach(_llvm_lib_path ${_llvm_libs_release})
-        get_filename_component(_llvm_lib_name ${_llvm_lib_path} ABSOLUTE)
-        list(APPEND _llvm_libs optimized ${_llvm_lib_name})
-      endforeach()
-      foreach(_llvm_lib_path ${_llvm_libs_debug})
-        get_filename_component(_llvm_lib_name ${_llvm_lib_path} ABSOLUTE)
-        list(APPEND _llvm_libs debug ${_llvm_lib_name})
-      endforeach()
-      set(LLVM_LIBRARY ${_llvm_libs})
-      unset(_llvm_lib_name)
-      unset(_llvm_lib_path)
-      unset(_llvm_libs)
-      unset(_llvm_libs_debug)
-      unset(_llvm_libs_release)
-
-      set(OSL_LIBRARIES
-        optimized ${OSL_ROOT_DIR}/lib/oslcomp.lib
-        optimized ${OSL_ROOT_DIR}/lib/oslexec.lib
-        optimized ${OSL_ROOT_DIR}/lib/oslquery.lib
-        optimized ${OSL_ROOT_DIR}/lib/pugixml.lib
-        debug ${OSL_ROOT_DIR}/lib/oslcomp_d.lib
-        debug ${OSL_ROOT_DIR}/lib/oslexec_d.lib
-        debug ${OSL_ROOT_DIR}/lib/oslquery_d.lib
-        debug ${OSL_ROOT_DIR}/lib/pugixml_d.lib
-      )
-    endif()
   endif()
 endif()
 
@@ -238,22 +259,23 @@ endif()
 # OpenColorIO
 ###########################################################################
 
-if(WITH_CYCLES_OPENCOLORIO)
-  if(CYCLES_STANDALONE_REPOSITORY)
-    find_package(OpenColorIO REQUIRED)
-    set(WITH_OPENCOLORIO ON)
+if(CYCLES_STANDALONE_REPOSITORY AND WITH_CYCLES_OPENCOLORIO)
+  set(WITH_OPENCOLORIO ON)
 
-    if(MSVC AND EXISTS ${_cycles_lib_dir})
-      set(OPENCOLORIO_LIBPATH ${_cycles_lib_dir}/opencolorio/lib)
-      set(OPENCOLORIO_LIBRARIES
-        optimized ${OPENCOLORIO_LIBPATH}/OpenColorIO.lib
-        optimized ${OPENCOLORIO_LIBPATH}/tinyxml.lib
-        optimized ${OPENCOLORIO_LIBPATH}/libyaml-cpp.lib
-        debug ${OPENCOLORIO_LIBPATH}/OpencolorIO_d.lib
-        debug ${OPENCOLORIO_LIBPATH}/tinyxml_d.lib
-        debug ${OPENCOLORIO_LIBPATH}/libyaml-cpp_d.lib
-      )
-    endif()
+  if(MSVC AND EXISTS ${_cycles_lib_dir})
+    set(OPENCOLORIO_INCLUDE_DIRS ${OPENCOLORIO_ROOT_DIR}/include)
+    set(OPENCOLORIO_LIBRARIES
+      optimized ${OPENCOLORIO_ROOT_DIR}/lib/OpenColorIO.lib
+      optimized ${OPENCOLORIO_ROOT_DIR}/lib/libyaml-cpp.lib
+      optimized ${OPENCOLORIO_ROOT_DIR}/lib/libexpatMD.lib
+      optimized ${OPENCOLORIO_ROOT_DIR}/lib/pystring.lib
+      debug ${OPENCOLORIO_ROOT_DIR}/lib/OpencolorIO_d.lib
+      debug ${OPENCOLORIO_ROOT_DIR}/lib/libyaml-cpp_d.lib
+      debug ${OPENCOLORIO_ROOT_DIR}/lib/libexpatdMD.lib
+      debug ${OPENCOLORIO_ROOT_DIR}/lib/pystring_d.lib
+    )
+  else()
+    find_package(OpenColorIO REQUIRED)
   endif()
 endif()
 
@@ -274,22 +296,59 @@ if(CYCLES_STANDALONE_REPOSITORY)
     endif()
   endif()
 
-  set(__boost_packages filesystem regex system thread date_time)
-  if(WITH_CYCLES_OSL)
-    list(APPEND __boost_packages wave)
+  if(MSVC AND EXISTS ${_cycles_lib_dir})
+    set(BOOST_INCLUDE_DIR ${BOOST_ROOT}/include)
+    set(BOOST_VERSION_HEADER ${BOOST_INCLUDE_DIR}/boost/version.hpp)
+    if(EXISTS ${BOOST_VERSION_HEADER})
+      file(STRINGS "${BOOST_VERSION_HEADER}" BOOST_LIB_VERSION REGEX "#define BOOST_LIB_VERSION ")
+      if(BOOST_LIB_VERSION MATCHES "#define BOOST_LIB_VERSION \"([0-9_]+)\"")
+        set(BOOST_VERSION "${CMAKE_MATCH_1}")
+      endif()
+    endif()
+    if(NOT BOOST_VERSION)
+      message(FATAL_ERROR "Unable to determine Boost version")
+    endif()
+    set(BOOST_POSTFIX "vc141-mt-x64-${BOOST_VERSION}.lib")
+    set(BOOST_DEBUG_POSTFIX "vc141-mt-gd-x64-${BOOST_VERSION}.lib")
+    set(BOOST_LIBRARIES
+      optimized ${BOOST_ROOT}/lib/libboost_date_time-${BOOST_POSTFIX}
+      optimized ${BOOST_ROOT}/lib/libboost_filesystem-${BOOST_POSTFIX}
+      optimized ${BOOST_ROOT}/lib/libboost_regex-${BOOST_POSTFIX}
+      optimized ${BOOST_ROOT}/lib/libboost_system-${BOOST_POSTFIX}
+      optimized ${BOOST_ROOT}/lib/libboost_thread-${BOOST_POSTFIX}
+      optimized ${BOOST_ROOT}/lib/libboost_chrono-${BOOST_POSTFIX}
+      debug ${BOOST_ROOT}/lib/libboost_date_time-${BOOST_DEBUG_POSTFIX}
+      debug ${BOOST_ROOT}/lib/libboost_filesystem-${BOOST_DEBUG_POSTFIX}
+      debug ${BOOST_ROOT}/lib/libboost_regex-${BOOST_DEBUG_POSTFIX}
+      debug ${BOOST_ROOT}/lib/libboost_system-${BOOST_DEBUG_POSTFIX}
+      debug ${BOOST_ROOT}/lib/libboost_thread-${BOOST_DEBUG_POSTFIX}
+      debug ${BOOST_ROOT}/lib/libboost_chrono-${BOOST_DEBUG_POSTFIX}
+    )
+    if(WITH_CYCLES_OSL)
+      set(BOOST_LIBRARIES ${BOOST_LIBRARIES}
+        optimized ${BOOST_ROOT}/lib/libboost_wave-${BOOST_POSTFIX}
+        debug ${BOOST_ROOT}/lib/libboost_wave-${BOOST_DEBUG_POSTFIX})
+    endif()
+  else()
+    set(__boost_packages filesystem regex system thread date_time)
+    if(WITH_CYCLES_OSL)
+      list(APPEND __boost_packages wave)
+    endif()
+    find_package(Boost 1.48 COMPONENTS ${__boost_packages} REQUIRED)
+    if(NOT Boost_FOUND)
+      # Try to find non-multithreaded if -mt not found, this flag
+      # doesn't matter for us, it has nothing to do with thread
+      # safety, but keep it to not disturb build setups.
+      set(Boost_USE_MULTITHREADED OFF)
+      find_package(Boost 1.48 COMPONENTS ${__boost_packages})
+    endif()
+    unset(__boost_packages)
+
+    set(BOOST_INCLUDE_DIR ${Boost_INCLUDE_DIRS})
+    set(BOOST_LIBRARIES ${Boost_LIBRARIES})
+    set(BOOST_LIBPATH ${Boost_LIBRARY_DIRS})
   endif()
-  find_package(Boost 1.48 COMPONENTS ${__boost_packages} REQUIRED)
-  if(NOT Boost_FOUND)
-    # Try to find non-multithreaded if -mt not found, this flag
-    # doesn't matter for us, it has nothing to do with thread
-    # safety, but keep it to not disturb build setups.
-    set(Boost_USE_MULTITHREADED OFF)
-    find_package(Boost 1.48 COMPONENTS ${__boost_packages})
-  endif()
-  unset(__boost_packages)
-  set(BOOST_INCLUDE_DIR ${Boost_INCLUDE_DIRS})
-  set(BOOST_LIBRARIES ${Boost_LIBRARIES})
-  set(BOOST_LIBPATH ${Boost_LIBRARY_DIRS})
+
   set(BOOST_DEFINITIONS "-DBOOST_ALL_NO_LIB")
 endif()
 
@@ -297,47 +356,30 @@ endif()
 # Embree
 ###########################################################################
 
-if(WITH_CYCLES_EMBREE)
-  if(CYCLES_STANDALONE_REPOSITORY)
-    if(MSVC AND EXISTS ${_cycles_lib_dir})
-      set(EMBREE_TASKING_LIBRARY
-        optimized ${EMBREE_ROOT_DIR}/lib/tasking.lib
-        debug  ${EMBREE_ROOT_DIR}/lib/tasking_d.lib
-      )
-      set(EMBREE_EMBREE3_LIBRARY
-        optimized ${EMBREE_ROOT_DIR}/lib/embree3.lib
-        debug  ${EMBREE_ROOT_DIR}/lib/embree3_d.lib
-      )
-      set(EMBREE_EMBREE_AVX_LIBRARY
-        optimized ${EMBREE_ROOT_DIR}/lib/embree_avx.lib
-        debug  ${EMBREE_ROOT_DIR}/lib/embree_avx_d.lib
-      )
-      set(EMBREE_EMBREE_AVX2_LIBRARY
-        optimized ${EMBREE_ROOT_DIR}/lib/embree_avx2.lib
-        debug  ${EMBREE_ROOT_DIR}/lib/embree_avx2_d.lib
-      )
-      set(EMBREE_EMBREE_SSE42_LIBRARY
-        optimized ${EMBREE_ROOT_DIR}/lib/embree_sse42.lib
-        debug  ${EMBREE_ROOT_DIR}/lib/embree_sse42_d.lib
-      )
-      set(EMBREE_LEXERS_LIBRARY
-        optimized ${EMBREE_ROOT_DIR}/lib/lexers.lib
-        debug  ${EMBREE_ROOT_DIR}/lib/lexers_d.lib
-      )
-      set(EMBREE_MATH_LIBRARY
-        optimized ${EMBREE_ROOT_DIR}/lib/math.lib
-        debug  ${EMBREE_ROOT_DIR}/lib/math_d.lib
-      )
-      set(EMBREE_SIMD_LIBRARY
-        optimized ${EMBREE_ROOT_DIR}/lib/simd.lib
-        debug  ${EMBREE_ROOT_DIR}/lib/simd_d.lib
-      )
-      set(EMBREE_SYS_LIBRARY
-        optimized ${EMBREE_ROOT_DIR}/lib/sys.lib
-        debug  ${EMBREE_ROOT_DIR}/lib/sys_d.lib
-      )
-    endif()
-
+if(CYCLES_STANDALONE_REPOSITORY AND WITH_CYCLES_EMBREE)
+  if(MSVC AND EXISTS ${_cycles_lib_dir})
+    set(EMBREE_INCLUDE_DIRS ${EMBREE_ROOT_DIR}/include)
+    set(EMBREE_LIBRARIES
+      optimized ${EMBREE_ROOT_DIR}/lib/embree3.lib
+      optimized ${EMBREE_ROOT_DIR}/lib/embree_avx2.lib
+      optimized ${EMBREE_ROOT_DIR}/lib/embree_avx.lib
+      optimized ${EMBREE_ROOT_DIR}/lib/embree_sse42.lib
+      optimized ${EMBREE_ROOT_DIR}/lib/lexers.lib
+      optimized ${EMBREE_ROOT_DIR}/lib/math.lib
+      optimized ${EMBREE_ROOT_DIR}/lib/simd.lib
+      optimized ${EMBREE_ROOT_DIR}/lib/tasking.lib
+      optimized ${EMBREE_ROOT_DIR}/lib/sys.lib
+      debug ${EMBREE_ROOT_DIR}/lib/embree3_d.lib
+      debug ${EMBREE_ROOT_DIR}/lib/embree_avx2_d.lib
+      debug ${EMBREE_ROOT_DIR}/lib/embree_avx_d.lib
+      debug ${EMBREE_ROOT_DIR}/lib/embree_sse42_d.lib
+      debug ${EMBREE_ROOT_DIR}/lib/lexers_d.lib
+      debug ${EMBREE_ROOT_DIR}/lib/math_d.lib
+      debug ${EMBREE_ROOT_DIR}/lib/simd_d.lib
+      debug ${EMBREE_ROOT_DIR}/lib/sys_d.lib
+      debug ${EMBREE_ROOT_DIR}/lib/tasking_d.lib
+    )
+  else()
     find_package(Embree 3.8.0 REQUIRED)
   endif()
 endif()
@@ -346,29 +388,45 @@ endif()
 # Logging
 ###########################################################################
 
-if(WITH_CYCLES_LOGGING)
-  if(CYCLES_STANDALONE_REPOSITORY)
-    find_package(Glog REQUIRED)
-    find_package(Gflags REQUIRED)
-  endif()
+if(CYCLES_STANDALONE_REPOSITORY AND WITH_CYCLES_LOGGING)
+  find_package(Glog REQUIRED)
+  find_package(Gflags REQUIRED)
 endif()
 
 ###########################################################################
 # OpenSubdiv
 ###########################################################################
 
-if(WITH_CYCLES_OPENSUBDIV)
-  if(CYCLES_STANDALONE_REPOSITORY)
-    find_package(OpenSubdiv REQUIRED)
-    set(WITH_OPENSUBDIV ON)
+if(WITH_CYCLES_HYDRA_RENDER_DELEGATE AND PXR_LIBRARY_DIR AND (WITH_OPENSUBDIV OR WITH_CYCLES_OPENSUBDIV))
+  find_library(OPENSUBDIV_LIBRARY_CPU_DEBUG_PXR NAMES osdCPU_d osdCPU PATHS ${PXR_LIBRARY_DIR} NO_CACHE NO_DEFAULT_PATH)
+  find_library(OPENSUBDIV_LIBRARY_GPU_DEBUG_PXR NAMES osdGPU_d osdGPU PATHS ${PXR_LIBRARY_DIR} NO_CACHE NO_DEFAULT_PATH)
+  find_library(OPENSUBDIV_LIBRARY_CPU_RELEASE_PXR NAMES osdCPU PATHS ${PXR_LIBRARY_DIR} NO_CACHE NO_DEFAULT_PATH)
+  find_library(OPENSUBDIV_LIBRARY_GPU_RELEASE_PXR NAMES osdGPU PATHS ${PXR_LIBRARY_DIR} NO_CACHE NO_DEFAULT_PATH)
+  if(OPENSUBDIV_LIBRARY_CPU_RELEASE_PXR AND OPENSUBDIV_LIBRARY_GPU_RELEASE_PXR)
+    set(OPENSUBDIV_INCLUDE_DIRS ${PXR_INCLUDE_DIRS})
+    set(OPENSUBDIV_LIBRARIES
+      optimized ${OPENSUBDIV_LIBRARY_CPU_RELEASE_PXR}
+      optimized ${OPENSUBDIV_LIBRARY_GPU_RELEASE_PXR}
+      debug ${OPENSUBDIV_LIBRARY_CPU_DEBUG_PXR}
+      debug ${OPENSUBDIV_LIBRARY_GPU_DEBUG_PXR}
+    )
+  endif()
+endif()
 
+if(CYCLES_STANDALONE_REPOSITORY AND WITH_CYCLES_OPENSUBDIV)
+  set(WITH_OPENSUBDIV ON)
+
+  if(NOT OPENSUBDIV_LIBRARY_CPU_RELEASE_PXR OR NOT OPENSUBDIV_LIBRARY_GPU_RELEASE_PXR)
     if(MSVC AND EXISTS ${_cycles_lib_dir})
+      set(OPENSUBDIV_INCLUDE_DIRS ${OPENSUBDIV_ROOT_DIR}/include)
       set(OPENSUBDIV_LIBRARIES
         optimized ${OPENSUBDIV_ROOT_DIR}/lib/osdCPU.lib
         optimized ${OPENSUBDIV_ROOT_DIR}/lib/osdGPU.lib
         debug ${OPENSUBDIV_ROOT_DIR}/lib/osdCPU_d.lib
         debug ${OPENSUBDIV_ROOT_DIR}/lib/osdGPU_d.lib
       )
+    else()
+      find_package(OpenSubdiv REQUIRED)
     endif()
   endif()
 endif()
@@ -377,18 +435,29 @@ endif()
 # OpenVDB
 ###########################################################################
 
-if(WITH_CYCLES_OPENVDB)
-  if(CYCLES_STANDALONE_REPOSITORY)
+if(WITH_CYCLES_HYDRA_RENDER_DELEGATE AND PXR_LIBRARY_DIR AND (WITH_OPENVDB OR WITH_CYCLES_OPENVDB))
+  find_library(OPENVDB_LIBRARY_PXR NAMES openvdb PATHS ${PXR_LIBRARY_DIR} NO_CACHE NO_DEFAULT_PATH)
+  if(OPENVDB_LIBRARY_PXR)
+    set(OPENVDB_INCLUDE_DIRS ${PXR_INCLUDE_DIRS})
+    set(OPENVDB_LIBRARIES ${OPENVDB_LIBRARY_PXR})
+  endif()
+endif()
+
+if(CYCLES_STANDALONE_REPOSITORY AND WITH_CYCLES_OPENVDB)
+  set(WITH_OPENVDB ON)
+  set(OPENVDB_DEFINITIONS -DNOMINMAX -D_USE_MATH_DEFINES)
+
+  if(NOT OPENVDB_LIBRARY_PXR)
+    find_package(OpenVDB REQUIRED)
+
     if(MSVC AND EXISTS ${_cycles_lib_dir})
       set(BLOSC_LIBRARY
-          optimized ${BLOSC_ROOT_DIR}/lib/libblosc.lib
-          debug ${BLOSC_ROOT_DIR}/lib/libblosc_d.lib)
+        optimized ${BLOSC_ROOT_DIR}/lib/libblosc.lib
+        debug ${BLOSC_ROOT_DIR}/lib/libblosc_d.lib
+      )
+    else()
+      find_package(Blosc REQUIRED)
     endif()
-
-    find_package(OpenVDB REQUIRED)
-    find_package(Blosc REQUIRED)
-    set(WITH_OPENVDB ON)
-    set(OPENVDB_DEFINITIONS -DNOMINMAX -D_USE_MATH_DEFINES)
   endif()
 endif()
 
@@ -396,21 +465,21 @@ endif()
 # OpenImageDenoise
 ###########################################################################
 
-if(WITH_CYCLES_OPENIMAGEDENOISE)
-  if(CYCLES_STANDALONE_REPOSITORY)
+if(CYCLES_STANDALONE_REPOSITORY AND WITH_CYCLES_OPENIMAGEDENOISE)
+  set(WITH_OPENIMAGEDENOISE ON)
+
+  if(MSVC AND EXISTS ${_cycles_lib_dir})
+    set(OPENIMAGEDENOISE_INCLUDE_DIRS ${OPENIMAGEDENOISE_ROOT_DIR}/include)
+    set(OPENIMAGEDENOISE_LIBRARIES
+      optimized ${OPENIMAGEDENOISE_ROOT_DIR}/lib/OpenImageDenoise.lib
+      optimized ${OPENIMAGEDENOISE_ROOT_DIR}/lib/common.lib
+      optimized ${OPENIMAGEDENOISE_ROOT_DIR}/lib/dnnl.lib
+      debug ${OPENIMAGEDENOISE_ROOT_DIR}/lib/OpenImageDenoise_d.lib
+      debug ${OPENIMAGEDENOISE_ROOT_DIR}/lib/common_d.lib
+      debug ${OPENIMAGEDENOISE_ROOT_DIR}/lib/dnnl_d.lib
+    )
+  else()
     find_package(OpenImageDenoise REQUIRED)
-    set(WITH_OPENIMAGEDENOISE ON)
-
-    if(MSVC AND EXISTS ${_cycles_lib_dir})
-      set(OPENIMAGEDENOISE_LIBRARIES
-        optimized ${OPENIMAGEDENOISE_ROOT_DIR}/lib/OpenImageDenoise.lib
-        optimized ${OPENIMAGEDENOISE_ROOT_DIR}/lib/common.lib
-        optimized ${OPENIMAGEDENOISE_ROOT_DIR}/lib/dnnl.lib
-        debug ${OPENIMAGEDENOISE_ROOT_DIR}/lib/OpenImageDenoise_d.lib
-        debug ${OPENIMAGEDENOISE_ROOT_DIR}/lib/common_d.lib
-        debug ${OPENIMAGEDENOISE_ROOT_DIR}/lib/dnnl_d.lib)
-    endif()
-
   endif()
 endif()
 
@@ -418,15 +487,30 @@ endif()
 # TBB
 ###########################################################################
 
-if(CYCLES_STANDALONE_REPOSITORY)
-  if(MSVC AND EXISTS ${_cycles_lib_dir})
-    set(TBB_LIBRARY
-      optimized ${TBB_ROOT_DIR}/lib/tbb.lib
-      debug ${TBB_ROOT_DIR}/lib/debug/tbb_debug.lib
+if(WITH_CYCLES_HYDRA_RENDER_DELEGATE AND PXR_LIBRARY_DIR)
+  find_library(TBB_LIBRARY_DEBUG_PXR NAMES tbb_debug tbb PATHS ${PXR_LIBRARY_DIR} NO_CACHE NO_DEFAULT_PATH)
+  find_library(TBB_LIBRARY_RELEASE_PXR NAMES tbb PATHS ${PXR_LIBRARY_DIR} NO_CACHE NO_DEFAULT_PATH)
+  if(TBB_LIBRARY_RELEASE_PXR)
+    set(TBB_INCLUDE_DIRS ${PXR_INCLUDE_DIRS})
+    set(TBB_LIBRARIES
+      optimized ${TBB_LIBRARY_RELEASE_PXR}
+      debug ${TBB_LIBRARY_DEBUG_PXR}
     )
   endif()
+endif()
 
-  find_package(TBB REQUIRED)
+if(CYCLES_STANDALONE_REPOSITORY)
+  if(NOT TBB_LIBRARY_RELEASE_PXR)
+    if(MSVC AND EXISTS ${_cycles_lib_dir})
+      set(TBB_INCLUDE_DIRS ${TBB_ROOT_DIR}/include)
+      set(TBB_LIBRARIES
+        optimized ${TBB_ROOT_DIR}/lib/tbb.lib
+        debug ${TBB_ROOT_DIR}/lib/tbb_debug.lib
+      )
+    else()
+      find_package(TBB REQUIRED)
+    endif()
+  endif()
 endif()
 
 ###########################################################################
@@ -438,9 +522,9 @@ if(CYCLES_STANDALONE_REPOSITORY)
     set(GLEW_LIBRARY "${_cycles_lib_dir}/opengl/lib/glew.lib")
     set(GLEW_INCLUDE_DIR "${_cycles_lib_dir}/opengl/include")
     add_definitions(-DGLEW_STATIC)
+  else()
+    find_package(GLEW REQUIRED)
   endif()
-
-  find_package(GLEW REQUIRED)
 else()
   # Workaround for unconventional variable name use in Blender.
   set(GLEW_INCLUDE_DIR "${GLEW_INCLUDE_PATH}")
@@ -466,11 +550,11 @@ if(CYCLES_STANDALONE_REPOSITORY)
 
   find_package(OpenGL REQUIRED)
 
-  set(CYCLES_GL_LIBRARIES
-    ${OPENGL_gl_LIBRARY}
-    ${OPENGL_glu_LIBRARY}
-    ${GLEW_LIBRARY}
-  )
+    set(CYCLES_GL_LIBRARIES
+      ${OPENGL_gl_LIBRARY}
+      ${OPENGL_glu_LIBRARY}
+      ${GLEW_LIBRARY}
+    )
 else()
   set(CYCLES_GL_LIBRARIES
     bf_intern_glew_mx

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.
@@ -143,13 +144,13 @@ macro(cycles_install_libraries target)
     if(CMAKE_BUILD_TYPE STREQUAL "Debug")
       install(
         FILES
-        ${TBB_ROOT_DIR}/lib/debug/tbb_debug${CMAKE_SHARED_LIBRARY_SUFFIX}
+        ${TBB_ROOT_DIR}/bin/tbb_debug${CMAKE_SHARED_LIBRARY_SUFFIX}
         ${OPENVDB_ROOT_DIR}/bin/openvdb_d${CMAKE_SHARED_LIBRARY_SUFFIX}
         DESTINATION $<TARGET_FILE_DIR:${target}>)
     else()
       install(
         FILES
-        ${TBB_ROOT_DIR}/lib/tbb${CMAKE_SHARED_LIBRARY_SUFFIX}
+        ${TBB_ROOT_DIR}/bin/tbb${CMAKE_SHARED_LIBRARY_SUFFIX}
         ${OPENVDB_ROOT_DIR}/bin/openvdb${CMAKE_SHARED_LIBRARY_SUFFIX}
         DESTINATION $<TARGET_FILE_DIR:${target}>)
     endif()

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/hydra/CMakeLists.txt

@@ -0,0 +1,149 @@
+# 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
+  PUBLIC
+  hd
+  hgi
+  PRIVATE
+  cycles_scene
+  cycles_session
+  cycles_graph
+)
+
+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
+)
+
+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 "..")
+
+file(RELATIVE_PATH PLUG_INFO_LIBRARY_PATH "${CYCLES_HYDRA_INSTALL_PATH}/${HdCyclesPluginName}" "${CYCLES_HYDRA_INSTALL_PATH}/${HdCyclesPluginName}${CMAKE_SHARED_LIBRARY_SUFFIX}")
+file(RELATIVE_PATH PLUG_INFO_RESOURCE_PATH "${CYCLES_HYDRA_INSTALL_PATH}/${HdCyclesPluginName}" "${CYCLES_INSTALL_PATH}")
+
+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,308 @@
+/* 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);
+
+#if PXR_VERSION < 2102
+// clang-format off
+TF_DEFINE_PRIVATE_TOKENS(_tokens,
+    (projection)
+    (orthographic)
+);
+// clang-format on
+#endif
+
+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 PXR_VERSION < 2111
+  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
+    }
+  }
+#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, _tokens->projection);
+    if (!value.IsEmpty()) {
+      _data.SetProjection(value.Get<TfToken>() != _tokens->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,45 @@
+/* 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 ShaderNode;
+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,90 @@
+/* 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
+
+#if PXR_VERSION < 2108
+// clang-format off
+TF_DEFINE_PRIVATE_TOKENS(_tokens,
+   (fieldName)
+);
+// clang-format on
+#endif
+
+#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,584 @@
+/* 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
+
+// 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);
+  }
+};
+
+namespace {
+
+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
+
+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,63 @@
+/* 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;
+  }
+
+ private:
+  struct NodeDesc {
+    CCL_NS::ShaderNode *node;
+    const class UsdToCyclesMapping *mapping;
+  };
+
+  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<typename 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/pass_accessor.cpp

@@ -18,7 +18,11 @@ CCL_NAMESPACE_BEGIN
  */
 
 PassAccessor::PassAccessInfo::PassAccessInfo(const BufferPass &pass)
-    : type(pass.type), mode(pass.mode), include_albedo(pass.include_albedo), offset(pass.offset)
+    : type(pass.type),
+      mode(pass.mode),
+      include_albedo(pass.include_albedo),
+      is_lightgroup(!pass.lightgroup.empty()),
+      offset(pass.offset)
 {
 }
 
@@ -127,7 +131,8 @@ bool PassAccessor::get_render_tile_pixels(const RenderBuffers *render_buffers,
 
   const PassType type = pass_access_info_.type;
   const PassMode mode = pass_access_info_.mode;
-  const PassInfo pass_info = Pass::get_info(type, pass_access_info_.include_albedo);
+  const PassInfo pass_info = Pass::get_info(
+      type, pass_access_info_.include_albedo, pass_access_info_.is_lightgroup);
   int num_written_components = pass_info.num_components;
 
   if (pass_info.num_components == 1) {
@@ -215,8 +220,8 @@ void PassAccessor::init_kernel_film_convert(KernelFilmConvert *kfilm_convert,
                                             const Destination &destination) const
 {
   const PassMode mode = pass_access_info_.mode;
-  const PassInfo &pass_info = Pass::get_info(pass_access_info_.type,
-                                             pass_access_info_.include_albedo);
+  const PassInfo &pass_info = Pass::get_info(
+      pass_access_info_.type, pass_access_info_.include_albedo, pass_access_info_.is_lightgroup);
 
   kfilm_convert->pass_offset = pass_access_info_.offset;
   kfilm_convert->pass_stride = buffer_params.pass_stride;
@@ -279,8 +284,8 @@ bool PassAccessor::set_render_tile_pixels(RenderBuffers *render_buffers, const S
     return false;
   }
 
-  const PassInfo pass_info = Pass::get_info(pass_access_info_.type,
-                                            pass_access_info_.include_albedo);
+  const PassInfo pass_info = Pass::get_info(
+      pass_access_info_.type, pass_access_info_.include_albedo, pass_access_info_.is_lightgroup);
 
   const BufferParams &buffer_params = render_buffers->params;
 

intern/cycles/integrator/pass_accessor.h

@@ -28,6 +28,7 @@ class PassAccessor {
     PassType type = PASS_NONE;
     PassMode mode = PassMode::NOISY;
     bool include_albedo = false;
+    bool is_lightgroup = false;
     int offset = -1;
 
     /* For the shadow catcher matte pass: whether to approximate shadow catcher pass into its

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

@@ -223,6 +223,7 @@ set(SRC_KERNEL_INTEGRATOR_HEADERS
   integrator/intersect_subsurface.h
   integrator/intersect_volume_stack.h
   integrator/megakernel.h
+  integrator/mnee.h
   integrator/path_state.h
   integrator/shade_background.h
   integrator/shade_light.h

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

@@ -76,10 +76,11 @@ typedef unsigned long long uint64_t;
 /* GPU texture objects */
 
 typedef unsigned long long CUtexObject;
-typedef CUtexObject ccl_gpu_tex_object;
+typedef CUtexObject ccl_gpu_tex_object_2D;
+typedef CUtexObject ccl_gpu_tex_object_3D;
 
 template<typename T>
-ccl_device_forceinline T ccl_gpu_tex_object_read_2D(const ccl_gpu_tex_object texobj,
+ccl_device_forceinline T ccl_gpu_tex_object_read_2D(const ccl_gpu_tex_object_2D texobj,
                                                     const float x,
                                                     const float y)
 {
@@ -87,7 +88,7 @@ ccl_device_forceinline T ccl_gpu_tex_object_read_2D(const ccl_gpu_tex_object tex
 }
 
 template<typename T>
-ccl_device_forceinline T ccl_gpu_tex_object_read_3D(const ccl_gpu_tex_object texobj,
+ccl_device_forceinline T ccl_gpu_tex_object_read_3D(const ccl_gpu_tex_object_3D texobj,
                                                     const float x,
                                                     const float y,
                                                     const float z)

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

@@ -88,6 +88,7 @@
   extern "C" __global__ void __launch_bounds__(block_num_threads)
 
 #define ccl_gpu_kernel_signature(name, ...) kernel_gpu_##name(__VA_ARGS__)
+#define ccl_gpu_kernel_postfix
 
 #define ccl_gpu_kernel_call(x) x
 

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

@@ -56,7 +56,7 @@ ccl_device_noinline T kernel_tex_image_interp_bicubic(ccl_global const TextureIn
                                                       float x,
                                                       float y)
 {
-  ccl_gpu_tex_object tex = (ccl_gpu_tex_object)info.data;
+  ccl_gpu_tex_object_2D tex = (ccl_gpu_tex_object_2D)info.data;
 
   x = (x * info.width) - 0.5f;
   y = (y * info.height) - 0.5f;
@@ -85,7 +85,7 @@ template<typename T>
 ccl_device_noinline T
 kernel_tex_image_interp_tricubic(ccl_global const TextureInfo &info, float x, float y, float z)
 {
-  ccl_gpu_tex_object tex = (ccl_gpu_tex_object)info.data;
+  ccl_gpu_tex_object_3D tex = (ccl_gpu_tex_object_3D)info.data;
 
   x = (x * info.width) - 0.5f;
   y = (y * info.height) - 0.5f;
@@ -190,7 +190,7 @@ ccl_device float4 kernel_tex_image_interp(KernelGlobals kg, int id, float x, flo
       return kernel_tex_image_interp_bicubic<float4>(info, x, y);
     }
     else {
-      ccl_gpu_tex_object tex = (ccl_gpu_tex_object)info.data;
+      ccl_gpu_tex_object_2D tex = (ccl_gpu_tex_object_2D)info.data;
       return ccl_gpu_tex_object_read_2D<float4>(tex, x, y);
     }
   }
@@ -202,7 +202,7 @@ ccl_device float4 kernel_tex_image_interp(KernelGlobals kg, int id, float x, flo
       f = kernel_tex_image_interp_bicubic<float>(info, x, y);
     }
     else {
-      ccl_gpu_tex_object tex = (ccl_gpu_tex_object)info.data;
+      ccl_gpu_tex_object_2D tex = (ccl_gpu_tex_object_2D)info.data;
       f = ccl_gpu_tex_object_read_2D<float>(tex, x, y);
     }
 
@@ -245,7 +245,7 @@ ccl_device float4 kernel_tex_image_interp_3d(KernelGlobals kg,
       return kernel_tex_image_interp_tricubic<float4>(info, x, y, z);
     }
     else {
-      ccl_gpu_tex_object tex = (ccl_gpu_tex_object)info.data;
+      ccl_gpu_tex_object_3D tex = (ccl_gpu_tex_object_3D)info.data;
       return ccl_gpu_tex_object_read_3D<float4>(tex, x, y, z);
     }
   }
@@ -256,7 +256,7 @@ ccl_device float4 kernel_tex_image_interp_3d(KernelGlobals kg,
       f = kernel_tex_image_interp_tricubic<float>(info, x, y, z);
     }
     else {
-      ccl_gpu_tex_object tex = (ccl_gpu_tex_object)info.data;
+      ccl_gpu_tex_object_3D tex = (ccl_gpu_tex_object_3D)info.data;
       f = ccl_gpu_tex_object_read_3D<float>(tex, x, y, z);
     }
 

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

@@ -58,6 +58,7 @@ ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     INTEGRATOR_STATE_WRITE(state, shadow_path, queued_kernel) = 0;
   }
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_signature(integrator_init_from_camera,
@@ -89,6 +90,7 @@ ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
   ccl_gpu_kernel_call(
       integrator_init_from_camera(nullptr, state, tile, render_buffer, x, y, sample));
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_signature(integrator_init_from_bake,
@@ -120,6 +122,7 @@ ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
   ccl_gpu_kernel_call(
       integrator_init_from_bake(nullptr, state, tile, render_buffer, x, y, sample));
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_signature(integrator_intersect_closest,
@@ -134,6 +137,7 @@ ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_call(integrator_intersect_closest(NULL, state, render_buffer));
   }
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_signature(integrator_intersect_shadow,
@@ -147,6 +151,7 @@ ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_call(integrator_intersect_shadow(NULL, state));
   }
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_signature(integrator_intersect_subsurface,
@@ -160,6 +165,7 @@ ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_call(integrator_intersect_subsurface(NULL, state));
   }
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_signature(integrator_intersect_volume_stack,
@@ -173,6 +179,7 @@ ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_call(integrator_intersect_volume_stack(NULL, state));
   }
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_signature(integrator_shade_background,
@@ -187,6 +194,7 @@ ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_call(integrator_shade_background(NULL, state, render_buffer));
   }
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_signature(integrator_shade_light,
@@ -201,6 +209,7 @@ ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_call(integrator_shade_light(NULL, state, render_buffer));
   }
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_signature(integrator_shade_shadow,
@@ -215,6 +224,7 @@ ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_call(integrator_shade_shadow(NULL, state, render_buffer));
   }
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_signature(integrator_shade_surface,
@@ -229,6 +239,7 @@ ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_call(integrator_shade_surface(NULL, state, render_buffer));
   }
 }
+ccl_gpu_kernel_postfix
 
 #ifdef __KERNEL_METAL__
 constant int __dummy_constant [[function_constant(0)]];
@@ -256,6 +267,7 @@ ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
 #endif
   }
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_signature(integrator_shade_volume,
@@ -270,6 +282,7 @@ ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_call(integrator_shade_volume(NULL, state, render_buffer));
   }
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel_threads(GPU_PARALLEL_ACTIVE_INDEX_DEFAULT_BLOCK_SIZE)
     ccl_gpu_kernel_signature(integrator_queued_paths_array,
@@ -288,6 +301,7 @@ ccl_gpu_kernel_threads(GPU_PARALLEL_ACTIVE_INDEX_DEFAULT_BLOCK_SIZE)
                                   num_indices,
                                   ccl_gpu_kernel_lambda_pass);
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel_threads(GPU_PARALLEL_ACTIVE_INDEX_DEFAULT_BLOCK_SIZE)
     ccl_gpu_kernel_signature(integrator_queued_shadow_paths_array,
@@ -306,6 +320,7 @@ ccl_gpu_kernel_threads(GPU_PARALLEL_ACTIVE_INDEX_DEFAULT_BLOCK_SIZE)
                                   num_indices,
                                   ccl_gpu_kernel_lambda_pass);
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel_threads(GPU_PARALLEL_ACTIVE_INDEX_DEFAULT_BLOCK_SIZE)
     ccl_gpu_kernel_signature(integrator_active_paths_array,
@@ -321,6 +336,7 @@ ccl_gpu_kernel_threads(GPU_PARALLEL_ACTIVE_INDEX_DEFAULT_BLOCK_SIZE)
                                   num_indices,
                                   ccl_gpu_kernel_lambda_pass);
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel_threads(GPU_PARALLEL_ACTIVE_INDEX_DEFAULT_BLOCK_SIZE)
     ccl_gpu_kernel_signature(integrator_terminated_paths_array,
@@ -337,6 +353,7 @@ ccl_gpu_kernel_threads(GPU_PARALLEL_ACTIVE_INDEX_DEFAULT_BLOCK_SIZE)
                                   num_indices,
                                   ccl_gpu_kernel_lambda_pass);
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel_threads(GPU_PARALLEL_ACTIVE_INDEX_DEFAULT_BLOCK_SIZE)
     ccl_gpu_kernel_signature(integrator_terminated_shadow_paths_array,
@@ -353,6 +370,7 @@ ccl_gpu_kernel_threads(GPU_PARALLEL_ACTIVE_INDEX_DEFAULT_BLOCK_SIZE)
                                   num_indices,
                                   ccl_gpu_kernel_lambda_pass);
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel_threads(GPU_PARALLEL_SORTED_INDEX_DEFAULT_BLOCK_SIZE)
     ccl_gpu_kernel_signature(integrator_sorted_paths_array,
@@ -380,6 +398,7 @@ ccl_gpu_kernel_threads(GPU_PARALLEL_SORTED_INDEX_DEFAULT_BLOCK_SIZE)
                                   key_prefix_sum,
                                   ccl_gpu_kernel_lambda_pass);
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel_threads(GPU_PARALLEL_ACTIVE_INDEX_DEFAULT_BLOCK_SIZE)
     ccl_gpu_kernel_signature(integrator_compact_paths_array,
@@ -399,6 +418,7 @@ ccl_gpu_kernel_threads(GPU_PARALLEL_ACTIVE_INDEX_DEFAULT_BLOCK_SIZE)
                                   num_indices,
                                   ccl_gpu_kernel_lambda_pass);
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel_threads(GPU_PARALLEL_SORTED_INDEX_DEFAULT_BLOCK_SIZE)
     ccl_gpu_kernel_signature(integrator_compact_states,
@@ -416,6 +436,7 @@ ccl_gpu_kernel_threads(GPU_PARALLEL_SORTED_INDEX_DEFAULT_BLOCK_SIZE)
     ccl_gpu_kernel_call(integrator_state_move(NULL, to_state, from_state));
   }
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel_threads(GPU_PARALLEL_ACTIVE_INDEX_DEFAULT_BLOCK_SIZE)
     ccl_gpu_kernel_signature(integrator_compact_shadow_paths_array,
@@ -435,6 +456,7 @@ ccl_gpu_kernel_threads(GPU_PARALLEL_ACTIVE_INDEX_DEFAULT_BLOCK_SIZE)
                                   num_indices,
                                   ccl_gpu_kernel_lambda_pass);
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel_threads(GPU_PARALLEL_SORTED_INDEX_DEFAULT_BLOCK_SIZE)
     ccl_gpu_kernel_signature(integrator_compact_shadow_states,
@@ -452,12 +474,14 @@ ccl_gpu_kernel_threads(GPU_PARALLEL_SORTED_INDEX_DEFAULT_BLOCK_SIZE)
     ccl_gpu_kernel_call(integrator_shadow_state_move(NULL, to_state, from_state));
   }
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel_threads(GPU_PARALLEL_PREFIX_SUM_DEFAULT_BLOCK_SIZE) ccl_gpu_kernel_signature(
     prefix_sum, ccl_global int *counter, ccl_global int *prefix_sum, int num_values)
 {
   gpu_parallel_prefix_sum(ccl_gpu_global_id_x(), counter, prefix_sum, num_values);
 }
+ccl_gpu_kernel_postfix
 
 /* --------------------------------------------------------------------
  * Adaptive sampling.
@@ -494,6 +518,7 @@ ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     atomic_fetch_and_add_uint32(num_active_pixels, popcount(num_active_pixels_mask));
   }
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_signature(adaptive_sampling_filter_x,
@@ -512,6 +537,7 @@ ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
         kernel_adaptive_sampling_filter_x(NULL, render_buffer, sy + y, sx, sw, offset, stride));
   }
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_signature(adaptive_sampling_filter_y,
@@ -530,6 +556,7 @@ ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
         kernel_adaptive_sampling_filter_y(NULL, render_buffer, sx + x, sy, sh, offset, stride));
   }
 }
+ccl_gpu_kernel_postfix
 
 /* --------------------------------------------------------------------
  * Cryptomatte.
@@ -546,6 +573,7 @@ ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_call(kernel_cryptomatte_post(nullptr, render_buffer, pixel_index));
   }
 }
+ccl_gpu_kernel_postfix
 
 /* --------------------------------------------------------------------
  * Film.
@@ -627,6 +655,7 @@ ccl_device_inline void kernel_gpu_film_convert_half_write(ccl_global uchar4 *rgb
 \
     FILM_GET_PASS_PIXEL_F32(variant, input_channel_count); \
   } \
+  ccl_gpu_kernel_postfix \
 \
   ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS) \
       ccl_gpu_kernel_signature(film_convert_##variant##_half_rgba, \
@@ -666,7 +695,8 @@ ccl_device_inline void kernel_gpu_film_convert_half_write(ccl_global uchar4 *rgb
     const half4 half_pixel = float4_to_half4_display( \
         make_float4(pixel[0], pixel[1], pixel[2], pixel[3])); \
     kernel_gpu_film_convert_half_write(rgba, rgba_offset, rgba_stride, x, y, half_pixel); \
-  }
+  } \
+  ccl_gpu_kernel_postfix
 
 /* 1 channel inputs */
 KERNEL_FILM_CONVERT_VARIANT(depth, 1)
@@ -706,6 +736,7 @@ ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_call(kernel_displace_evaluate(NULL, input, output, offset + i));
   }
 }
+ccl_gpu_kernel_postfix
 
 /* Background */
 
@@ -721,6 +752,7 @@ ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_call(kernel_background_evaluate(NULL, input, output, offset + i));
   }
 }
+ccl_gpu_kernel_postfix
 
 /* Curve Shadow Transparency */
 
@@ -737,6 +769,7 @@ ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
         kernel_curve_shadow_transparency_evaluate(NULL, input, output, offset + i));
   }
 }
+ccl_gpu_kernel_postfix
 
 /* --------------------------------------------------------------------
  * Denoising.
@@ -770,6 +803,7 @@ ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
   color_out[1] = clamp(color_out[1], 0.0f, 10000.0f);
   color_out[2] = clamp(color_out[2], 0.0f, 10000.0f);
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_signature(filter_guiding_preprocess,
@@ -849,6 +883,7 @@ ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     flow_out[1] = -motion_in[1] * pixel_scale;
   }
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_signature(filter_guiding_set_fake_albedo,
@@ -877,6 +912,7 @@ ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
   albedo_out[1] = 0.5f;
   albedo_out[2] = 0.5f;
 }
+ccl_gpu_kernel_postfix
 
 ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     ccl_gpu_kernel_signature(filter_color_postprocess,
@@ -936,6 +972,7 @@ ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     denoised_pixel[3] = 0;
   }
 }
+ccl_gpu_kernel_postfix
 
 /* --------------------------------------------------------------------
  * Shadow catcher.
@@ -961,3 +998,4 @@ ccl_gpu_kernel(GPU_KERNEL_BLOCK_NUM_THREADS, GPU_KERNEL_MAX_REGISTERS)
     atomic_fetch_and_add_uint32(num_possible_splits, popcount(can_split_mask));
   }
 }
+ccl_gpu_kernel_postfix

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

@@ -73,10 +73,11 @@ typedef unsigned long long uint64_t;
 #define ccl_gpu_ballot(predicate) __ballot(predicate)
 
 /* GPU texture objects */
-typedef hipTextureObject_t ccl_gpu_tex_object;
+typedef hipTextureObject_t ccl_gpu_tex_object_2D;
+typedef hipTextureObject_t ccl_gpu_tex_object_3D;
 
 template<typename T>
-ccl_device_forceinline T ccl_gpu_tex_object_read_2D(const ccl_gpu_tex_object texobj,
+ccl_device_forceinline T ccl_gpu_tex_object_read_2D(const ccl_gpu_tex_object_2D texobj,
                                                     const float x,
                                                     const float y)
 {
@@ -84,7 +85,7 @@ ccl_device_forceinline T ccl_gpu_tex_object_read_2D(const ccl_gpu_tex_object tex
 }
 
 template<typename T>
-ccl_device_forceinline T ccl_gpu_tex_object_read_3D(const ccl_gpu_tex_object texobj,
+ccl_device_forceinline T ccl_gpu_tex_object_read_3D(const ccl_gpu_tex_object_3D texobj,
                                                     const float x,
                                                     const float y,
                                                     const float z)

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

@@ -31,6 +31,7 @@
   extern "C" __global__ void __launch_bounds__(block_num_threads)
 
 #define ccl_gpu_kernel_signature(name, ...) kernel_gpu_##name(__VA_ARGS__)
+#define ccl_gpu_kernel_postfix
 
 #define ccl_gpu_kernel_call(x) x
 

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

@@ -132,6 +132,7 @@ void kernel_gpu_##name::run(thread MetalKernelContext& context, \
                   uint simd_group_index, \
                   uint num_simd_groups) ccl_global const
 
+#define ccl_gpu_kernel_postfix
 #define ccl_gpu_kernel_call(x) context.x
 
 /* define a function object where "func" is the lambda body, and additional parameters are used to specify captured state  */

intern/cycles/kernel/device/metal/context_begin.h

@@ -19,17 +19,18 @@ class MetalKernelContext {
     {}
 
     /* texture fetch adapter functions */
-    typedef uint64_t ccl_gpu_tex_object;
+    typedef uint64_t ccl_gpu_tex_object_2D;
+    typedef uint64_t ccl_gpu_tex_object_3D;
 
     template<typename T>
     inline __attribute__((__always_inline__))
-    T ccl_gpu_tex_object_read_2D(ccl_gpu_tex_object tex, float x, float y) const {
+    T ccl_gpu_tex_object_read_2D(ccl_gpu_tex_object_2D tex, float x, float y) const {
       kernel_assert(0);
       return 0;
     }
     template<typename T>
     inline __attribute__((__always_inline__))
-    T ccl_gpu_tex_object_read_3D(ccl_gpu_tex_object tex, float x, float y, float z) const {
+    T ccl_gpu_tex_object_read_3D(ccl_gpu_tex_object_3D tex, float x, float y, float z) const {
       kernel_assert(0);
       return 0;
     }
@@ -37,14 +38,14 @@ class MetalKernelContext {
     // texture2d
     template<>
     inline __attribute__((__always_inline__))
-    float4 ccl_gpu_tex_object_read_2D(ccl_gpu_tex_object tex, float x, float y) const {
+    float4 ccl_gpu_tex_object_read_2D(ccl_gpu_tex_object_2D tex, float x, float y) const {
       const uint tid(tex);
       const uint sid(tex >> 32);
       return metal_ancillaries->textures_2d[tid].tex.sample(metal_samplers[sid], float2(x, y));
     }
     template<>
     inline __attribute__((__always_inline__))
-    float ccl_gpu_tex_object_read_2D(ccl_gpu_tex_object tex, float x, float y) const {
+    float ccl_gpu_tex_object_read_2D(ccl_gpu_tex_object_2D tex, float x, float y) const {
       const uint tid(tex);
       const uint sid(tex >> 32);
       return metal_ancillaries->textures_2d[tid].tex.sample(metal_samplers[sid], float2(x, y)).x;
@@ -53,14 +54,14 @@ class MetalKernelContext {
     // texture3d
     template<>
     inline __attribute__((__always_inline__))
-    float4 ccl_gpu_tex_object_read_3D(ccl_gpu_tex_object tex, float x, float y, float z) const {
+    float4 ccl_gpu_tex_object_read_3D(ccl_gpu_tex_object_3D tex, float x, float y, float z) const {
       const uint tid(tex);
       const uint sid(tex >> 32);
       return metal_ancillaries->textures_3d[tid].tex.sample(metal_samplers[sid], float3(x, y, z));
     }
     template<>
     inline __attribute__((__always_inline__))
-    float ccl_gpu_tex_object_read_3D(ccl_gpu_tex_object tex, float x, float y, float z) const {
+    float ccl_gpu_tex_object_read_3D(ccl_gpu_tex_object_3D tex, float x, float y, float z) const {
       const uint tid(tex);
       const uint sid(tex >> 32);
       return metal_ancillaries->textures_3d[tid].tex.sample(metal_samplers[sid], float3(x, y, z)).x;

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

@@ -78,10 +78,11 @@ typedef unsigned long long uint64_t;
 /* GPU texture objects */
 
 typedef unsigned long long CUtexObject;
-typedef CUtexObject ccl_gpu_tex_object;
+typedef CUtexObject ccl_gpu_tex_object_2D;
+typedef CUtexObject ccl_gpu_tex_object_3D;
 
 template<typename T>
-ccl_device_forceinline T ccl_gpu_tex_object_read_2D(const ccl_gpu_tex_object texobj,
+ccl_device_forceinline T ccl_gpu_tex_object_read_2D(const ccl_gpu_tex_object_2D texobj,
                                                     const float x,
                                                     const float y)
 {
@@ -89,7 +90,7 @@ ccl_device_forceinline T ccl_gpu_tex_object_read_2D(const ccl_gpu_tex_object tex
 }
 
 template<typename T>
-ccl_device_forceinline T ccl_gpu_tex_object_read_3D(const ccl_gpu_tex_object texobj,
+ccl_device_forceinline T ccl_gpu_tex_object_read_3D(const ccl_gpu_tex_object_3D texobj,
                                                     const float x,
                                                     const float y,
                                                     const float z)

intern/cycles/kernel/film/accumulate.h

@@ -320,12 +320,13 @@ ccl_device_inline void kernel_accum_combined_transparent_pass(KernelGlobals kg,
 }
 
 /* Write background or emission to appropriate pass. */
-ccl_device_inline void kernel_accum_emission_or_background_pass(KernelGlobals kg,
-                                                                ConstIntegratorState state,
-                                                                float3 contribution,
-                                                                ccl_global float *ccl_restrict
-                                                                    buffer,
-                                                                const int pass)
+ccl_device_inline void kernel_accum_emission_or_background_pass(
+    KernelGlobals kg,
+    ConstIntegratorState state,
+    float3 contribution,
+    ccl_global float *ccl_restrict buffer,
+    const int pass,
+    const int lightgroup = LIGHTGROUP_NONE)
 {
   if (!(kernel_data.film.light_pass_flag & PASS_ANY)) {
     return;
@@ -347,11 +348,22 @@ ccl_device_inline void kernel_accum_emission_or_background_pass(KernelGlobals kg
   }
 #  endif /* __DENOISING_FEATURES__ */
 
+  if (lightgroup != LIGHTGROUP_NONE && kernel_data.film.pass_lightgroup != PASS_UNUSED) {
+    kernel_write_pass_float3(buffer + kernel_data.film.pass_lightgroup + 3 * lightgroup,
+                             contribution);
+  }
+
   if (!(path_flag & PATH_RAY_ANY_PASS)) {
     /* Directly visible, write to emission or background pass. */
     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 +449,19 @@ 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;
+    }
+
+    /* Write lightgroup pass. LIGHTGROUP_NONE is ~0 so decode from unsigned to signed */
+    const int lightgroup = (int)(INTEGRATOR_STATE(state, shadow_path, lightgroup)) - 1;
+    if (lightgroup != LIGHTGROUP_NONE && kernel_data.film.pass_lightgroup != PASS_UNUSED) {
+      kernel_write_pass_float3(buffer + kernel_data.film.pass_lightgroup + 3 * lightgroup,
+                               contribution);
+    }
+
     if (kernel_data.kernel_features & KERNEL_FEATURE_LIGHT_PASSES) {
       int pass_offset = PASS_UNUSED;
 
@@ -554,15 +579,20 @@ ccl_device_inline void kernel_accum_background(KernelGlobals kg,
     kernel_accum_combined_transparent_pass(
         kg, path_flag, sample, contribution, transparent, buffer);
   }
-  kernel_accum_emission_or_background_pass(
-      kg, state, contribution, buffer, kernel_data.film.pass_background);
+  kernel_accum_emission_or_background_pass(kg,
+                                           state,
+                                           contribution,
+                                           buffer,
+                                           kernel_data.film.pass_background,
+                                           kernel_data.background.lightgroup);
 }
 
 /* Write emission to render buffer. */
 ccl_device_inline void kernel_accum_emission(KernelGlobals kg,
                                              ConstIntegratorState state,
                                              const float3 L,
-                                             ccl_global float *ccl_restrict render_buffer)
+                                             ccl_global float *ccl_restrict render_buffer,
+                                             const int lightgroup = LIGHTGROUP_NONE)
 {
   float3 contribution = L;
   kernel_accum_clamp(kg, &contribution, INTEGRATOR_STATE(state, path, bounce) - 1);
@@ -573,7 +603,7 @@ ccl_device_inline void kernel_accum_emission(KernelGlobals kg,
 
   kernel_accum_combined_pass(kg, path_flag, sample, contribution, buffer);
   kernel_accum_emission_or_background_pass(
-      kg, state, contribution, buffer, kernel_data.film.pass_emission);
+      kg, state, contribution, buffer, kernel_data.film.pass_emission, lightgroup);
 }
 
 CCL_NAMESPACE_END

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

@@ -283,6 +283,26 @@ ccl_device_inline float object_pass_id(KernelGlobals kg, int object)
   return kernel_tex_fetch(__objects, object).pass_id;
 }
 
+/* Lightgroup of lamp */
+
+ccl_device_inline int lamp_lightgroup(KernelGlobals kg, int lamp)
+{
+  if (lamp == LAMP_NONE)
+    return LIGHTGROUP_NONE;
+
+  return kernel_tex_fetch(__lights, lamp).lightgroup;
+}
+
+/* Lightgroup of object */
+
+ccl_device_inline int object_lightgroup(KernelGlobals kg, int object)
+{
+  if (object == OBJECT_NONE)
+    return LIGHTGROUP_NONE;
+
+  return kernel_tex_fetch(__objects, object).lightgroup;
+}
+
 /* Per lamp random number for shader variation */
 
 ccl_device_inline float lamp_random_number(KernelGlobals kg, int lamp)

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();
   }
 }