WIP changes to compiling interface directory as C++ code

Instead to create only the Blank object, now a new Layer and a simple material is added.

This is a common request of artists.

Reviewed By: mendio, pepeland

Differential Revision: https://developer.blender.org/D11110

build_files/build_environment/CMakeLists.txt

@@ -113,7 +113,7 @@ include(cmake/expat.cmake)
 include(cmake/yamlcpp.cmake)
 include(cmake/opencolorio.cmake)
 
-if(APPLE AND ("${CMAKE_OSX_ARCHITECTURES}" STREQUAL "arm64"))
+if(BLENDER_PLATFORM_ARM)
   include(cmake/sse2neon.cmake)
 endif()
 

build_files/build_environment/cmake/boost.cmake

@@ -18,6 +18,12 @@
 
 set(BOOST_ADDRESS_MODEL 64)
 
+if(BLENDER_PLATFORM_ARM)
+  set(BOOST_ARCHITECTURE arm)
+else()
+  set(BOOST_ARCHITECTURE x86)
+endif()
+
 if(WIN32)
   set(BOOST_TOOLSET toolset=msvc-14.1)
   set(BOOST_COMPILER_STRING -vc141)
@@ -29,7 +35,6 @@ if(WIN32)
   if(BUILD_MODE STREQUAL Release)
     set(BOOST_HARVEST_CMD ${BOOST_HARVEST_CMD} && ${CMAKE_COMMAND} -E copy_directory ${LIBDIR}/boost/include/boost-${BOOST_VERSION_NODOTS_SHORT}/ ${HARVEST_TARGET}/boost/include/)
   endif()
-
 elseif(APPLE)
   set(BOOST_CONFIGURE_COMMAND ./bootstrap.sh)
   set(BOOST_BUILD_COMMAND ./b2)
@@ -93,7 +98,7 @@ ExternalProject_Add(external_boost
   UPDATE_COMMAND  ""
   PATCH_COMMAND ${BOOST_PATCH_COMMAND}
   CONFIGURE_COMMAND ${BOOST_CONFIGURE_COMMAND}
-  BUILD_COMMAND ${BOOST_BUILD_COMMAND} ${BOOST_BUILD_OPTIONS} -j${MAKE_THREADS} architecture=x86 address-model=${BOOST_ADDRESS_MODEL} link=static threading=multi ${BOOST_OPTIONS}    --prefix=${LIBDIR}/boost install
+  BUILD_COMMAND ${BOOST_BUILD_COMMAND} ${BOOST_BUILD_OPTIONS} -j${MAKE_THREADS} architecture=${BOOST_ARCHITECTURE} address-model=${BOOST_ADDRESS_MODEL} link=static threading=multi ${BOOST_OPTIONS}    --prefix=${LIBDIR}/boost install
   BUILD_IN_SOURCE 1
   INSTALL_COMMAND "${BOOST_HARVEST_CMD}"
 )

build_files/build_environment/cmake/embree.cmake

@@ -47,7 +47,7 @@ else()
   set(EMBREE_BUILD_DIR)
 endif()
 
-if(APPLE AND ("${CMAKE_OSX_ARCHITECTURES}" STREQUAL "arm64"))
+if(BLENDER_PLATFORM_ARM)
   ExternalProject_Add(external_embree
     GIT_REPOSITORY ${EMBREE_ARM_GIT}
     GIT_TAG "blender-arm"

build_files/build_environment/cmake/gmp.cmake

@@ -25,19 +25,12 @@ else()
   set(GMP_OPTIONS --enable-static --disable-shared )
 endif()
 
-if(APPLE)
-  if("${CMAKE_OSX_ARCHITECTURES}" STREQUAL "arm64")
-    set(GMP_OPTIONS
-      ${GMP_OPTIONS}
-      --disable-assembly
-    )
-  else()
-    set(GMP_OPTIONS
-      ${GMP_OPTIONS}
-      --with-pic
-    )
-  endif()
-elseif(UNIX)
+if(APPLE AND NOT BLENDER_PLATFORM_ARM)
+  set(GMP_OPTIONS
+    ${GMP_OPTIONS}
+    --with-pic
+  )
+elseif(UNIX AND NOT APPLE)
   set(GMP_OPTIONS
     ${GMP_OPTIONS}
     --with-pic
@@ -45,6 +38,13 @@ elseif(UNIX)
   )
 endif()
 
+if(BLENDER_PLATFORM_ARM)
+  set(GMP_OPTIONS
+    ${GMP_OPTIONS}
+    --disable-assembly
+  )
+endif()
+
 ExternalProject_Add(external_gmp
   URL file://${PACKAGE_DIR}/${GMP_FILE}
   DOWNLOAD_DIR ${DOWNLOAD_DIR}

build_files/build_environment/cmake/harvest.cmake

@@ -109,9 +109,9 @@ harvest(llvm/lib llvm/lib "libclang*.a")
 if(APPLE)
   harvest(openmp/lib openmp/lib "*")
   harvest(openmp/include openmp/include "*.h")
-  if("${CMAKE_OSX_ARCHITECTURES}" STREQUAL "arm64")
-    harvest(sse2neon sse2neon "*.h")
-  endif()
+endif()
+if(BLENDER_PLATFORM_ARM)
+  harvest(sse2neon sse2neon "*.h")
 endif()
 harvest(ogg/lib ffmpeg/lib "*.a")
 harvest(openal/include openal/include "*.h")

build_files/build_environment/cmake/llvm.cmake

@@ -16,7 +16,7 @@
 #
 # ***** END GPL LICENSE BLOCK *****
 
-if(APPLE AND "${CMAKE_OSX_ARCHITECTURES}" STREQUAL "arm64")
+if(BLENDER_PLATFORM_ARM)
   set(LLVM_TARGETS AArch64$<SEMICOLON>ARM)
 else()
   set(LLVM_TARGETS X86)

build_files/build_environment/cmake/opencolorio.cmake

@@ -36,7 +36,7 @@ set(OPENCOLORIO_EXTRA_ARGS
   -Dyaml-cpp_ROOT=${LIBDIR}/yamlcpp
 )
 
-if(APPLE AND NOT("${CMAKE_OSX_ARCHITECTURES}" STREQUAL "x86_64"))
+if(BLENDER_PLATFORM_ARM)
   set(OPENCOLORIO_EXTRA_ARGS
     ${OPENCOLORIO_EXTRA_ARGS}
     -DOCIO_USE_SSE=OFF

build_files/build_environment/cmake/options.cmake

@@ -137,6 +137,10 @@ else()
     endif()
     set(OSX_SYSROOT ${XCODE_DEV_PATH}/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk)
 
+    if("${CMAKE_OSX_ARCHITECTURES}" STREQUAL "arm64")
+      set(BLENDER_PLATFORM_ARM ON)
+    endif()
+
     set(PLATFORM_CFLAGS "-isysroot ${OSX_SYSROOT} -mmacosx-version-min=${OSX_DEPLOYMENT_TARGET} -arch ${CMAKE_OSX_ARCHITECTURES}")
     set(PLATFORM_CXXFLAGS "-isysroot ${OSX_SYSROOT} -mmacosx-version-min=${OSX_DEPLOYMENT_TARGET} -std=c++11 -stdlib=libc++ -arch ${CMAKE_OSX_ARCHITECTURES}")
     set(PLATFORM_LDFLAGS "-isysroot ${OSX_SYSROOT} -mmacosx-version-min=${OSX_DEPLOYMENT_TARGET} -arch ${CMAKE_OSX_ARCHITECTURES}")
@@ -151,6 +155,10 @@ else()
       -DCMAKE_OSX_SYSROOT:PATH=${OSX_SYSROOT}
     )
   else()
+    if("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "aarch64")
+      set(BLENDER_PLATFORM_ARM ON)
+    endif()
+
     set(PLATFORM_CFLAGS "-fPIC")
     set(PLATFORM_CXXFLAGS "-std=c++11 -fPIC")
     set(PLATFORM_LDFLAGS)

build_files/build_environment/cmake/png.cmake

@@ -22,8 +22,8 @@ set(PNG_EXTRA_ARGS
   -DPNG_STATIC=ON
 )
 
-if(APPLE AND ("${CMAKE_OSX_ARCHITECTURES}" STREQUAL "arm64"))
-  set(PNG_EXTRA_ARGS ${PNG_EXTRA_ARGS} -DPNG_HARDWARE_OPTIMIZATIONS=ON -DPNG_ARM_NEON=on -DCMAKE_SYSTEM_PROCESSOR="aarch64")
+if(BLENDER_PLATFORM_ARM)
+  set(PNG_EXTRA_ARGS ${PNG_EXTRA_ARGS} -DPNG_HARDWARE_OPTIMIZATIONS=ON -DPNG_ARM_NEON=ON -DCMAKE_SYSTEM_PROCESSOR="aarch64")
 endif()
 
 ExternalProject_Add(external_png

build_files/build_environment/cmake/sse2neon.cmake

@@ -16,15 +16,13 @@
 #
 # ***** END GPL LICENSE BLOCK *****
 
-if(APPLE AND ("${CMAKE_OSX_ARCHITECTURES}" STREQUAL "arm64"))
-  ExternalProject_Add(external_sse2neon
-    GIT_REPOSITORY  ${SSE2NEON_GIT}
-    GIT_TAG ${SSE2NEON_GIT_HASH}
-    DOWNLOAD_DIR ${DOWNLOAD_DIR}
-    PREFIX ${BUILD_DIR}/sse2neon
-    CONFIGURE_COMMAND echo sse2neon - Nothing to configure
-    BUILD_COMMAND echo sse2neon - nothing to build
-    INSTALL_COMMAND mkdir -p ${LIBDIR}/sse2neon && cp ${BUILD_DIR}/sse2neon/src/external_sse2neon/sse2neon.h ${LIBDIR}/sse2neon
-    INSTALL_DIR ${LIBDIR}/sse2neon
-  )
-endif()
+ExternalProject_Add(external_sse2neon
+  GIT_REPOSITORY  ${SSE2NEON_GIT}
+  GIT_TAG ${SSE2NEON_GIT_HASH}
+  DOWNLOAD_DIR ${DOWNLOAD_DIR}
+  PREFIX ${BUILD_DIR}/sse2neon
+  CONFIGURE_COMMAND echo sse2neon - Nothing to configure
+  BUILD_COMMAND echo sse2neon - nothing to build
+  INSTALL_COMMAND mkdir -p ${LIBDIR}/sse2neon && cp ${BUILD_DIR}/sse2neon/src/external_sse2neon/sse2neon.h ${LIBDIR}/sse2neon
+  INSTALL_DIR ${LIBDIR}/sse2neon
+)

build_files/build_environment/cmake/ssl.cmake

@@ -22,7 +22,9 @@ set(SSL_PATCH_CMD echo .)
 if(APPLE)
   set(SSL_OS_COMPILER "blender-darwin-${CMAKE_OSX_ARCHITECTURES}")
 else()
-  if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
+  if(BLENDER_PLATFORM_ARM)
+    set(SSL_OS_COMPILER "blender-linux-aarch64")
+  elseif("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
     set(SSL_EXTRA_ARGS enable-ec_nistp_64_gcc_128)
     set(SSL_OS_COMPILER "blender-linux-x86_64")
   else()

build_files/build_environment/cmake/ssl.conf

@@ -8,6 +8,11 @@ my %targets = (
     inherit_from     => [ "linux-x86_64" ],
     cflags => add("-fPIC"),
   },
+  "blender-linux-aarch64" => {
+    inherit_from     => [ "linux-aarch64" ],
+    cxxflags => add("-fPIC"),
+    cflags => add("-fPIC"),
+  },
   "blender-darwin-x86_64" => {
     inherit_from     => [ "darwin64-x86_64-cc" ],
     cflags => add("-fPIC"),

build_files/build_environment/cmake/tbb.cmake

@@ -21,6 +21,7 @@ if(WIN32)
     -DTBB_BUILD_TBBMALLOC=On
     -DTBB_BUILD_TBBMALLOC_PROXY=On
     -DTBB_BUILD_STATIC=Off
+    -DTBB_BUILD_TESTS=Off
   )
   set(TBB_LIBRARY tbb)
   set(TBB_STATIC_LIBRARY Off)
@@ -30,6 +31,7 @@ else()
     -DTBB_BUILD_TBBMALLOC=On
     -DTBB_BUILD_TBBMALLOC_PROXY=Off
     -DTBB_BUILD_STATIC=On
+    -DTBB_BUILD_TESTS=Off
   )
   set(TBB_LIBRARY tbb_static)
   set(TBB_STATIC_LIBRARY On)
@@ -42,7 +44,7 @@ ExternalProject_Add(external_tbb
   URL_HASH ${TBB_HASH_TYPE}=${TBB_HASH}
   PREFIX ${BUILD_DIR}/tbb
   PATCH_COMMAND COMMAND ${CMAKE_COMMAND} -E copy ${PATCH_DIR}/cmakelists_tbb.txt ${BUILD_DIR}/tbb/src/external_tbb/CMakeLists.txt &&
-  ${CMAKE_COMMAND} -E copy ${BUILD_DIR}/tbb/src/external_tbb/build/vs2013/version_string.ver ${BUILD_DIR}/tbb/src/external_tbb/src/tbb/version_string.ver &&
+  ${CMAKE_COMMAND} -E copy ${BUILD_DIR}/tbb/src/external_tbb/build/vs2013/version_string.ver ${BUILD_DIR}/tbb/src/external_tbb/build/version_string.ver.in &&
   ${PATCH_CMD} -p 1 -d ${BUILD_DIR}/tbb/src/external_tbb < ${PATCH_DIR}/tbb.diff
   CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${LIBDIR}/tbb ${DEFAULT_CMAKE_FLAGS} ${TBB_EXTRA_ARGS}
   INSTALL_DIR ${LIBDIR}/tbb

build_files/build_environment/cmake/versions.cmake

@@ -152,7 +152,7 @@ set(OPENCOLORIO_HASH 1a2e3478b6cd9a1549f24e1b2205e3f0)
 set(OPENCOLORIO_HASH_TYPE MD5)
 set(OPENCOLORIO_FILE OpenColorIO-${OPENCOLORIO_VERSION}.tar.gz)
 
-if(APPLE AND ("${CMAKE_OSX_ARCHITECTURES}" STREQUAL "arm64"))
+if(BLENDER_PLATFORM_ARM)
   # Newer version required by ISPC with arm support.
   set(LLVM_VERSION 11.0.1)
   set(LLVM_URI https://github.com/llvm/llvm-project/releases/download/llvmorg-${LLVM_VERSION}/llvm-project-${LLVM_VERSION}.src.tar.xz)
@@ -398,11 +398,20 @@ set(LZMA_HASH 5117f930900b341493827d63aa910ff5e011e0b994197c3b71c08a20228a42df)
 set(LZMA_HASH_TYPE SHA256)
 set(LZMA_FILE xz-${LZMA_VERSION}.tar.bz2)
 
-set(SSL_VERSION 1.1.1g)
-set(SSL_URI https://www.openssl.org/source/openssl-${SSL_VERSION}.tar.gz)
-set(SSL_HASH ddb04774f1e32f0c49751e21b67216ac87852ceb056b75209af2443400636d46)
-set(SSL_HASH_TYPE SHA256)
-set(SSL_FILE openssl-${SSL_VERSION}.tar.gz)
+if(BLENDER_PLATFORM_ARM)
+  # Need at least 1.1.1i for aarch64 support (https://github.com/openssl/openssl/pull/13218)
+  set(SSL_VERSION 1.1.1i)
+  set(SSL_URI https://www.openssl.org/source/openssl-${SSL_VERSION}.tar.gz)
+  set(SSL_HASH e8be6a35fe41d10603c3cc635e93289ed00bf34b79671a3a4de64fcee00d5242)
+  set(SSL_HASH_TYPE SHA256)
+  set(SSL_FILE openssl-${SSL_VERSION}.tar.gz)
+else()
+  set(SSL_VERSION 1.1.1g)
+  set(SSL_URI https://www.openssl.org/source/openssl-${SSL_VERSION}.tar.gz)
+  set(SSL_HASH ddb04774f1e32f0c49751e21b67216ac87852ceb056b75209af2443400636d46)
+  set(SSL_HASH_TYPE SHA256)
+  set(SSL_FILE openssl-${SSL_VERSION}.tar.gz)
+endif()
 
 set(SQLITE_VERSION 3.31.1)
 set(SQLITE_URI https://www.sqlite.org/2018/sqlite-src-3240000.zip)
@@ -453,7 +462,7 @@ set(XR_OPENXR_SDK_HASH 0df6b2fd6045423451a77ff6bc3e1a75)
 set(XR_OPENXR_SDK_HASH_TYPE MD5)
 set(XR_OPENXR_SDK_FILE OpenXR-SDK-${XR_OPENXR_SDK_VERSION}.tar.gz)
 
-if(APPLE AND ("${CMAKE_OSX_ARCHITECTURES}" STREQUAL "arm64"))
+if(BLENDER_PLATFORM_ARM)
   # Unreleased version with macOS arm support.
   set(ISPC_URI https://github.com/ispc/ispc/archive/f5949c055eb9eeb93696978a3da4bfb3a6a30b35.zip)
   set(ISPC_HASH d382fea18d01dbd0cd05d9e1ede36d7d)

build_files/build_environment/cmake/x264.cmake

@@ -20,24 +20,16 @@ if(WIN32)
   set(X264_EXTRA_ARGS --enable-win32thread --cross-prefix=${MINGW_HOST}- --host=${MINGW_HOST})
 endif()
 
-
-if(APPLE)
-  if("${CMAKE_OSX_ARCHITECTURES}" STREQUAL "arm64")
-    set(X264_EXTRA_ARGS ${X264_EXTRA_ARGS} "--disable-asm")
-    set(X264_CONFIGURE_ENV echo .)
-  else()
-    set(X264_CONFIGURE_ENV
-      export AS=${LIBDIR}/nasm/bin/nasm
-    )
-  endif()
-else()
-  set(X264_CONFIGURE_ENV echo .)
+if(BLENDER_PLATFORM_ARM)
+  set(X264_EXTRA_ARGS ${X264_EXTRA_ARGS} "--disable-asm")
 endif()
 
-if(UNIX AND NOT APPLE)
+if((APPLE AND NOT BLENDER_PLATFORM_ARM) OR (UNIX AND NOT APPLE))
   set(X264_CONFIGURE_ENV
     export AS=${LIBDIR}/nasm/bin/nasm
   )
+else()
+  set(X264_CONFIGURE_ENV echo .)
 endif()
 
 ExternalProject_Add(external_x264

build_files/build_environment/install_deps.sh

@@ -1797,6 +1797,10 @@ compile_OCIO() {
     cmake_d="$cmake_d -D OCIO_BUILD_PYTHON=OFF"
     cmake_d="$cmake_d -D OCIO_BUILD_GPU_TESTS=OFF"
 
+    if [ $(uname -m) == "aarch64" ]; then
+      cmake_d="$cmake_d -D OCIO_USE_SSE=OFF"
+    fi
+
     if file /bin/cp | grep -q '32-bit'; then
       cflags="-fPIC -m32 -march=i686"
     else
@@ -2059,7 +2063,10 @@ compile_OIIO() {
     cmake_d="$cmake_d -D CMAKE_INSTALL_PREFIX=$_inst"
     cmake_d="$cmake_d -D STOP_ON_WARNING=OFF"
     cmake_d="$cmake_d -D LINKSTATIC=OFF"
-    cmake_d="$cmake_d -D USE_SIMD=sse2"
+
+    if [ $(uname -m) != "aarch64" ]; then
+      cmake_d="$cmake_d -D USE_SIMD=sse2"
+    fi
 
     cmake_d="$cmake_d -D OPENEXR_VERSION=$OPENEXR_VERSION"
 
@@ -2079,7 +2086,7 @@ compile_OIIO() {
     cmake_d="$cmake_d -D USE_OPENCV=OFF"
     cmake_d="$cmake_d -D BUILD_TESTING=OFF"
     cmake_d="$cmake_d -D OIIO_BUILD_TESTS=OFF"
-    cmake_d="$cmake_d -D OIIO_BUILD_TOOLS=ON"
+    cmake_d="$cmake_d -D OIIO_BUILD_TOOLS=OFF"
     cmake_d="$cmake_d -D TXT2MAN="
     #cmake_d="$cmake_d -D CMAKE_EXPORT_COMPILE_COMMANDS=ON"
     #cmake_d="$cmake_d -D CMAKE_VERBOSE_MAKEFILE=ON"
@@ -2209,10 +2216,15 @@ compile_LLVM() {
     mkdir build
     cd build
 
+    LLVM_TARGETS="X86"
+    if [ $(uname -m) == "aarch64" ]; then
+      LLVM_TARGETS="AArch64"
+    fi
+
     cmake_d="-D CMAKE_BUILD_TYPE=Release"
     cmake_d="$cmake_d -D CMAKE_INSTALL_PREFIX=$_inst"
     cmake_d="$cmake_d -D LLVM_ENABLE_FFI=ON"
-    cmake_d="$cmake_d -D LLVM_TARGETS_TO_BUILD=X86"
+    cmake_d="$cmake_d -D LLVM_TARGETS_TO_BUILD=$LLVM_TARGETS"
     cmake_d="$cmake_d -D LLVM_ENABLE_TERMINFO=OFF"
 
     if [ -d $_FFI_INCLUDE_DIR ]; then
@@ -2329,13 +2341,16 @@ compile_OSL() {
     cmake_d="$cmake_d -D STOP_ON_WARNING=OFF"
     cmake_d="$cmake_d -D OSL_BUILD_PLUGINS=OFF"
     cmake_d="$cmake_d -D OSL_BUILD_TESTS=OFF"
-    cmake_d="$cmake_d -D USE_SIMD=sse2"
     cmake_d="$cmake_d -D USE_LLVM_BITCODE=OFF"
     cmake_d="$cmake_d -D USE_PARTIO=OFF"
     cmake_d="$cmake_d -D OSL_BUILD_MATERIALX=OFF"
     cmake_d="$cmake_d -D USE_QT=OFF"
     cmake_d="$cmake_d -D USE_PYTHON=OFF"
 
+    if [ $(uname -m) != "aarch64" ]; then
+      cmake_d="$cmake_d -D USE_SIMD=sse2"
+    fi
+
     cmake_d="$cmake_d -D CMAKE_CXX_STANDARD=14"
 
     #~ cmake_d="$cmake_d -D ILMBASE_VERSION=$ILMBASE_VERSION"

build_files/build_environment/patches/cmakelists_tbb.txt

@@ -1,5 +1,32 @@
-cmake_minimum_required (VERSION 2.8)
-project(tbb CXX)
+cmake_minimum_required(VERSION 3.1 FATAL_ERROR)
+
+if (POLICY CMP0048)
+  # cmake warns if loaded from a min-3.0-required parent dir, so silence the warning:
+  cmake_policy(SET CMP0048 NEW)
+endif()
+
+project (tbb CXX)
+
+include(CheckCXXCompilerFlag)
+include(CheckCXXSourceRuns)
+
+if(POLICY CMP0058)
+  cmake_policy(SET CMP0058 NEW)
+endif()
+
+if(POLICY CMP0068)
+  cmake_policy(SET CMP0068 NEW)
+endif()
+
+if (POLICY CMP0078)
+  # swig standard target names
+  cmake_policy(SET CMP0078 NEW)
+endif ()
+
+if (POLICY CMP0086)
+  # UseSWIG honors SWIG_MODULE_NAME via -module flag
+  cmake_policy(SET CMP0086 NEW)
+endif ()
 
 if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
   message(STATUS "Setting build type to 'Release' as none was specified.")
@@ -8,12 +35,36 @@ if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
     "MinSizeRel" "RelWithDebInfo")
 endif()
 
-include_directories(include src src/rml/include )
+if(NOT TBB_INSTALL_RUNTIME_DIR)
+  set(TBB_INSTALL_RUNTIME_DIR bin)
+endif()
+if(NOT TBB_INSTALL_LIBRARY_DIR)
+  set(TBB_INSTALL_LIBRARY_DIR lib)
+endif()
+if(NOT TBB_INSTALL_ARCHIVE_DIR)
+  set(TBB_INSTALL_ARCHIVE_DIR lib)
+endif()
+if(NOT TBB_INSTALL_INCLUDE_DIR)
+  set(TBB_INSTALL_INCLUDE_DIR include)
+endif()
+if(NOT TBB_CMAKE_PACKAGE_INSTALL_DIR)
+  set(TBB_CMAKE_PACKAGE_INSTALL_DIR lib/cmake/tbb)
+endif()
+
+include_directories(include src src/rml/include ${CMAKE_CURRENT_BINARY_DIR})
 
 option(TBB_BUILD_SHARED          "Build TBB shared library" ON)
 option(TBB_BUILD_STATIC          "Build TBB static library" ON)
 option(TBB_BUILD_TBBMALLOC       "Build TBB malloc library" ON)
 option(TBB_BUILD_TBBMALLOC_PROXY "Build TBB malloc proxy library" ON)
+option(TBB_BUILD_TESTS           "Build TBB tests and enable testing infrastructure" ON)
+option(TBB_NO_DATE               "Do not save the configure date in the version string" OFF)
+option(TBB_BUILD_PYTHON          "Build TBB Python bindings" OFF)
+option(TBB_SET_SOVERSION         "Set the SOVERSION (shared library build version suffix)?" OFF)
+
+# When this repository is part of a larger build system of a parent project
+# we may not want TBB to set up default installation targets
+option(TBB_INSTALL_TARGETS       "Include build targets for 'make install'" ON)
 
 if(APPLE)
   set(CMAKE_MACOSX_RPATH ON)
@@ -39,66 +90,143 @@ set(tbbmalloc_proxy_src
   src/tbbmalloc/proxy.cpp
   src/tbbmalloc/tbb_function_replacement.cpp)
 
-if (NOT APPLE)
-  add_definitions(-DDO_ITT_NOTIFY)
-else()
-  # Disable annoying "has no symbols" warnings
- set(CMAKE_C_ARCHIVE_CREATE   "<CMAKE_AR> Scr <TARGET> <LINK_FLAGS> <OBJECTS>")
- set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> Scr <TARGET> <LINK_FLAGS> <OBJECTS>")
- set(CMAKE_C_ARCHIVE_FINISH   "<CMAKE_RANLIB> -no_warning_for_no_symbols -c <TARGET>")
- set(CMAKE_CXX_ARCHIVE_FINISH "<CMAKE_RANLIB> -no_warning_for_no_symbols -c <TARGET>")
+add_library (tbb_interface INTERFACE)
+add_definitions(-DTBB_SUPPRESS_DEPRECATED_MESSAGES=1)
+
+if (CMAKE_SYSTEM_PROCESSOR MATCHES "(i386|x86_64)")
+  if (NOT APPLE AND NOT MINGW)
+    target_compile_definitions(tbb_interface INTERFACE DO_ITT_NOTIFY)
+  endif()
 endif()
 
+if (APPLE)
+  # Disable annoying "has no symbols" warnings
+  set(CMAKE_C_ARCHIVE_CREATE   "<CMAKE_AR> Scr <TARGET> <LINK_FLAGS> <OBJECTS>")
+  set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> Scr <TARGET> <LINK_FLAGS> <OBJECTS>")
+  set(CMAKE_C_ARCHIVE_FINISH   "<CMAKE_RANLIB> -no_warning_for_no_symbols -c <TARGET>")
+  set(CMAKE_CXX_ARCHIVE_FINISH "<CMAKE_RANLIB> -no_warning_for_no_symbols -c <TARGET>")
+endif()
+
+macro(CHECK_CXX_COMPILER_AND_LINKER_FLAGS _RESULT _CXX_FLAGS _LINKER_FLAGS)
+  set(CMAKE_REQUIRED_FLAGS ${_CXX_FLAGS})
+  set(CMAKE_REQUIRED_LIBRARIES ${_LINKER_FLAGS})
+  set(CMAKE_REQUIRED_QUIET TRUE)
+  check_cxx_source_runs("#include <iostream>\nint main(int argc, char **argv) { std::cout << \"test\"; return 0; }" ${_RESULT})
+  set(CMAKE_REQUIRED_FLAGS "")
+  set(CMAKE_REQUIRED_LIBRARIES "")
+endmacro()
+
+# Prefer libc++ in conjunction with Clang
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  if (CMAKE_CXX_FLAGS MATCHES "-stdlib=libc\\+\\+")
+    message(STATUS "TBB: using libc++.")
+  else()
+    CHECK_CXX_COMPILER_AND_LINKER_FLAGS(HAS_LIBCPP "-stdlib=libc++" "-stdlib=libc++")
+    if (HAS_LIBCPP)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++ -D_LIBCPP_VERSION")
+      set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -stdlib=libc++")
+      set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -stdlib=libc++")
+      message(STATUS "TBB: using libc++.")
+    else()
+      message(STATUS "TBB: NOT using libc++.")
+    endif()
+  endif()
+endif()
+
+set (CMAKE_CXX_STANDARD 11)
+
 if (UNIX)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -DUSE_PTHREAD")
-  if(NOT CMAKE_CXX_FLAGS MATCHES "-mno-rtm")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mrtm")
-  endif()
-  if (APPLE)
-    set(ARCH_PREFIX "mac")
-  else()
-    set(ARCH_PREFIX "lin")
-  endif()
-  if (CMAKE_SIZEOF_VOID_P EQUAL 8)
-    set(ARCH_PREFIX "${ARCH_PREFIX}64")
-  else()
-    set(ARCH_PREFIX "${ARCH_PREFIX}32")
-  endif()
-  set(ENABLE_RTTI "-frtti -fexceptions ")
-  set(DISABLE_RTTI "-fno-rtti -fno-exceptions ")
-elseif(WIN32)
-  cmake_minimum_required (VERSION 3.1)
-  enable_language(ASM_MASM)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /GS- /Zc:wchar_t /Zc:forScope /DUSE_WINTHREAD")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /D_CRT_SECURE_NO_DEPRECATE /D_WIN32_WINNT=0x0600 /volatile:iso")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4267 /wd4800 /wd4146 /wd4244 /wd4018")
+  target_compile_definitions(tbb_interface INTERFACE USE_PTHREAD)
 
-  if (CMAKE_SIZEOF_VOID_P EQUAL 8)
-    list(APPEND tbb_src src/tbb/intel64-masm/atomic_support.asm
-      src/tbb/intel64-masm/itsx.asm src/tbb/intel64-masm/intel64_misc.asm)
-    list(APPEND tbbmalloc_src src/tbb/intel64-masm/atomic_support.asm)
-    set(CMAKE_ASM_MASM_FLAGS "/DEM64T=1")
-    set(ARCH_PREFIX "win64")
-  else()
-    list(APPEND tbb_src src/tbb/ia32-masm/atomic_support.asm
-      src/tbb/ia32-masm/itsx.asm src/tbb/ia32-masm/lock_byte.asm)
-    list(APPEND tbbmalloc_src src/tbb/ia32-masm/atomic_support.asm)
-    set(ARCH_PREFIX "win32")
-  endif()
-  set(ENABLE_RTTI "/EHsc /GR ")
-  set(DISABLE_RTTI "/EHs- /GR- ")
+  check_cxx_compiler_flag ("-mrtm -Werror" SUPPORTS_MRTM)
+  if (SUPPORTS_MRTM)
+    target_compile_options(tbb_interface INTERFACE "-mrtm")
+  endif ()
+
+elseif(WIN32)
+  target_compile_definitions(tbb_interface INTERFACE USE_WINTHREAD _WIN32_WINNT=0x0600)
+  if (MSVC)
+    enable_language(ASM_MASM)
+    target_compile_options(tbb_interface INTERFACE /GS- /Zc:wchar_t /Zc:forScope)
+    check_cxx_compiler_flag ("/volatile:iso" SUPPORTS_VOLATILE_FLAG)
+    if (SUPPORTS_VOLATILE_FLAG)
+      target_compile_options(tbb_interface INTERFACE /volatile:iso)
+    endif ()
+    target_compile_options(tbb_interface INTERFACE $<$<COMPILE_LANGUAGE:CXX>:/wd4267 /wd4800 /wd4146 /wd4244 /wd4577 /wd4018>)
+    if (NOT CMAKE_SIZEOF_VOID_P)
+       message(FATAL_ERROR "'CMAKE_SIZEOF_VOID_P' is undefined. Please delete your build directory and rerun CMake again!")
+    endif()
+
+    if (CMAKE_SIZEOF_VOID_P EQUAL 8)
+      list(APPEND tbb_src src/tbb/intel64-masm/atomic_support.asm
+        src/tbb/intel64-masm/itsx.asm src/tbb/intel64-masm/intel64_misc.asm)
+      list(APPEND tbbmalloc_src src/tbb/intel64-masm/atomic_support.asm)
+      set(CMAKE_ASM_MASM_FLAGS "/DEM64T=1 ${CMAKE_ASM_MASM_FLAGS}")
+    else()
+      list(APPEND tbb_src src/tbb/ia32-masm/atomic_support.asm
+        src/tbb/ia32-masm/itsx.asm src/tbb/ia32-masm/lock_byte.asm)
+      # Enable SAFESEH feature for assembly (x86 builds only).
+      set(CMAKE_ASM_MASM_FLAGS "/safeseh ${CMAKE_ASM_MASM_FLAGS}")
+    endif()
+  elseif (MINGW)
+    target_compile_options(tbb_interface INTERFACE "-mthreads")
+  endif ()
 endif()
 
-if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-  include(CheckCXXCompilerFlag)
-  check_cxx_compiler_flag("-flifetime-dse=1" SUPPORTS_FLIFETIME)
-  if (SUPPORTS_FLIFETIME)
-    add_definitions(-flifetime-dse=1)
+if (MSVC)
+  set(ENABLE_RTTI "/EHsc /GR ")
+  set(DISABLE_RTTI "/EHs- /GR- ")
+elseif (UNIX)
+  set(ENABLE_RTTI "-frtti -fexceptions ")
+  set(DISABLE_RTTI "-fno-rtti -fno-exceptions ")
+endif ()
+
+##--------
+#   - Added TBB_USE_GLIBCXX_VERSION macro to specify the version of GNU
+#     libstdc++ when it cannot be properly recognized, e.g. when used
+#     with Clang on Linux* OS. Inspired by a contribution from David A.
+if (NOT TBB_USE_GLIBCXX_VERSION AND UNIX AND NOT APPLE)
+  if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+    # using Clang
+    string(REPLACE "." "0" TBB_USE_GLIBCXX_VERSION ${CMAKE_CXX_COMPILER_VERSION})
   endif()
 endif()
 
+if (TBB_USE_GLIBCXX_VERSION)
+  target_compile_definitions(tbb_interface INTERFACE TBB_USE_GLIBCXX_VERSION=${TBB_USE_GLIBCXX_VERSION})
+endif()
+
+##-------
+
+if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+   check_cxx_compiler_flag ("-flifetime-dse=1" SUPPORTS_FLIFETIME)
+   if (SUPPORTS_FLIFETIME)
+     target_compile_options(tbb_interface INTERFACE -flifetime-dse=1)
+   endif()
+endif()
+
 # Linker export definitions
-if (WIN32)
+if (APPLE)
+  set (ARCH_PREFIX "mac")
+elseif(WIN32)
+  set (ARCH_PREFIX "win")
+else()
+  set (ARCH_PREFIX "lin")
+endif()
+
+if (CMAKE_SIZEOF_VOID_P EQUAL 8)
+  set(ARCH_PREFIX "${ARCH_PREFIX}64")
+else()
+  set(ARCH_PREFIX "${ARCH_PREFIX}32")
+endif()
+
+if (MINGW)
+  set (ARCH_PREFIX "${ARCH_PREFIX}-gcc")
+  # there's no win32-gcc-tbb-export.def, use lin32-tbb-export.def
+  execute_process (COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/src/tbb/lin32-tbb-export.def ${CMAKE_CURRENT_SOURCE_DIR}/src/tbb/win32-gcc-tbb-export.def)
+endif()
+
+if (MSVC)
   add_custom_command(OUTPUT tbb.def
     COMMAND ${CMAKE_CXX_COMPILER} /TC /EP ${CMAKE_CURRENT_SOURCE_DIR}/src/tbb/${ARCH_PREFIX}-tbb-export.def  -I ${CMAKE_CURRENT_SOURCE_DIR}/include > tbb.def
     MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/src/tbb/${ARCH_PREFIX}-tbb-export.def
@@ -110,18 +238,15 @@ if (WIN32)
     MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/src/tbbmalloc/${ARCH_PREFIX}-tbbmalloc-export.def
     COMMENT "Preprocessing tbbmalloc.def"
   )
-  list(APPEND tbb_src ${CMAKE_CURRENT_SOURCE_DIR}/src/tbb/tbb_resource.rc)
-  list(APPEND tbbmalloc_src ${CMAKE_CURRENT_SOURCE_DIR}/src/tbbmalloc/tbbmalloc.rc)
-  list(APPEND tbbmalloc_proxy_src ${CMAKE_CURRENT_SOURCE_DIR}/src/tbbmalloc/tbbmalloc.rc)
 else()
   add_custom_command(OUTPUT tbb.def
-    COMMAND ${CMAKE_CXX_COMPILER} -xc++ -E ${CMAKE_CURRENT_SOURCE_DIR}/src/tbb/${ARCH_PREFIX}-tbb-export.def  -I ${CMAKE_CURRENT_SOURCE_DIR}/include -o tbb.def
+    COMMAND ${CMAKE_CXX_COMPILER} -xc++ -std=c++11 -E ${CMAKE_CURRENT_SOURCE_DIR}/src/tbb/${ARCH_PREFIX}-tbb-export.def  -I ${CMAKE_CURRENT_SOURCE_DIR}/include -o tbb.def
     MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/src/tbb/${ARCH_PREFIX}-tbb-export.def
     COMMENT "Preprocessing tbb.def"
   )
 
   add_custom_command(OUTPUT tbbmalloc.def
-    COMMAND ${CMAKE_CXX_COMPILER} -xc++ -E ${CMAKE_CURRENT_SOURCE_DIR}/src/tbbmalloc/${ARCH_PREFIX}-tbbmalloc-export.def  -I ${CMAKE_CURRENT_SOURCE_DIR}/include -o   tbbmalloc.def
+    COMMAND ${CMAKE_CXX_COMPILER} -xc++ -std=c++11 -E ${CMAKE_CURRENT_SOURCE_DIR}/src/tbbmalloc/${ARCH_PREFIX}-tbbmalloc-export.def  -I ${CMAKE_CURRENT_SOURCE_DIR}/include -o   tbbmalloc.def
     MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/src/tbbmalloc/${ARCH_PREFIX}-tbbmalloc-export.def
     COMMENT "Preprocessing tbbmalloc.def"
   )
@@ -132,34 +257,80 @@ add_custom_target(tbb_def_files DEPENDS tbb.def tbbmalloc.def)
 # TBB library
 if (TBB_BUILD_STATIC)
   add_library(tbb_static STATIC ${tbb_src})
-  set_property(TARGET tbb_static APPEND PROPERTY COMPILE_DEFINITIONS "__TBB_BUILD=1")
-  set_property(TARGET tbb_static APPEND PROPERTY COMPILE_DEFINITIONS "__TBB_SOURCE_DIRECTLY_INCLUDED=1")
+  target_link_libraries(tbb_static PRIVATE tbb_interface)
+  target_include_directories(tbb_static INTERFACE "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>" "$<INSTALL_INTERFACE:${TBB_INSTALL_INCLUDE_DIR}>")
   set_property(TARGET tbb_static APPEND_STRING PROPERTY COMPILE_FLAGS ${ENABLE_RTTI})
-  install(TARGETS tbb_static ARCHIVE DESTINATION lib)
+  if (TBB_INSTALL_TARGETS)
+    install(TARGETS tbb_static ARCHIVE DESTINATION ${TBB_INSTALL_ARCHIVE_DIR})
+  endif()
+
+  target_compile_definitions(tbb_static
+    PRIVATE
+      -D__TBB_BUILD=1
+      -D__TBB_DYNAMIC_LOAD_ENABLED=0
+      -D__TBB_SOURCE_DIRECTLY_INCLUDED=1)
+
+  if (MSVC)
+    target_compile_definitions(tbb_static
+      PUBLIC -D__TBB_NO_IMPLICIT_LINKAGE=1
+      PRIVATE -D_CRT_SECURE_NO_WARNINGS)
+  endif()
+
+  if (UNIX AND NOT APPLE)
+    target_link_libraries(tbb_static PUBLIC pthread dl)
+  endif()
 endif()
 
 if (TBB_BUILD_SHARED)
   add_library(tbb SHARED ${tbb_src})
-  set_property(TARGET tbb APPEND PROPERTY COMPILE_DEFINITIONS "__TBB_BUILD=1")
+  target_link_libraries(tbb PRIVATE tbb_interface)
+  target_include_directories(tbb INTERFACE "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>" "$<INSTALL_INTERFACE:${TBB_INSTALL_INCLUDE_DIR}>")
   set_property(TARGET tbb APPEND_STRING PROPERTY COMPILE_FLAGS ${ENABLE_RTTI})
-  add_dependencies(tbb tbb_def_files)
-  if (APPLE)
-    set_property(TARGET tbb APPEND PROPERTY LINK_FLAGS "-Wl,-exported_symbols_list,${CMAKE_CURRENT_BINARY_DIR}/tbb.def")
-  elseif(UNIX)
-    set_property(TARGET tbb APPEND PROPERTY LINK_FLAGS "-Wl,-version-script,${CMAKE_CURRENT_BINARY_DIR}/tbb.def")
-  elseif(WIN32)
-    set_property(TARGET tbb APPEND PROPERTY LINK_FLAGS "/DEF:${CMAKE_CURRENT_BINARY_DIR}/tbb.def")
-    
+  if (TBB_SET_SOVERSION)
+    set_property(TARGET tbb PROPERTY SOVERSION 2)
+  endif ()
+
+  target_compile_definitions(tbb
+    PRIVATE -D__TBB_BUILD=1)
+
+  if (MSVC)
+    target_compile_definitions(tbb
+      PUBLIC -D__TBB_NO_IMPLICIT_LINKAGE=1
+      PRIVATE -D_CRT_SECURE_NO_WARNINGS)
   endif()
-  install(TARGETS tbb DESTINATION lib)
-  if(WIN32)
-    set_target_properties(tbb PROPERTIES OUTPUT_NAME "tbb$<$<CONFIG:Debug>:_debug>")
+
+  add_dependencies(tbb tbb_def_files)
+
+  if (APPLE)
+    set_property(TARGET tbb APPEND PROPERTY LINK_FLAGS "-Wl,-exported_symbols_list,\"${CMAKE_CURRENT_BINARY_DIR}/tbb.def\"")
+  elseif (MSVC)
+    set_property(TARGET tbb APPEND PROPERTY LINK_FLAGS "/DEF:\"${CMAKE_CURRENT_BINARY_DIR}/tbb.def\"")
+  else ()
+    set_property(TARGET tbb APPEND PROPERTY LINK_FLAGS "-Wl,-version-script,\"${CMAKE_CURRENT_BINARY_DIR}/tbb.def\"")
+  endif()
+
+  if (TBB_INSTALL_TARGETS)
+    install(TARGETS tbb EXPORT TBB
+            LIBRARY DESTINATION ${TBB_INSTALL_LIBRARY_DIR}
+            ARCHIVE DESTINATION ${TBB_INSTALL_ARCHIVE_DIR}
+            RUNTIME DESTINATION ${TBB_INSTALL_RUNTIME_DIR})
+    if (MSVC)
+      install(FILES $<TARGET_PDB_FILE:tbb> DESTINATION ${TBB_INSTALL_RUNTIME_DIR} OPTIONAL)
+    endif()
+  endif()
+
+  if (UNIX AND NOT APPLE)
+    target_link_libraries(tbb PUBLIC pthread dl)
   endif()
 endif()
 
-if(CMAKE_COMPILER_IS_GNUCC)
+
+if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
   # Quench a warning on GCC
   set_source_files_properties(${CMAKE_CURRENT_SOURCE_DIR}/src/tbb/governor.cpp COMPILE_FLAGS "-Wno-missing-field-initializers ")
+elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+  # Quench a warning on Clang
+  set_source_files_properties(${CMAKE_CURRENT_SOURCE_DIR}/src/tbb/itt_notify.cpp COMPILE_FLAGS "-Wno-varargs ")
 elseif(MSVC)
   # Quench a warning on MSVC
   set_source_files_properties(${CMAKE_CURRENT_SOURCE_DIR}/src/tbb/scheduler.cpp COMPILE_FLAGS "/wd4458 ")
@@ -169,24 +340,50 @@ if(TBB_BUILD_TBBMALLOC)
   # TBB malloc library
   if (TBB_BUILD_STATIC)
     add_library(tbbmalloc_static STATIC ${tbbmalloc_static_src})
+    target_link_libraries(tbbmalloc_static PRIVATE tbb_interface)
     set_property(TARGET tbbmalloc_static APPEND PROPERTY COMPILE_DEFINITIONS "__TBBMALLOC_BUILD=1")
+    set_property(TARGET tbbmalloc_static APPEND PROPERTY COMPILE_DEFINITIONS "__TBB_DYNAMIC_LOAD_ENABLED=0")
+    set_property(TARGET tbbmalloc_static APPEND PROPERTY COMPILE_DEFINITIONS "__TBB_SOURCE_DIRECTLY_INCLUDED=1")
     set_property(TARGET tbbmalloc_static APPEND_STRING PROPERTY COMPILE_FLAGS ${DISABLE_RTTI})
-    install(TARGETS tbbmalloc_static ARCHIVE DESTINATION lib)
+    if (MSVC)
+      target_compile_definitions(tbbmalloc_static PUBLIC __TBB_NO_IMPLICIT_LINKAGE=1 __TBBMALLOC_NO_IMPLICIT_LINKAGE=1)
+    endif()
+    if (TBB_INSTALL_TARGETS)
+      install(TARGETS tbbmalloc_static ARCHIVE DESTINATION ${TBB_INSTALL_ARCHIVE_DIR})
+    endif()
   endif()
 
   if (TBB_BUILD_SHARED)
     add_library(tbbmalloc SHARED ${tbbmalloc_src})
+    target_link_libraries(tbbmalloc PRIVATE tbb_interface)
     set_property(TARGET tbbmalloc APPEND PROPERTY COMPILE_DEFINITIONS "__TBBMALLOC_BUILD=1")
     set_property(TARGET tbbmalloc APPEND_STRING PROPERTY COMPILE_FLAGS ${DISABLE_RTTI})
+    if (TBB_SET_SOVERSION)
+      set_property(TARGET tbbmalloc PROPERTY SOVERSION 2)
+    endif ()
     add_dependencies(tbbmalloc tbb_def_files)
     if (APPLE)
-      set_property(TARGET tbbmalloc APPEND PROPERTY LINK_FLAGS "-Wl,-exported_symbols_list,${CMAKE_CURRENT_BINARY_DIR}/tbbmalloc.def")
-    elseif(UNIX)
-      set_property(TARGET tbbmalloc APPEND PROPERTY LINK_FLAGS "-Wl,-version-script,${CMAKE_CURRENT_BINARY_DIR}/tbbmalloc.def")
-    elseif(WIN32)
-      set_property(TARGET tbbmalloc APPEND PROPERTY LINK_FLAGS "/DEF:${CMAKE_CURRENT_BINARY_DIR}/tbbmalloc.def")
+      set_property(TARGET tbbmalloc APPEND PROPERTY LINK_FLAGS "-Wl,-exported_symbols_list,\"${CMAKE_CURRENT_BINARY_DIR}/tbbmalloc.def\"")
+    elseif (MSVC)
+      set_property(TARGET tbbmalloc APPEND PROPERTY LINK_FLAGS "/DEF:\"${CMAKE_CURRENT_BINARY_DIR}/tbbmalloc.def\"")
+    else ()
+      set_property(TARGET tbbmalloc APPEND PROPERTY LINK_FLAGS "-Wl,-version-script,\"${CMAKE_CURRENT_BINARY_DIR}/tbbmalloc.def\"")
+    endif()
+    if (MSVC)
+      target_compile_definitions(tbbmalloc PUBLIC __TBB_NO_IMPLICIT_LINKAGE=1 __TBBMALLOC_NO_IMPLICIT_LINKAGE=1)
+    endif()
+    if (TBB_INSTALL_TARGETS)
+      install(TARGETS tbbmalloc EXPORT TBB
+              LIBRARY DESTINATION ${TBB_INSTALL_LIBRARY_DIR}
+              ARCHIVE DESTINATION ${TBB_INSTALL_ARCHIVE_DIR}
+              RUNTIME DESTINATION ${TBB_INSTALL_RUNTIME_DIR})
+      if (MSVC)
+        install(FILES $<TARGET_PDB_FILE:tbbmalloc> DESTINATION ${TBB_INSTALL_RUNTIME_DIR} OPTIONAL)
+      endif()
+    endif()
+    if (UNIX AND NOT APPLE)
+      target_link_libraries(tbbmalloc PUBLIC pthread dl)
     endif()
-    install(TARGETS tbbmalloc DESTINATION lib)
   endif()
 endif()
 
@@ -194,19 +391,298 @@ if(TBB_BUILD_TBBMALLOC_PROXY)
   # TBB malloc proxy library
   if (TBB_BUILD_STATIC)
     add_library(tbbmalloc_proxy_static STATIC ${tbbmalloc_proxy_src})
+    target_link_libraries(tbbmalloc_proxy_static PRIVATE tbb_interface)
     set_property(TARGET tbbmalloc_proxy_static APPEND PROPERTY COMPILE_DEFINITIONS "__TBBMALLOC_BUILD=1")
+    set_property(TARGET tbbmalloc_proxy_static APPEND PROPERTY COMPILE_DEFINITIONS "__TBB_DYNAMIC_LOAD_ENABLED=0")
+    set_property(TARGET tbbmalloc_proxy_static APPEND PROPERTY COMPILE_DEFINITIONS "__TBB_SOURCE_DIRECTLY_INCLUDED=1")
     set_property(TARGET tbbmalloc_proxy_static APPEND_STRING PROPERTY COMPILE_FLAGS ${DISABLE_RTTI})
-    link_libraries(tbbmalloc_proxy_static tbbmalloc)
-    install(TARGETS tbbmalloc_proxy_static ARCHIVE DESTINATION lib)
+    if (TBB_INSTALL_TARGETS)
+      install(TARGETS tbbmalloc_proxy_static ARCHIVE DESTINATION ${TBB_INSTALL_ARCHIVE_DIR})
+    endif()
   endif()
 
   if (TBB_BUILD_SHARED)
     add_library(tbbmalloc_proxy SHARED ${tbbmalloc_proxy_src})
+    target_link_libraries(tbbmalloc_proxy PRIVATE tbb_interface)
     set_property(TARGET tbbmalloc_proxy APPEND PROPERTY COMPILE_DEFINITIONS "__TBBMALLOC_BUILD=1")
     set_property(TARGET tbbmalloc_proxy APPEND_STRING PROPERTY COMPILE_FLAGS ${DISABLE_RTTI})
-    target_link_libraries(tbbmalloc_proxy tbbmalloc)
-    install(TARGETS tbbmalloc_proxy DESTINATION lib)
+    if (TBB_SET_SOVERSION)
+      set_property(TARGET tbbmalloc_proxy PROPERTY SOVERSION 2)
+    endif ()
+    target_link_libraries(tbbmalloc_proxy PUBLIC tbbmalloc)
+    if (TBB_INSTALL_TARGETS)
+      install(TARGETS tbbmalloc_proxy EXPORT TBB
+              LIBRARY DESTINATION ${TBB_INSTALL_LIBRARY_DIR}
+              ARCHIVE DESTINATION ${TBB_INSTALL_ARCHIVE_DIR}
+              RUNTIME DESTINATION ${TBB_INSTALL_RUNTIME_DIR})
+      if (MSVC)
+        install(FILES $<TARGET_PDB_FILE:tbbmalloc_proxy> DESTINATION ${TBB_INSTALL_RUNTIME_DIR} OPTIONAL)
+      endif()
+    endif()
+    if (UNIX AND NOT APPLE)
+      target_link_libraries(tbbmalloc_proxy PUBLIC pthread dl)
+    endif()
   endif()
 endif()
 
-install(DIRECTORY include/tbb DESTINATION include)
+if (TBB_INSTALL_TARGETS)
+  install(DIRECTORY include/tbb DESTINATION ${TBB_INSTALL_INCLUDE_DIR})
+  if (TBB_BUILD_SHARED)
+    install(EXPORT TBB DESTINATION ${TBB_CMAKE_PACKAGE_INSTALL_DIR} NAMESPACE TBB:: FILE TBBConfig.cmake)
+  endif()
+endif()
+
+# version file
+if (TBB_INSTALL_TARGETS)
+  set (_VERSION_FILE ${CMAKE_CURRENT_SOURCE_DIR}/include/tbb/tbb_stddef.h)
+  file (STRINGS ${_VERSION_FILE} _VERSION_MAJOR_STRING REGEX ".*define[ ]+TBB_VERSION_MAJOR[ ]+[0-9]+.*")
+  file (STRINGS ${_VERSION_FILE} _VERSION_MINOR_STRING REGEX ".*define[ ]+TBB_VERSION_MINOR[ ]+[0-9]+.*")
+  string (REGEX REPLACE ".*TBB_VERSION_MAJOR[ ]+([0-9]+)" "\\1" TBB_MAJOR_VERSION ${_VERSION_MAJOR_STRING})
+  string (REGEX REPLACE ".*TBB_VERSION_MINOR[ ]+([0-9]+)" "\\1" TBB_MINOR_VERSION ${_VERSION_MINOR_STRING})
+  set (TBB_VERSION_STRING "${TBB_MAJOR_VERSION}.${TBB_MINOR_VERSION}")
+  include (CMakePackageConfigHelpers)
+  write_basic_package_version_file (TBBConfigVersion.cmake VERSION "${TBB_VERSION_STRING}" COMPATIBILITY AnyNewerVersion)
+  install (FILES ${CMAKE_CURRENT_BINARY_DIR}/TBBConfigVersion.cmake DESTINATION "${TBB_CMAKE_PACKAGE_INSTALL_DIR}")
+endif()
+
+# version_string.ver
+if (UNIX AND NOT TBB_NO_DATE)
+  execute_process (COMMAND date "+%a, %d %b %Y %H:%M:%S %z"
+                   OUTPUT_VARIABLE _configure_date
+                   OUTPUT_STRIP_TRAILING_WHITESPACE)
+elseif (WIN32 AND NOT TBB_NO_DATE)
+  execute_process (COMMAND cmd " /C date /T"
+                   OUTPUT_VARIABLE _configure_date
+                   OUTPUT_STRIP_TRAILING_WHITESPACE)
+else ()
+  set (_configure_date "Unknown")
+endif()
+set (TBB_CONFIG_DATE "${_configure_date}" CACHE STRING "First time that TBB was configured")
+set (_configure_date "${TBB_CONFIG_DATE}")
+include_directories (${CMAKE_BINARY_DIR})
+configure_file (build/version_string.ver.in version_string.ver @ONLY)
+
+if (TBB_BUILD_TESTS)
+  enable_language (C)
+  enable_testing ()
+
+  find_library (LIBRT_LIBRARIES rt)
+  find_library (LIDL_LIBRARIES dl)
+  find_package (Threads)
+  if (NOT APPLE)
+    find_package (OpenMP)
+  endif()
+
+  macro (tbb_add_test testname)
+    set (full_testname tbb_test_${testname})
+    add_executable (${full_testname} src/test/test_${testname}.cpp)
+    target_link_libraries(${full_testname} PRIVATE tbb_interface)
+    if (TBB_BUILD_SHARED)
+      target_link_libraries (${full_testname} PRIVATE tbb tbbmalloc)
+      target_compile_definitions (${full_testname} PRIVATE __TBB_LIB_NAME=tbb)
+    else ()
+      target_link_libraries (${full_testname} PRIVATE tbb_static tbbmalloc_static)
+      target_compile_definitions (${full_testname} PRIVATE __TBB_LIB_NAME=tbb_static)
+    endif ()
+    if (LIBRT_LIBRARIES)
+      target_link_libraries (${full_testname} PRIVATE ${LIBRT_LIBRARIES})
+    endif ()
+    if (LIDL_LIBRARIES)
+      target_link_libraries (${full_testname} PRIVATE ${LIDL_LIBRARIES})
+    endif ()
+    if (Threads_FOUND)
+      target_link_libraries (${full_testname} PRIVATE ${CMAKE_THREAD_LIBS_INIT})
+    endif ()
+    if (OPENMP_FOUND AND "${testname}" MATCHES "openmp")
+      set_target_properties (${full_testname} PROPERTIES COMPILE_FLAGS "${OpenMP_CXX_FLAGS}")
+      set_target_properties (${full_testname} PROPERTIES LINK_FLAGS "${OpenMP_CXX_FLAGS}")
+    endif()
+    if (MINGW)
+      target_link_libraries (${full_testname} PRIVATE psapi)
+    endif ()
+    add_test (NAME ${full_testname} COMMAND ${full_testname})
+  endmacro ()
+
+  tbb_add_test (aggregator)
+  tbb_add_test (aligned_space)
+  tbb_add_test (assembly)
+  if (NOT WIN32)
+    tbb_add_test (async_msg) # msvc64/debug timeouts
+  endif()
+  tbb_add_test (async_node)
+  # tbb_add_test (atomic) # msvc64/debug timeouts: Compile-time initialization fails for static tbb::atomic variables
+  tbb_add_test (blocked_range2d)
+  tbb_add_test (blocked_range3d)
+  tbb_add_test (blocked_range)
+  tbb_add_test (broadcast_node)
+  tbb_add_test (buffer_node)
+  tbb_add_test (cache_aligned_allocator)
+  if (NOT WIN32)
+    tbb_add_test (cache_aligned_allocator_STL)
+  endif()
+  tbb_add_test (cilk_dynamic_load)
+  tbb_add_test (cilk_interop)
+  tbb_add_test (combinable)
+  tbb_add_test (composite_node)
+  tbb_add_test (concurrent_hash_map)
+  tbb_add_test (concurrent_lru_cache)
+  # tbb_add_test (concurrent_monitor) # too long
+  # tbb_add_test (concurrent_priority_queue)
+  if (NOT WIN32)
+    tbb_add_test (concurrent_queue) # msvc64/debug timeouts
+  endif()
+  # tbb_add_test (concurrent_queue_whitebox)
+  tbb_add_test (concurrent_unordered_map)
+  # tbb_add_test (concurrent_unordered_set)
+  tbb_add_test (concurrent_vector)
+  tbb_add_test (continue_node)
+  tbb_add_test (critical_section)
+  tbb_add_test (dynamic_link)
+  # tbb_add_test (eh_algorithms)
+  tbb_add_test (eh_flow_graph)
+  # tbb_add_test (eh_tasks)
+  tbb_add_test (enumerable_thread_specific)
+  tbb_add_test (examples_common_utility)
+  # tbb_add_test (fast_random)
+  tbb_add_test (flow_graph)
+  tbb_add_test (flow_graph_whitebox)
+  # tbb_add_test (fp) # mingw: harness_fp.h:66, assertion !checkConsistency || (ctl.mxcsr & SSE_RND_MODE_MASK) >> 3 == (ctl.x87cw & FE_RND_MODE_MASK): failed
+  # tbb_add_test (function_node) # mingw:random timeout
+  # tbb_add_test (global_control)
+  # tbb_add_test (global_control_whitebox)
+  tbb_add_test (halt)
+  tbb_add_test (handle_perror)
+  # tbb_add_test (hw_concurrency)
+  tbb_add_test (indexer_node)
+  tbb_add_test (inits_loop)
+  tbb_add_test (intrusive_list)
+  tbb_add_test (ittnotify)
+  # tbb_add_test (join_node) #msvc/64: fatal error C1128: number of sections exceeded object file format limit: compile with /bigob
+  tbb_add_test (lambda)
+  tbb_add_test (limiter_node)
+  # tbb_add_test (malloc_atexit)
+  # tbb_add_test (malloc_compliance) #mingw: Limits should be decreased for the test to work
+  tbb_add_test (malloc_init_shutdown)
+  # tbb_add_test (malloc_lib_unload)
+  # tbb_add_test (malloc_overload)
+  tbb_add_test (malloc_pools)
+  tbb_add_test (malloc_regression)
+  # tbb_add_test (malloc_used_by_lib)
+  # tbb_add_test (malloc_whitebox)
+  tbb_add_test (model_plugin)
+  # tbb_add_test (multifunction_node) # too long
+  tbb_add_test (mutex)
+  tbb_add_test (mutex_native_threads)
+  # tbb_add_test (opencl_node)
+  if (OPENMP_FOUND)
+    tbb_add_test (openmp)
+  endif ()
+  tbb_add_test (overwrite_node)
+  # tbb_add_test (parallel_do)
+  # This seems to fail on CI platforms (AppVeyor/Travis), perhaps because the VM exposes just 1 core?
+  tbb_add_test (parallel_for)
+  tbb_add_test (parallel_for_each)
+  tbb_add_test (parallel_for_vectorization)
+  tbb_add_test (parallel_invoke)
+  tbb_add_test (parallel_pipeline)
+  tbb_add_test (parallel_reduce)
+  tbb_add_test (parallel_scan)
+  tbb_add_test (parallel_sort)
+  tbb_add_test (parallel_while)
+  # tbb_add_test (partitioner_whitebox) # too long
+  tbb_add_test (pipeline)
+  # tbb_add_test (pipeline_with_tbf) # takes forever on appveyor
+  tbb_add_test (priority_queue_node)
+  tbb_add_test (queue_node)
+  tbb_add_test (reader_writer_lock)
+  # tbb_add_test (runtime_loader) # LINK : fatal error LNK1104: cannot open file 'tbbproxy.lib' [C:\projects\tbb\test_runtime_loader.vcxproj]
+  tbb_add_test (rwm_upgrade_downgrade)
+  # tbb_add_test (ScalableAllocator)
+  if (NOT WIN32)
+    tbb_add_test (ScalableAllocator_STL)
+  endif()
+  tbb_add_test (semaphore)
+  # tbb_add_test (sequencer_node) # msvc: timeout
+  tbb_add_test (source_node)
+  tbb_add_test (split_node)
+  tbb_add_test (static_assert)
+  tbb_add_test (std_thread)
+  tbb_add_test (tagged_msg)
+  # tbb_add_test (task_arena) # LINK : fatal error LNK1104: cannot open file '__TBB_LIB_NAME.lib' [C:\projects\tbb\test_task_arena.vcxproj]
+  # tbb_add_test (task_assertions)
+  tbb_add_test (task_auto_init)
+  tbb_add_test (task)
+  # tbb_add_test (task_enqueue) # too long
+  tbb_add_test (task_group)
+  # tbb_add_test (task_leaks)
+  # tbb_add_test (task_priority)
+  # tbb_add_test (task_scheduler_init) # msvc: test_task_scheduler_init.cpp:68, assertion !test_mandatory_parallelism || Harness::CanReachConcurrencyLevel(threads): failed
+  tbb_add_test (task_scheduler_observer)
+  tbb_add_test (task_steal_limit)
+  tbb_add_test (tbb_condition_variable)
+  tbb_add_test (tbb_fork)
+  # tbb_add_test (tbb_header)
+  tbb_add_test (tbb_thread)
+  # tbb_add_test (tbb_version)
+  tbb_add_test (tick_count)
+  tbb_add_test (tuple)
+  tbb_add_test (write_once_node)
+  tbb_add_test (yield)
+endif ()
+
+if (TBB_BUILD_PYTHON)
+  find_package(PythonInterp)
+  find_package(PythonLibs ${PYTHON_VERSION_STRING} EXACT)
+  find_package(SWIG 3)
+  if (PythonLibs_FOUND AND SWIG_FOUND AND TBB_BUILD_SHARED)
+    include (${SWIG_USE_FILE})
+    set_source_files_properties (python/tbb/api.i PROPERTIES CPLUSPLUS ON)
+    set (CMAKE_SWIG_FLAGS "-threads")
+
+    # swig_add_module is deprecated
+    if (CMAKE_VERSION VERSION_LESS 3.8)
+      swig_add_module (api python python/tbb/api.i)
+    else ()
+      swig_add_library (api LANGUAGE python SOURCES python/tbb/api.i)
+    endif ()
+
+    # UseSWIG generates now standard target names
+    if (CMAKE_VERSION VERSION_LESS 3.13)
+      set (module_target ${SWIG_MODULE_api_REAL_NAME})
+    else ()
+      set (module_target api)
+    endif ()
+
+    target_include_directories(${module_target} PRIVATE ${PYTHON_INCLUDE_DIRS})
+    target_link_libraries(${module_target} PRIVATE tbb)
+    if(WIN32)
+      target_link_libraries(${module_target} ${PYTHON_LIBRARIES})
+    elseif(APPLE)
+      set_target_properties(${module_target} PROPERTIES LINK_FLAGS "-undefined dynamic_lookup")
+    endif()
+
+    if (WIN32)
+      set (PYTHON_SITE_PACKAGES Lib/site-packages)
+    else ()
+      set (PYTHON_SITE_PACKAGES lib/python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}/site-packages)
+    endif ()
+    if (TBB_INSTALL_TARGETS)
+      install(FILES python/TBB.py
+              DESTINATION ${PYTHON_SITE_PACKAGES})
+      install(FILES python/tbb/__init__.py python/tbb/pool.py python/tbb/test.py python/tbb/__main__.py ${CMAKE_CURRENT_BINARY_DIR}/api.py
+              DESTINATION ${PYTHON_SITE_PACKAGES}/tbb)
+      install(TARGETS ${module_target}
+              DESTINATION ${PYTHON_SITE_PACKAGES}/tbb)
+    endif()
+
+    if(UNIX AND NOT APPLE)
+      add_library(irml SHARED python/rml/ipc_server.cpp python/rml/ipc_utils.cpp src/tbb/cache_aligned_allocator.cpp src/tbb/dynamic_link.cpp src/tbb/tbb_misc_ex.cpp src/tbb/tbb_misc.cpp)
+      target_compile_definitions(irml PRIVATE DO_ITT_NOTIFY=0 USE_PTHREAD=1)
+      target_link_libraries(irml PRIVATE tbb)
+      set_target_properties(irml PROPERTIES VERSION 1)
+      if (TBB_INSTALL_TARGETS)
+        install(TARGETS irml DESTINATION ${TBB_INSTALL_LIBRARY_DIR})
+      endif()
+    endif ()
+  endif ()
+endif ()

build_files/build_environment/patches/tbb.diff

@@ -10,4 +10,15 @@ index 7a8d06a0..886699d8 100644
 +    #if (__cplusplus >= 201402L && (!defined(_MSC_VER) || _MSC_VER >= 1920))
          #define __TBB_DEPRECATED [[deprecated]]
          #define __TBB_DEPRECATED_MSG(msg) [[deprecated(msg)]]
-     #elif _MSC_VER
+     #elif _MSC_VER
+--- a/src/tbb/tools_api/ittnotify_config.h
++++ b/src/tbb/tools_api/ittnotify_config.h
+@@ -162,7 +162,7 @@
+ #    define ITT_ARCH ITT_ARCH_IA32E
+ #  elif defined _M_IA64 || defined __ia64__
+ #    define ITT_ARCH ITT_ARCH_IA64
+-#  elif defined _M_ARM || defined __arm__
++#  elif defined _M_ARM || defined __arm__ || defined __aarch64__
+ #    define ITT_ARCH ITT_ARCH_ARM
+ #  elif defined __powerpc64__
+ #    define ITT_ARCH ITT_ARCH_PPC64

build_files/build_environment/patches/theora.diff

@@ -4,7 +4,7 @@
  	# Some are omitted here because they have special meanings below.
  	1750a | 580 \
  	| a29k \
-+    | aarch64 \
++	| aarch64 \
  	| alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
  	| alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
  	| arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr \
@@ -12,7 +12,7 @@
  	# Recognize the basic CPU types with company name.
  	580-* \
  	| a29k-* \
-+    | aarch64-* \
++	| aarch64-* \
  	| alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \
  	| alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \
  	| alphapca5[67]-* | alpha64pca5[67]-* | arc-* \

build_files/build_environment/patches/usd.diff

@@ -53,3 +53,147 @@ diff -ru USD-20.11/pxr/base/tf/pxrLZ4/lz4.cpp external_usd/pxr/base/tf/pxrLZ4/lz
  
  /*-******************************
  *  Compression functions
+
+From 442d087962f762deeb8b6e49a0955753fcf9aeb9 Mon Sep 17 00:00:00 2001
+From: Tsahi Zidenberg <tsahee@amazon.com>
+Date: Sun, 15 Nov 2020 15:18:24 +0000
+Subject: [PATCH 1/2] stackTrace: support aarch64/linux
+
+stacktrace calls syscall directly via assembler. Create compatible
+aarch64 code.
+---
+ pxr/base/arch/stackTrace.cpp | 30 ++++++++++++++++++++++++------
+ 1 file changed, 24 insertions(+), 6 deletions(-)
+
+diff --git a/pxr/base/arch/stackTrace.cpp b/pxr/base/arch/stackTrace.cpp
+index dcc1dfd46..c11aabeb1 100644
+--- a/pxr/base/arch/stackTrace.cpp
++++ b/pxr/base/arch/stackTrace.cpp
+@@ -583,7 +583,6 @@ nonLockingLinux__execve (const char *file,
+                          char *const argv[],
+                          char *const envp[])
+ {
+-#if defined(ARCH_BITS_64)
+     /*
+      * We make a direct system call here, because we can't find an
+      * execve which corresponds with the non-locking fork we call
+@@ -594,7 +593,27 @@ nonLockingLinux__execve (const char *file,
+      * hangs in a threaded app.  (We use the non-locking fork to get
+      * around problems with forking when we have had memory
+      * corruption.)  whew.
+-     *
++     */
++
++    unsigned long result;
++
++#if defined (__aarch64__)
++    {
++        register long __file_result asm ("x0") = (long)file;
++        register char* const* __argv asm ("x1") = argv;
++        register char* const* __envp asm ("x2") = envp;
++        register long __num_execve asm ("x8") = 221;
++        __asm__ __volatile__ (
++            "svc 0"
++            : "=r" (__file_result)
++            : "r"(__num_execve), "r" (__file_result), "r" (__argv), "r" (__envp)
++            : "memory"
++        );
++        result = __file_result;
++    }
++#elif defined(ARCH_CPU_INTEL) && defined(ARCH_BITS_64)
++
++    /*
+      * %rdi, %rsi, %rdx, %rcx, %r8, %r9 are args 0-5
+      * syscall clobbers %rcx and %r11
+      *
+@@ -603,7 +622,6 @@ nonLockingLinux__execve (const char *file,
+      * constraints to gcc.
+      */
+ 
+-    unsigned long result;
+     __asm__ __volatile__ (
+         "mov    %0, %%rdi    \n\t"
+         "mov    %%rcx, %%rsi \n\t"
+@@ -614,6 +632,9 @@ nonLockingLinux__execve (const char *file,
+         : "0" (file), "c" (argv), "d" (envp)
+         : "memory", "cc", "r11"
+     );
++#else
++#error Unknown architecture
++#endif
+ 
+     if (result >= 0xfffffffffffff000) {
+         errno = -result;
+@@ -621,9 +642,6 @@ nonLockingLinux__execve (const char *file,
+     }
+ 
+     return result;
+-#else
+-#error Unknown architecture
+-#endif
+ }
+ 
+ #endif
+
+From a1dffe02519bb3c6ccbbe8c6c58304da5db98995 Mon Sep 17 00:00:00 2001
+From: Tsahi Zidenberg <tsahee@amazon.com>
+Date: Sun, 15 Nov 2020 15:22:52 +0000
+Subject: [PATCH 2/2] timing: support aarch64/linux
+
+The aarch64 arch-timer is directly accessible to userspace via two
+registers:
+CNTVCT_EL0 - holds the current counter value
+CNTFRQ_EL0 - holds the counter frequency (in Hz)
+---
+ pxr/base/arch/timing.cpp | 6 ++++++
+ pxr/base/arch/timing.h   | 6 +++++-
+ 2 files changed, 11 insertions(+), 1 deletion(-)
+
+diff --git a/pxr/base/arch/timing.cpp b/pxr/base/arch/timing.cpp
+index 27ad58fed..9022950c1 100644
+--- a/pxr/base/arch/timing.cpp
++++ b/pxr/base/arch/timing.cpp
+@@ -59,6 +59,11 @@ ARCH_HIDDEN
+ void
+ Arch_InitTickTimer()
+ {
++#ifdef __aarch64__
++    uint64_t counter_hz;
++    __asm __volatile("mrs	%0, CNTFRQ_EL0" : "=&r" (counter_hz));
++    Arch_NanosecondsPerTick = double(1e9) / double(counter_hz);
++#else
+     // NOTE: Normally ifstream would be cleaner, but it causes crashes when
+     //       used in conjunction with DSOs and the Intel Compiler.
+     FILE *in;
+@@ -135,6 +140,7 @@ Arch_InitTickTimer()
+     }
+ 
+     Arch_NanosecondsPerTick = double(1e9) / double(cpuHz);
++#endif
+ }
+ #elif defined(ARCH_OS_WINDOWS)
+ 
+diff --git a/pxr/base/arch/timing.h b/pxr/base/arch/timing.h
+index 67ec0d15f..6dc3e85a0 100644
+--- a/pxr/base/arch/timing.h
++++ b/pxr/base/arch/timing.h
+@@ -36,7 +36,7 @@
+ /// \addtogroup group_arch_SystemFunctions
+ ///@{
+ 
+-#if defined(ARCH_OS_LINUX)
++#if defined(ARCH_OS_LINUX) && defined(ARCH_CPU_INTEL)
+ #include <x86intrin.h>
+ #elif defined(ARCH_OS_DARWIN)
+ #include <mach/mach_time.h>
+@@ -69,6 +69,10 @@ ArchGetTickTime()
+ #elif defined(ARCH_CPU_INTEL)
+     // On Intel we'll use the rdtsc instruction.
+     return __rdtsc();
++#elif defined (__aarch64__)
++    uint64_t result;
++    __asm __volatile("mrs	%0, CNTVCT_EL0" : "=&r" (result));
++    return result;
+ #else
+ #error Unknown architecture.
+ #endif

build_files/buildbot/buildbot_utils.py

@@ -85,8 +85,8 @@ class VersionInfo:
         version_number = int(self._parse_header_file(blender_h, 'BLENDER_VERSION'))
         version_number_patch = int(self._parse_header_file(blender_h, 'BLENDER_VERSION_PATCH'))
         version_numbers = (version_number // 100, version_number % 100, version_number_patch)
-        self.short_version = "%d.%02d" % (version_numbers[0], version_numbers[1])
-        self.version = "%d.%02d.%d" % version_numbers
+        self.short_version = "%d.%d" % (version_numbers[0], version_numbers[1])
+        self.version = "%d.%d.%d" % version_numbers
         self.version_cycle = self._parse_header_file(blender_h, 'BLENDER_VERSION_CYCLE')
         self.hash = self._parse_header_file(buildinfo_h, 'BUILD_HASH')[1:-1]
 

build_files/cmake/Modules/FindEmbree.cmake

@@ -34,7 +34,7 @@ FIND_PATH(EMBREE_INCLUDE_DIR
     include
 )
 
-IF(NOT (APPLE AND ("${CMAKE_OSX_ARCHITECTURES}" STREQUAL "arm64")))
+IF(NOT (("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "aarch64") OR (APPLE AND ("${CMAKE_OSX_ARCHITECTURES}" STREQUAL "arm64"))))
   SET(_embree_SIMD_COMPONENTS
     embree_sse42
     embree_avx

build_files/cmake/config/blender_release.cmake

@@ -56,6 +56,10 @@ set(WITH_TBB                 ON  CACHE BOOL "" FORCE)
 set(WITH_USD                 ON  CACHE BOOL "" FORCE)
 
 set(WITH_MEM_JEMALLOC          ON  CACHE BOOL "" FORCE)
+set(WITH_CYCLES_CUDA_BINARIES  ON  CACHE BOOL "" FORCE)
+set(WITH_CYCLES_CUBIN_COMPILER OFF CACHE BOOL "" FORCE)
+set(CYCLES_CUDA_BINARIES_ARCH sm_30;sm_35;sm_37;sm_50;sm_52;sm_60;sm_61;sm_70;sm_75;sm_86;compute_75 CACHE STRING "" FORCE)
+set(WITH_CYCLES_DEVICE_OPTIX   ON CACHE BOOL "" FORCE)
 
 # platform dependent options
 if(APPLE)
@@ -76,8 +80,4 @@ if(UNIX AND NOT APPLE)
 endif()
 if(NOT APPLE)
   set(WITH_XR_OPENXR              ON  CACHE BOOL "" FORCE)
-
-  set(WITH_CYCLES_DEVICE_OPTIX    ON  CACHE BOOL "" FORCE)
-  set(WITH_CYCLES_CUDA_BINARIES   ON  CACHE BOOL "" FORCE)
-  set(WITH_CYCLES_CUBIN_COMPILER  OFF CACHE BOOL "" FORCE)
 endif()

build_files/cmake/macros.cmake

@@ -923,10 +923,6 @@ function(get_blender_version)
   math(EXPR _out_version_major "${_out_version} / 100")
   math(EXPR _out_version_minor "${_out_version} % 100")
 
-  # Zero pad the minor version so `_out_version_minor` is always two characters.
-  # This is needed if the minor version is a single digit.
-  string(REGEX REPLACE "^([0-9])$" "0\\1" _out_version_minor "${_out_version_minor}")
-
   # output vars
   set(BLENDER_VERSION "${_out_version_major}.${_out_version_minor}" PARENT_SCOPE)
   set(BLENDER_VERSION_MAJOR "${_out_version_major}" PARENT_SCOPE)

build_files/cmake/platform/platform_apple.cmake

@@ -20,6 +20,12 @@
 
 # Libraries configuration for Apple.
 
+if("${CMAKE_OSX_ARCHITECTURES}" STREQUAL "arm64")
+  set(MACOSX_DEPLOYMENT_TARGET 11.00)
+else()
+  set(MACOSX_DEPLOYMENT_TARGET 10.13)
+endif()
+
 macro(find_package_wrapper)
 # do nothing, just satisfy the macro
 endmacro()

build_files/cmake/platform/platform_apple_xcode.cmake

@@ -168,15 +168,21 @@ endif()
 unset(OSX_SDKROOT)
 
 
+# 10.13 is our min. target, if you use higher sdk, weak linking happens
 if("${CMAKE_OSX_ARCHITECTURES}" STREQUAL "arm64")
-  # M1 chips run Big Sur onwards.
   set(OSX_MIN_DEPLOYMENT_TARGET 11.00)
 else()
-  # 10.13 is our min. target, if you use higher sdk, weak linking happens
   set(OSX_MIN_DEPLOYMENT_TARGET 10.13)
 endif()
 
-set(CMAKE_OSX_DEPLOYMENT_TARGET "${OSX_MIN_DEPLOYMENT_TARGET}" CACHE STRING "" FORCE)
+if(CMAKE_OSX_DEPLOYMENT_TARGET)
+  if(${CMAKE_OSX_DEPLOYMENT_TARGET} VERSION_LESS ${OSX_MIN_DEPLOYMENT_TARGET})
+    message(STATUS "Setting deployment target to ${OSX_MIN_DEPLOYMENT_TARGET}, lower versions are not supported")
+    set(CMAKE_OSX_DEPLOYMENT_TARGET "${OSX_MIN_DEPLOYMENT_TARGET}" CACHE STRING "" FORCE)
+  endif()
+else()
+  set(CMAKE_OSX_DEPLOYMENT_TARGET "${OSX_MIN_DEPLOYMENT_TARGET}" CACHE STRING "" FORCE)
+endif()
 
 if(NOT ${CMAKE_GENERATOR} MATCHES "Xcode")
   # Force CMAKE_OSX_DEPLOYMENT_TARGET for makefiles, will not work else (CMake bug?)

build_files/cmake/platform/platform_win32_bundle_crt.cmake

@@ -15,15 +15,6 @@ if(WITH_WINDOWS_BUNDLE_CRT)
 
   include(InstallRequiredSystemLibraries)
 
-  # ucrtbase(d).dll cannot be in the manifest, due to the way windows 10 handles
-  # redirects for this dll, for details see T88813.
-  foreach(lib ${CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS})
-    string(FIND ${lib} "ucrtbase" pos)
-    if(NOT pos EQUAL -1)
-      list(REMOVE_ITEM CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS ${lib})
-      install(FILES ${lib} DESTINATION . COMPONENT Libraries)
-    endif()
-  endforeach()
   # Install the CRT to the blender.crt Sub folder.
   install(FILES ${CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS} DESTINATION ./blender.crt COMPONENT Libraries)
 

build_files/config/pipeline_config.json

@@ -1,91 +0,0 @@
-{
-    "update-code": {
-        "git": {
-            "submodules": [
-                {
-                    "path": "release/scripts/addons",
-                    "branch": "blender-v2.93-release",
-                    "commit_id": "HEAD"
-                },
-                {
-                    "path": "release/scripts/addons_contrib",
-                    "branch": "blender-v2.93-release",
-                    "commit_id": "HEAD"
-                },
-                {
-                    "path": "release/datafiles/locale",
-                    "branch": "blender-v2.93-release",
-                    "commit_id": "HEAD"
-                },
-                {
-                    "path": "source/tools",
-                    "branch": "blender-v2.93-release",
-                    "commit_id": "HEAD"
-                }
-            ]
-        },
-        "svn": {
-            "tests": {
-                "path": "lib/tests",
-                "branch": "tags/blender-2.93-release",
-                "commit_id": "HEAD"
-            },
-            "libraries": {
-                "darwin-x86_64": {
-                    "path": "lib/darwin",
-                    "branch": "tags/blender-2.93-release",
-                    "commit_id": "HEAD"
-                },
-                "darwin-arm64": {
-                    "path": "lib/darwin_arm64",
-                    "branch": "tags/blender-2.93-release",
-                    "commit_id": "HEAD"
-                },
-                "linux-x86_64": {
-                    "path": "lib/linux_centos7_x86_64",
-                    "branch": "tags/blender-2.93-release",
-                    "commit_id": "HEAD"
-                },
-                "windows-amd64": {
-                    "path": "lib/win64_vc15",
-                    "branch": "tags/blender-2.93-release",
-                    "commit_id": "HEAD"
-                }
-            }
-        }
-    },
-    "buildbot": {
-        "gcc": {
-            "version": "9.0"
-        },
-        "sdks": {
-            "optix": {
-                "version": "7.1.0"
-            },
-            "cuda10": {
-                "version": "10.1"
-            },
-            "cuda11": {
-                "version": "11.3"
-            }
-        },
-        "cmake": {
-            "default": {
-                "version": "any",
-                "overrides": {}
-            },
-            "darwin-x86_64": {
-                "overrides": {}
-            },
-            "darwin-arm64": {
-                "overrides": {}
-            },
-            "linux-x86_64": {
-                "overrides": {}
-            },
-            "windows-amd64": {
-                "overrides": {}
-            }
-        }
-    }
-}

doc/doxygen/Doxyfile

@@ -38,7 +38,7 @@ PROJECT_NAME           = Blender
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = "V2.93"
+PROJECT_NUMBER         = "V3.0"
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

doc/python_api/rst/info_gotcha.rst

@@ -50,7 +50,8 @@ you should be able to find the poll function with no knowledge of C.
 
    Blender does have the functionality for poll functions to describe why they fail,
    but its currently not used much, if you're interested to help improve the API
-   feel free to add calls to ``CTX_wm_operator_poll_msg_set`` where its not obvious why poll fails, e.g:
+   feel free to add calls to :class:`bpy.types.Operator.poll_message_set` (``CTX_wm_operator_poll_msg_set`` in C)
+   where its not obvious why poll fails, e.g:
 
       >>> bpy.ops.gpencil.draw()
       RuntimeError: Operator bpy.ops.gpencil.draw.poll() Failed to find Grease Pencil data to draw into

doc/python_api/sphinx_doc_gen.py

@@ -545,13 +545,6 @@ def range_str(val):
 
 
 def example_extract_docstring(filepath):
-    '''
-    Return (text, line_no, line_no_has_content) where:
-    - ``text`` is the doc-string text.
-    - ``line_no`` is the line the doc-string text ends.
-    - ``line_no_has_content`` when False, this file only contains a doc-string.
-      There is no need to include the remainder.
-    '''
     file = open(filepath, "r", encoding="utf-8")
     line = file.readline()
     line_no = 0
@@ -560,7 +553,7 @@ def example_extract_docstring(filepath):
         line_no += 1
     else:
         file.close()
-        return "", 0, True
+        return "", 0, False
 
     for line in file:
         line_no += 1

doc/python_api/static/css/theme_overrides.css

@@ -1,8 +1,7 @@
 /* T76453: Prevent Long enum lists */
-.field-list > dd p {
+.field-list li {
    max-height: 245px;
    overflow-y: auto !important;
-   word-break: break-word;
 }
 
 /* Hide home icon in search area */
@@ -12,15 +11,3 @@
 .wy-nav-content {
     max-width: 1000px !important;
 }
-
-/* Fix long titles on mobile */
-h1, h2, h3, h4, h5, h6 {word-break: break-all}
-
-/* Temp fix for https://github.com/readthedocs/sphinx_rtd_theme/pull/1109 */
-.hlist tr {
-   display: -ms-flexbox;
-   display: flex;
-   flex-flow: row wrap;
- }
-
-.hlist td {margin-right: auto}

extern/mantaflow/preprocessed/fileio/iovdb.cpp

@@ -29,10 +29,10 @@
 
 #if OPENVDB == 1
 #  include "openvdb/openvdb.h"
-#  include "openvdb/points/PointConversion.h"
-#  include "openvdb/points/PointCount.h"
-#  include "openvdb/tools/Clip.h"
-#  include "openvdb/tools/Dense.h"
+#  include <openvdb/points/PointConversion.h>
+#  include <openvdb/points/PointCount.h>
+#  include <openvdb/tools/Clip.h>
+#  include <openvdb/tools/Dense.h>
 #endif
 
 #define POSITION_NAME "P"
@@ -519,7 +519,7 @@ int writeObjectsVDB(const string &filename,
     }
   }
 
-  // Write only if there is at least one grid, optionally write with compression.
+  // Write only if the is at least one grid, optionally write with compression.
   if (gridsVDB.size()) {
     int vdb_flags = openvdb::io::COMPRESS_ACTIVE_MASK;
     switch (compression) {
@@ -534,8 +534,7 @@ int writeObjectsVDB(const string &filename,
       }
       case COMPRESSION_BLOSC: {
 #  if OPENVDB_BLOSC == 1
-        // Cannot use |= here, causes segfault with blosc 1.5.0 (== recommended version)
-        vdb_flags = openvdb::io::COMPRESS_BLOSC;
+        vdb_flags |= openvdb::io::COMPRESS_BLOSC;
 #  else
         debMsg("OpenVDB was built without Blosc support, using Zip compression instead", 1);
         vdb_flags |= openvdb::io::COMPRESS_ZIP;

extern/mantaflow/preprocessed/fluidsolver.h

@@ -384,7 +384,6 @@ class FluidSolver : public PbClass {
   GridStorage<Real> mGrids4dReal;
   GridStorage<Vec3> mGrids4dVec;
   GridStorage<Vec4> mGrids4dVec4;
-
  public:
   PbArgs _args;
 }

extern/mantaflow/preprocessed/general.h

@@ -42,7 +42,7 @@ inline void updateQtGui(bool full, int frame, float time, const std::string &cur
 #  ifdef _DEBUG
 #    define DEBUG 1
 #  endif  // _DEBUG
-#endif    // DEBUG
+#endif  // DEBUG
 
 // Standard exception
 class Error : public std::exception {

extern/mantaflow/preprocessed/gitinfo.h

@@ -1,3 +1,3 @@
 
 
-#define MANTA_GIT_VERSION "commit 9c505cd22e289b98c9aa717efba8ef3201c7e458"
+#define MANTA_GIT_VERSION "commit 39b7a415721ecbf6643612a24e8eadd221aeb934"

extern/mantaflow/preprocessed/grid.h

@@ -389,7 +389,6 @@ class GridBase : public PbClass {
   Real mDx;
   bool m3D;  // precomputed Z shift: to ensure 2D compatibility, always use this instead of sx*sy !
   IndexInt mStrideZ;
-
  public:
   PbArgs _args;
 }

extern/mantaflow/preprocessed/grid4d.h

@@ -326,7 +326,6 @@ class Grid4dBase : public PbClass {
   // precomputed Z,T shift: to ensure 2D compatibility, always use this instead of sx*sy !
   IndexInt mStrideZ;
   IndexInt mStrideT;
-
  public:
   PbArgs _args;
 }
@@ -951,7 +950,6 @@ template<class T> class Grid4d : public Grid4dBase {
 
  protected:
   T *mData;
-
  public:
   PbArgs _args;
 }

extern/mantaflow/preprocessed/levelset.h

@@ -266,7 +266,6 @@ class LevelsetGrid : public Grid<Real> {
   }
 
   static Real invalidTimeValue();
-
  public:
   PbArgs _args;
 }

extern/mantaflow/preprocessed/mesh.h

@@ -796,7 +796,6 @@ class Mesh : public PbClass {
   std::vector<MeshDataImpl<int> *>
       mMdataInt;  //! indicate that mdata of this mesh is copied, and needs to be freed
   bool mFreeMdata;
-
  public:
   PbArgs _args;
 }
@@ -882,7 +881,6 @@ class MeshDataBase : public PbClass {
 
  protected:
   Mesh *mMesh;
-
  public:
   PbArgs _args;
 }
@@ -1647,7 +1645,6 @@ template<class T> class MeshDataImpl : public MeshDataBase {
   //! optionally , we might have an associated grid from which to grab new data
   Grid<T> *mpGridSource;  //! unfortunately , we need to distinguish mac vs regular vec3
   bool mGridSourceMAC;
-
  public:
   PbArgs _args;
 }

extern/mantaflow/preprocessed/movingobs.h

@@ -154,7 +154,6 @@ class MovingObstacle : public PbClass {
   int mEmptyType;
   int mID;
   static int sIDcnt;
-
  public:
   PbArgs _args;
 }

extern/mantaflow/preprocessed/noisefield.h

@@ -236,7 +236,6 @@ class WaveletNoiseField : public PbClass {
   static int randomSeed;
   // global reference count for noise tile
   static std::atomic<int> mNoiseReferenceCount;
-
  public:
   PbArgs _args;
 }

extern/mantaflow/preprocessed/particle.h

@@ -205,7 +205,6 @@ class ParticleBase : public PbClass {
   //! custom seed for particle systems, used by plugins
   int mSeed;  //! fix global random seed storage, used mainly by functions in this class
   static int globalSeed;
-
  public:
   PbArgs _args;
 }
@@ -629,7 +628,6 @@ template<class S> class ParticleSystem : public ParticleBase {
   std::vector<S> mData;
   //! reduce storage , called by doCompress
   virtual void compress();
-
  public:
   PbArgs _args;
 }
@@ -920,7 +918,6 @@ class ParticleIndexSystem : public ParticleSystem<ParticleIndexData> {
       return -1;
     }
   };
-
  public:
   PbArgs _args;
 }
@@ -985,7 +982,6 @@ template<class DATA, class CON> class ConnectedParticleSystem : public ParticleS
  protected:
   std::vector<CON> mSegments;
   virtual void compress();
-
  public:
   PbArgs _args;
 }
@@ -1075,7 +1071,6 @@ class ParticleDataBase : public PbClass {
 
  protected:
   ParticleBase *mpParticleSys;
-
  public:
   PbArgs _args;
 }
@@ -1848,7 +1843,6 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
   //! optionally , we might have an associated grid from which to grab new data
   Grid<T> *mpGridSource;  //! unfortunately , we need to distinguish mac vs regular vec3
   bool mGridSourceMAC;
-
  public:
   PbArgs _args;
 }

extern/mantaflow/preprocessed/plugin/meshplugins.cpp

@@ -234,10 +234,10 @@ void subdivideMesh(
       normalize(ne2);
 
       // Real thisArea = sqrMag(cross(-e2,e0));
-      //  small angle approximation says sin(x) = arcsin(x) = x,
-      //  arccos(x) = pi/2 - arcsin(x),
-      //  cos(x) = dot(A,B),
-      //  so angle is approximately 1 - dot(A,B).
+      // small angle approximation says sin(x) = arcsin(x) = x,
+      // arccos(x) = pi/2 - arcsin(x),
+      // cos(x) = dot(A,B),
+      // so angle is approximately 1 - dot(A,B).
       Real angle[3];
       angle[0] = 1.0 - dot(ne0, -ne2);
       angle[1] = 1.0 - dot(ne1, -ne0);

extern/mantaflow/preprocessed/plugin/secondaryparticles.cpp

@@ -2287,10 +2287,9 @@ struct knFlipComputePotentialTrappedAir : public KernelBase {
           const Vec3 &vj = scaleFromManta * v.getCentered(x, y, z);
           const Vec3 xij = xi - xj;
           const Vec3 vij = vi - vj;
-          Real h = !pot.is3D() ?
-                       1.414 * radius :
-                       1.732 * radius;  // estimate sqrt(2)*radius resp. sqrt(3)*radius for h, due
-                                        // to squared resp. cubic neighbor area
+          Real h = !pot.is3D() ? 1.414 * radius :
+                                 1.732 * radius;  // estimate sqrt(2)*radius resp. sqrt(3)*radius
+                                                  // for h, due to squared resp. cubic neighbor area
           vdiff += norm(vij) * (1 - dot(getNormalized(vij), getNormalized(xij))) *
                    (1 - norm(xij) / h);
         }

extern/mantaflow/preprocessed/shapes.h

@@ -269,7 +269,6 @@ class Shape : public PbClass {
 
  protected:
   GridType mType;
-
  public:
   PbArgs _args;
 }
@@ -320,7 +319,6 @@ class NullShape : public Shape {
   {
     gridSetConst<Real>(phi, 1000.0f);
   }
-
  public:
   PbArgs _args;
 }
@@ -396,7 +394,6 @@ class Box : public Shape {
 
  protected:
   Vec3 mP0, mP1;
-
  public:
   PbArgs _args;
 }
@@ -458,7 +455,6 @@ class Sphere : public Shape {
  protected:
   Vec3 mCenter, mScale;
   Real mRadius;
-
  public:
   PbArgs _args;
 }
@@ -583,7 +579,6 @@ class Cylinder : public Shape {
  protected:
   Vec3 mCenter, mZDir;
   Real mRadius, mZ;
-
  public:
   PbArgs _args;
 }
@@ -660,7 +655,6 @@ class Slope : public Shape {
   Real mAnglexy, mAngleyz;
   Real mOrigin;
   Vec3 mGs;
-
  public:
   PbArgs _args;
 }

extern/mantaflow/preprocessed/turbulencepart.h

@@ -199,7 +199,6 @@ class TurbulenceParticleSystem : public ParticleSystem<TurbulenceParticleData> {
 
  private:
   WaveletNoiseField &noise;
-
  public:
   PbArgs _args;
 }

extern/mantaflow/preprocessed/vortexpart.h

@@ -127,7 +127,6 @@ class VortexParticleSystem : public ParticleSystem<VortexParticleData> {
   }
 
   virtual ParticleBase *clone();
-
  public:
   PbArgs _args;
 }

extern/mantaflow/preprocessed/vortexsheet.h

@@ -240,7 +240,6 @@ class VortexSheetMesh : public Mesh {
   VorticityChannel mVorticity;
   TexCoord3Channel mTex1, mTex2;
   TurbulenceChannel mTurb;
-
  public:
   PbArgs _args;
 }

intern/clog/CLG_log.h

@@ -118,7 +118,6 @@ typedef struct CLG_LogType {
 typedef struct CLG_LogRef {
   const char *identifier;
   CLG_LogType *type;
-  struct CLG_LogRef *next;
 } CLG_LogRef;
 
 void CLG_log_str(CLG_LogType *lg,

intern/clog/clog.c

@@ -81,8 +81,6 @@ typedef struct CLG_IDFilter {
 typedef struct CLogContext {
   /** Single linked list of types.  */
   CLG_LogType *types;
-  /** Single linked list of references.  */
-  CLG_LogRef *refs;
 #ifdef WITH_CLOG_PTHREADS
   pthread_mutex_t types_lock;
 #endif
@@ -675,12 +673,6 @@ static void CLG_ctx_free(CLogContext *ctx)
     MEM_freeN(item);
   }
 
-  while (ctx->refs != NULL) {
-    CLG_LogRef *item = ctx->refs;
-    ctx->refs = item->next;
-    item->type = NULL;
-  }
-
   for (uint i = 0; i < 2; i++) {
     while (ctx->filters[i] != NULL) {
       CLG_IDFilter *item = ctx->filters[i];
@@ -777,10 +769,6 @@ void CLG_logref_init(CLG_LogRef *clg_ref)
   pthread_mutex_lock(&g_ctx->types_lock);
 #endif
   if (clg_ref->type == NULL) {
-    /* Add to the refs list so we can NULL the pointers to 'type' when CLG_exit() is called. */
-    clg_ref->next = g_ctx->refs;
-    g_ctx->refs = clg_ref;
-
     CLG_LogType *clg_ty = clg_ctx_type_find_by_name(g_ctx, clg_ref->identifier);
     if (clg_ty == NULL) {
       clg_ty = clg_ctx_type_register(g_ctx, clg_ref->identifier);

intern/cycles/blender/addon/ui.py

@@ -552,9 +552,7 @@ class CYCLES_RENDER_PT_light_paths_fast_gi(CyclesButtonsPanel, Panel):
 
         if world:
           light = world.light_settings
-          col = layout.column(align=True)
-          col.prop(light, "ao_factor", text="AO Factor")
-          col.prop(light, "distance", text="AO Distance")
+          layout.prop(light, "distance", text="AO Distance")
 
 
 class CYCLES_RENDER_PT_motion_blur(CyclesButtonsPanel, Panel):
@@ -725,7 +723,7 @@ class CYCLES_RENDER_PT_performance_tiles(CyclesButtonsPanel, Panel):
         col.prop(cscene, "tile_order", text="Order")
 
         sub = col.column()
-        sub.active = not rd.use_save_buffers and not cscene.use_adaptive_sampling
+        sub.active = not rd.use_save_buffers
         sub.prop(cscene, "use_progressive_refine")
 
 

intern/cycles/blender/blender_object.cpp

@@ -96,49 +96,7 @@ bool BlenderSync::object_is_light(BL::Object &b_ob)
   return (b_ob_data && b_ob_data.is_a(&RNA_Light));
 }
 
-void BlenderSync::sync_object_motion_init(BL::Object &b_parent, BL::Object &b_ob, Object *object)
-{
-  /* Initialize motion blur for object, detecting if it's enabled and creating motion
-   * steps array if so. */
-  array<Transform> motion;
-  object->set_motion(motion);
-
-  Scene::MotionType need_motion = scene->need_motion();
-  if (need_motion == Scene::MOTION_NONE || !object->get_geometry()) {
-    return;
-  }
-
-  Geometry *geom = object->get_geometry();
-  geom->set_use_motion_blur(false);
-  geom->set_motion_steps(0);
-
-  uint motion_steps;
-
-  if (need_motion == Scene::MOTION_BLUR) {
-    motion_steps = object_motion_steps(b_parent, b_ob, Object::MAX_MOTION_STEPS);
-    geom->set_motion_steps(motion_steps);
-    if (motion_steps && object_use_deform_motion(b_parent, b_ob)) {
-      geom->set_use_motion_blur(true);
-    }
-  }
-  else {
-    motion_steps = 3;
-    geom->set_motion_steps(motion_steps);
-  }
-
-  motion.resize(motion_steps, transform_empty());
-
-  if (motion_steps) {
-    motion[motion_steps / 2] = object->get_tfm();
-
-    /* update motion socket before trying to access object->motion_time */
-    object->set_motion(motion);
-
-    for (size_t step = 0; step < motion_steps; step++) {
-      motion_times.insert(object->motion_time(step));
-    }
-  }
-}
+/* Object */
 
 Object *BlenderSync::sync_object(BL::Depsgraph &b_depsgraph,
                                  BL::ViewLayer &b_view_layer,
@@ -261,8 +219,10 @@ Object *BlenderSync::sync_object(BL::Depsgraph &b_depsgraph,
   }
 
   /* test if we need to sync */
-  bool object_updated = object_map.add_or_update(&object, b_ob, b_parent, key) ||
-                        (tfm != object->get_tfm());
+  bool object_updated = false;
+
+  if (object_map.add_or_update(&object, b_ob, b_parent, key))
+    object_updated = true;
 
   /* mesh sync */
   /* b_ob is owned by the iterator and will go out of scope at the end of the block.
@@ -311,11 +271,49 @@ Object *BlenderSync::sync_object(BL::Depsgraph &b_depsgraph,
    * transform comparison should not be needed, but duplis don't work perfect
    * in the depsgraph and may not signal changes, so this is a workaround */
   if (object->is_modified() || object_updated ||
-      (object->get_geometry() && object->get_geometry()->is_modified())) {
+      (object->get_geometry() && object->get_geometry()->is_modified()) ||
+      tfm != object->get_tfm()) {
     object->name = b_ob.name().c_str();
     object->set_pass_id(b_ob.pass_index());
     object->set_color(get_float3(b_ob.color()));
     object->set_tfm(tfm);
+    array<Transform> motion;
+    object->set_motion(motion);
+
+    /* motion blur */
+    Scene::MotionType need_motion = scene->need_motion();
+    if (need_motion != Scene::MOTION_NONE && object->get_geometry()) {
+      Geometry *geom = object->get_geometry();
+      geom->set_use_motion_blur(false);
+      geom->set_motion_steps(0);
+
+      uint motion_steps;
+
+      if (need_motion == Scene::MOTION_BLUR) {
+        motion_steps = object_motion_steps(b_parent, b_ob, Object::MAX_MOTION_STEPS);
+        geom->set_motion_steps(motion_steps);
+        if (motion_steps && object_use_deform_motion(b_parent, b_ob)) {
+          geom->set_use_motion_blur(true);
+        }
+      }
+      else {
+        motion_steps = 3;
+        geom->set_motion_steps(motion_steps);
+      }
+
+      motion.resize(motion_steps, transform_empty());
+
+      if (motion_steps) {
+        motion[motion_steps / 2] = tfm;
+
+        /* update motion socket before trying to access object->motion_time */
+        object->set_motion(motion);
+
+        for (size_t step = 0; step < motion_steps; step++) {
+          motion_times.insert(object->motion_time(step));
+        }
+      }
+    }
 
     /* dupli texture coordinates and random_id */
     if (is_instance) {
@@ -333,8 +331,6 @@ Object *BlenderSync::sync_object(BL::Depsgraph &b_depsgraph,
     object->tag_update(scene);
   }
 
-  sync_object_motion_init(b_parent, b_ob, object);
-
   if (is_instance) {
     /* Sync possible particle data. */
     sync_dupli_particle(b_parent, b_instance, object);
@@ -615,7 +611,7 @@ void BlenderSync::sync_motion(BL::RenderSettings &b_render,
     if (b_cam) {
       sync_camera_motion(b_render, b_cam, width, height, 0.0f);
     }
-    sync_objects(b_depsgraph, b_v3d);
+    sync_objects(b_depsgraph, b_v3d, 0.0f);
   }
 
   /* Insert motion times from camera. Motion times from other objects

intern/cycles/blender/blender_python.cpp

@@ -35,7 +35,6 @@
 #include "util/util_path.h"
 #include "util/util_string.h"
 #include "util/util_task.h"
-#include "util/util_tbb.h"
 #include "util/util_types.h"
 
 #ifdef WITH_OSL
@@ -289,11 +288,9 @@ static PyObject *render_func(PyObject * /*self*/, PyObject *args)
   RNA_pointer_create(NULL, &RNA_Depsgraph, (ID *)PyLong_AsVoidPtr(pydepsgraph), &depsgraphptr);
   BL::Depsgraph b_depsgraph(depsgraphptr);
 
-  /* Allow Blender to execute other Python scripts, and isolate TBB tasks so we
-   * don't get deadlocks with Blender threads accessing shared data like images. */
   python_thread_state_save(&session->python_thread_state);
 
-  tbb::this_task_arena::isolate([&] { session->render(b_depsgraph); });
+  session->render(b_depsgraph);
 
   python_thread_state_restore(&session->python_thread_state);
 
@@ -330,8 +327,7 @@ static PyObject *bake_func(PyObject * /*self*/, PyObject *args)
 
   python_thread_state_save(&session->python_thread_state);
 
-  tbb::this_task_arena::isolate(
-      [&] { session->bake(b_depsgraph, b_object, pass_type, pass_filter, width, height); });
+  session->bake(b_depsgraph, b_object, pass_type, pass_filter, width, height);
 
   python_thread_state_restore(&session->python_thread_state);
 
@@ -377,7 +373,7 @@ static PyObject *reset_func(PyObject * /*self*/, PyObject *args)
 
   python_thread_state_save(&session->python_thread_state);
 
-  tbb::this_task_arena::isolate([&] { session->reset_session(b_data, b_depsgraph); });
+  session->reset_session(b_data, b_depsgraph);
 
   python_thread_state_restore(&session->python_thread_state);
 
@@ -399,7 +395,7 @@ static PyObject *sync_func(PyObject * /*self*/, PyObject *args)
 
   python_thread_state_save(&session->python_thread_state);
 
-  tbb::this_task_arena::isolate([&] { session->synchronize(b_depsgraph); });
+  session->synchronize(b_depsgraph);
 
   python_thread_state_restore(&session->python_thread_state);
 

intern/cycles/blender/blender_session.cpp

@@ -237,9 +237,6 @@ void BlenderSession::reset_session(BL::BlendData &b_data, BL::Depsgraph &b_depsg
     sync->sync_recalc(b_depsgraph, b_v3d);
   }
 
-  BL::Object b_camera_override(b_engine.camera_override());
-  sync->sync_camera(b_render, b_camera_override, width, height, "");
-
   BL::SpaceView3D b_null_space_view3d(PointerRNA_NULL);
   BL::RegionView3D b_null_region_view3d(PointerRNA_NULL);
   BufferParams buffer_params = BlenderSync::get_buffer_params(b_render,

intern/cycles/blender/blender_shader.cpp

@@ -1553,9 +1553,13 @@ void BlenderSync::sync_lights(BL::Depsgraph &b_depsgraph, bool update_all)
 void BlenderSync::sync_shaders(BL::Depsgraph &b_depsgraph, BL::SpaceView3D &b_v3d)
 {
   /* for auto refresh images */
-  ImageManager *image_manager = scene->image_manager;
-  const int frame = b_scene.frame_current();
-  const bool auto_refresh_update = image_manager->set_animation_frame_update(frame);
+  bool auto_refresh_update = false;
+
+  if (preview) {
+    ImageManager *image_manager = scene->image_manager;
+    int frame = b_scene.frame_current();
+    auto_refresh_update = image_manager->set_animation_frame_update(frame);
+  }
 
   shader_map.pre_sync();
 

intern/cycles/blender/blender_sync.cpp

@@ -739,18 +739,12 @@ void BlenderSync::free_data_after_sync(BL::Depsgraph &b_depsgraph)
    * caches to be releases from blender side in order to reduce peak memory
    * footprint during synchronization process.
    */
-
   const bool is_interface_locked = b_engine.render() && b_engine.render().use_lock_interface();
-  const bool is_persistent_data = b_engine.render() && b_engine.render().use_persistent_data();
-  const bool can_free_caches =
-      (BlenderSession::headless || is_interface_locked) &&
-      /* Baking re-uses the depsgraph multiple times, clearing crashes
-       * reading un-evaluated mesh data which isn't aligned with the
-       * geometry we're baking, see T71012. */
-      !scene->bake_manager->get_baking() &&
-      /* Persistent data must main caches for performance and correctness. */
-      !is_persistent_data;
-
+  const bool can_free_caches = (BlenderSession::headless || is_interface_locked) &&
+                               /* Baking re-uses the depsgraph multiple times, clearing crashes
+                                * reading un-evaluated mesh data which isn't aligned with the
+                                * geometry we're baking, see T71012. */
+                               !scene->bake_manager->get_baking();
   if (!can_free_caches) {
     return;
   }
@@ -875,9 +869,6 @@ SessionParams BlenderSync::get_session_params(BL::RenderEngine &b_engine,
   /* Clamp samples. */
   params.samples = min(params.samples, Integrator::MAX_SAMPLES);
 
-  /* Adaptive sampling. */
-  params.adaptive_sampling = RNA_boolean_get(&cscene, "use_adaptive_sampling");
-
   /* tiles */
   const bool is_cpu = (params.device.type == DEVICE_CPU);
   if (!is_cpu && !background) {
@@ -930,7 +921,7 @@ SessionParams BlenderSync::get_session_params(BL::RenderEngine &b_engine,
   BL::RenderSettings b_r = b_scene.render();
   params.progressive_refine = b_engine.is_preview() ||
                               get_boolean(cscene, "use_progressive_refine");
-  if (b_r.use_save_buffers() || params.adaptive_sampling)
+  if (b_r.use_save_buffers())
     params.progressive_refine = false;
 
   if (background) {
@@ -966,6 +957,8 @@ SessionParams BlenderSync::get_session_params(BL::RenderEngine &b_engine,
   params.use_profiling = params.device.has_profiling && !b_engine.is_preview() && background &&
                          BlenderSession::print_render_stats;
 
+  params.adaptive_sampling = RNA_boolean_get(&cscene, "use_adaptive_sampling");
+
   return params;
 }
 

intern/cycles/blender/blender_sync.h

@@ -150,7 +150,6 @@ class BlenderSync {
                       BlenderObjectCulling &culling,
                       bool *use_portal,
                       TaskPool *geom_task_pool);
-  void sync_object_motion_init(BL::Object &b_parent, BL::Object &b_ob, Object *object);
 
   bool sync_object_attributes(BL::DepsgraphObjectInstance &b_instance, Object *object);
 

intern/cycles/bvh/bvh_optix.cpp

@@ -17,8 +17,6 @@
 
 #ifdef WITH_OPTIX
 
-#  include "device/device.h"
-
 #  include "bvh/bvh_optix.h"
 
 CCL_NAMESPACE_BEGIN
@@ -28,7 +26,6 @@ BVHOptiX::BVHOptiX(const BVHParams &params_,
                    const vector<Object *> &objects_,
                    Device *device)
     : BVH(params_, geometry_, objects_),
-      device(device),
       traversable_handle(0),
       as_data(device, params_.top_level ? "optix tlas" : "optix blas", false),
       motion_transform_data(device, "optix motion transform", false)
@@ -37,9 +34,7 @@ BVHOptiX::BVHOptiX(const BVHParams &params_,
 
 BVHOptiX::~BVHOptiX()
 {
-  // Acceleration structure memory is delayed freed on device, since deleting the
-  // BVH may happen while still being used for rendering.
-  device->release_optix_bvh(this);
+  // Acceleration structure memory is freed via the 'as_data' destructor
 }
 
 CCL_NAMESPACE_END

intern/cycles/bvh/bvh_optix.h

@@ -28,7 +28,6 @@ CCL_NAMESPACE_BEGIN
 
 class BVHOptiX : public BVH {
  public:
-  Device *device;
   uint64_t traversable_handle;
   device_only_memory<char> as_data;
   device_only_memory<char> motion_transform_data;

intern/cycles/device/device.h

@@ -61,6 +61,7 @@ enum DeviceTypeMask {
 };
 
 enum DeviceKernelStatus {
+  DEVICE_KERNEL_WAITING_FOR_FEATURE_KERNEL = 0,
   DEVICE_KERNEL_FEATURE_KERNEL_AVAILABLE,
   DEVICE_KERNEL_USING_FEATURE_KERNEL,
   DEVICE_KERNEL_FEATURE_KERNEL_INVALID,
@@ -426,9 +427,6 @@ class Device {
   /* acceleration structure building */
   virtual void build_bvh(BVH *bvh, Progress &progress, bool refit);
 
-  /* OptiX specific destructor. */
-  virtual void release_optix_bvh(BVH *){};
-
 #ifdef WITH_NETWORK
   /* networking */
   void server_run();

intern/cycles/device/device_memory.cpp

@@ -35,54 +35,10 @@ device_memory::device_memory(Device *device, const char *name, MemoryType type)
       device_pointer(0),
       host_pointer(0),
       shared_pointer(0),
-      shared_counter(0),
-      original_device_ptr(0),
-      original_device_size(0),
-      original_device(0),
-      need_realloc_(false),
-      modified(false)
+      shared_counter(0)
 {
 }
 
-device_memory::device_memory(device_memory &&other) noexcept
-    : data_type(other.data_type),
-      data_elements(other.data_elements),
-      data_size(other.data_size),
-      device_size(other.device_size),
-      data_width(other.data_width),
-      data_height(other.data_height),
-      data_depth(other.data_depth),
-      type(other.type),
-      name(other.name),
-      device(other.device),
-      device_pointer(other.device_pointer),
-      host_pointer(other.host_pointer),
-      shared_pointer(other.shared_pointer),
-      shared_counter(other.shared_counter),
-      original_device_ptr(other.original_device_ptr),
-      original_device_size(other.original_device_size),
-      original_device(other.original_device),
-      need_realloc_(other.need_realloc_),
-      modified(other.modified)
-{
-  other.data_elements = 0;
-  other.data_size = 0;
-  other.device_size = 0;
-  other.data_width = 0;
-  other.data_height = 0;
-  other.data_depth = 0;
-  other.device = 0;
-  other.device_pointer = 0;
-  other.host_pointer = 0;
-  other.shared_pointer = 0;
-  other.shared_counter = 0;
-  other.original_device_ptr = 0;
-  other.original_device_size = 0;
-  other.original_device = 0;
-  other.need_realloc_ = false;
-  other.modified = false;
-}
-
 device_memory::~device_memory()
 {
   assert(shared_pointer == 0);

intern/cycles/device/device_memory.h

@@ -238,7 +238,6 @@ class device_memory {
 
   /* Only create through subclasses. */
   device_memory(Device *device, const char *name, MemoryType type);
-  device_memory(device_memory &&other) noexcept;
 
   /* No copying allowed. */
   device_memory(const device_memory &) = delete;
@@ -278,10 +277,6 @@ template<typename T> class device_only_memory : public device_memory {
     data_elements = max(device_type_traits<T>::num_elements, 1);
   }
 
-  device_only_memory(device_only_memory &&other) noexcept : device_memory(std::move(other))
-  {
-  }
-
   virtual ~device_only_memory()
   {
     free();

intern/cycles/device/device_multi.cpp

@@ -232,6 +232,10 @@ class MultiDevice : public Device {
     foreach (SubDevice &sub, devices) {
       DeviceKernelStatus subresult = sub.device->get_active_kernel_switch_state();
       switch (subresult) {
+        case DEVICE_KERNEL_WAITING_FOR_FEATURE_KERNEL:
+          result = subresult;
+          break;
+
         case DEVICE_KERNEL_FEATURE_KERNEL_INVALID:
         case DEVICE_KERNEL_FEATURE_KERNEL_AVAILABLE:
           return subresult;

intern/cycles/device/device_optix.cpp

@@ -193,9 +193,6 @@ class OptiXDevice : public CUDADevice {
   device_only_memory<unsigned char> denoiser_state;
   int denoiser_input_passes = 0;
 
-  vector<device_only_memory<char>> delayed_free_bvh_memory;
-  thread_mutex delayed_free_bvh_mutex;
-
  public:
   OptiXDevice(DeviceInfo &info_, Stats &stats_, Profiler &profiler_, bool background_)
       : CUDADevice(info_, stats_, profiler_, background_),
@@ -261,8 +258,6 @@ class OptiXDevice : public CUDADevice {
     // Make CUDA context current
     const CUDAContextScope scope(cuContext);
 
-    free_bvh_memory_delayed();
-
     sbt_data.free();
     texture_info.free();
     launch_params.free();
@@ -960,14 +955,21 @@ class OptiXDevice : public CUDADevice {
         // Create OptiX denoiser handle on demand when it is first used
         OptixDenoiserOptions denoiser_options = {};
         assert(task.denoising.input_passes >= 1 && task.denoising.input_passes <= 3);
+#  if OPTIX_ABI_VERSION >= 47
+        denoiser_options.guideAlbedo = task.denoising.input_passes >= 2;
+        denoiser_options.guideNormal = task.denoising.input_passes >= 3;
+        check_result_optix_ret(optixDenoiserCreate(
+            context, OPTIX_DENOISER_MODEL_KIND_HDR, &denoiser_options, &denoiser));
+#  else
         denoiser_options.inputKind = static_cast<OptixDenoiserInputKind>(
             OPTIX_DENOISER_INPUT_RGB + (task.denoising.input_passes - 1));
-#  if OPTIX_ABI_VERSION < 28
+#    if OPTIX_ABI_VERSION < 28
         denoiser_options.pixelFormat = OPTIX_PIXEL_FORMAT_FLOAT3;
-#  endif
+#    endif
         check_result_optix_ret(optixDenoiserCreate(context, &denoiser_options, &denoiser));
         check_result_optix_ret(
             optixDenoiserSetModel(denoiser, OPTIX_DENOISER_MODEL_KIND_HDR, NULL, 0));
+#  endif
 
         // OptiX denoiser handle was created with the requested number of input passes
         denoiser_input_passes = task.denoising.input_passes;
@@ -1037,10 +1039,34 @@ class OptiXDevice : public CUDADevice {
 #  endif
       output_layers[0].format = OPTIX_PIXEL_FORMAT_FLOAT3;
 
+#  if OPTIX_ABI_VERSION >= 47
+      OptixDenoiserLayer image_layers = {};
+      image_layers.input = input_layers[0];
+      image_layers.output = output_layers[0];
+
+      OptixDenoiserGuideLayer guide_layers = {};
+      guide_layers.albedo = input_layers[1];
+      guide_layers.normal = input_layers[2];
+#  endif
+
       // Finally run denonising
       OptixDenoiserParams params = {};  // All parameters are disabled/zero
+#  if OPTIX_ABI_VERSION >= 47
       check_result_optix_ret(optixDenoiserInvoke(denoiser,
-                                                 0,
+                                                 NULL,
+                                                 &params,
+                                                 denoiser_state.device_pointer,
+                                                 scratch_offset,
+                                                 &guide_layers,
+                                                 &image_layers,
+                                                 1,
+                                                 overlap_offset.x,
+                                                 overlap_offset.y,
+                                                 denoiser_state.device_pointer + scratch_offset,
+                                                 scratch_size));
+#  else
+      check_result_optix_ret(optixDenoiserInvoke(denoiser,
+                                                 NULL,
                                                  &params,
                                                  denoiser_state.device_pointer,
                                                  scratch_offset,
@@ -1051,6 +1077,7 @@ class OptiXDevice : public CUDADevice {
                                                  output_layers,
                                                  denoiser_state.device_pointer + scratch_offset,
                                                  scratch_size));
+#  endif
 
 #  if OPTIX_DENOISER_NO_PIXEL_STRIDE
       void *output_args[] = {&input_ptr,
@@ -1270,8 +1297,6 @@ class OptiXDevice : public CUDADevice {
       return;
     }
 
-    free_bvh_memory_delayed();
-
     BVHOptiX *const bvh_optix = static_cast<BVHOptiX *>(bvh);
 
     progress.set_substatus("Building OptiX acceleration structure");
@@ -1742,24 +1767,6 @@ class OptiXDevice : public CUDADevice {
     }
   }
 
-  void release_optix_bvh(BVH *bvh) override
-  {
-    thread_scoped_lock lock(delayed_free_bvh_mutex);
-    /* Do delayed free of BVH memory, since geometry holding BVH might be deleted
-     * while GPU is still rendering. */
-    BVHOptiX *const bvh_optix = static_cast<BVHOptiX *>(bvh);
-
-    delayed_free_bvh_memory.emplace_back(std::move(bvh_optix->as_data));
-    delayed_free_bvh_memory.emplace_back(std::move(bvh_optix->motion_transform_data));
-    bvh_optix->traversable_handle = 0;
-  }
-
-  void free_bvh_memory_delayed()
-  {
-    thread_scoped_lock lock(delayed_free_bvh_mutex);
-    delayed_free_bvh_memory.free_memory();
-  }
-
   void const_copy_to(const char *name, void *host, size_t size) override
   {
     // Set constant memory for CUDA module

intern/cycles/device/opencl/device_opencl.h

@@ -269,6 +269,7 @@ class OpenCLDevice : public Device {
   cl_device_id cdDevice;
   cl_int ciErr;
   int device_num;
+  bool use_preview_kernels;
 
   class OpenCLProgram {
    public:
@@ -368,7 +369,8 @@ class OpenCLDevice : public Device {
     /* Load the kernels and put the created kernels in the given
      * `programs` parameter. */
     void load_kernels(vector<OpenCLProgram *> &programs,
-                      const DeviceRequestedFeatures &requested_features);
+                      const DeviceRequestedFeatures &requested_features,
+                      bool is_preview = false);
   };
 
   DeviceSplitKernel *split_kernel;
@@ -380,6 +382,7 @@ class OpenCLDevice : public Device {
   OpenCLProgram denoising_program;
 
   OpenCLSplitPrograms kernel_programs;
+  OpenCLSplitPrograms preview_programs;
 
   typedef map<string, device_vector<uchar> *> ConstMemMap;
   typedef map<string, device_ptr> MemMap;
@@ -409,6 +412,7 @@ class OpenCLDevice : public Device {
   string device_md5_hash(string kernel_custom_build_options = "");
   bool load_kernels(const DeviceRequestedFeatures &requested_features);
   void load_required_kernels(const DeviceRequestedFeatures &requested_features);
+  void load_preview_kernels();
 
   bool wait_for_availability(const DeviceRequestedFeatures &requested_features);
   DeviceKernelStatus get_active_kernel_switch_state();
@@ -418,7 +422,8 @@ class OpenCLDevice : public Device {
   /* Get the program file name to compile (*.cl) for the given kernel */
   const string get_opencl_program_filename(const string &kernel_name);
   string get_build_options(const DeviceRequestedFeatures &requested_features,
-                           const string &opencl_program_name);
+                           const string &opencl_program_name,
+                           bool preview_kernel = false);
   /* Enable the default features to reduce recompilation events */
   void enable_default_features(DeviceRequestedFeatures &features);
 

intern/cycles/device/opencl/device_opencl_impl.cpp

@@ -107,7 +107,8 @@ void OpenCLDevice::enable_default_features(DeviceRequestedFeatures &features)
 }
 
 string OpenCLDevice::get_build_options(const DeviceRequestedFeatures &requested_features,
-                                       const string &opencl_program_name)
+                                       const string &opencl_program_name,
+                                       bool preview_kernel)
 {
   /* first check for non-split kernel programs */
   if (opencl_program_name == "base" || opencl_program_name == "denoising") {
@@ -184,7 +185,13 @@ string OpenCLDevice::get_build_options(const DeviceRequestedFeatures &requested_
   enable_default_features(nofeatures);
 
   /* Add program specific optimized compile directives */
-  if (opencl_program_name == "split_do_volume" && !requested_features.use_volume) {
+  if (preview_kernel) {
+    DeviceRequestedFeatures preview_features;
+    preview_features.use_hair = true;
+    build_options += "-D__KERNEL_AO_PREVIEW__ ";
+    build_options += preview_features.get_build_options();
+  }
+  else if (opencl_program_name == "split_do_volume" && !requested_features.use_volume) {
     build_options += nofeatures.get_build_options();
   }
   else {
@@ -231,7 +238,9 @@ OpenCLDevice::OpenCLSplitPrograms::~OpenCLSplitPrograms()
 }
 
 void OpenCLDevice::OpenCLSplitPrograms::load_kernels(
-    vector<OpenCLProgram *> &programs, const DeviceRequestedFeatures &requested_features)
+    vector<OpenCLProgram *> &programs,
+    const DeviceRequestedFeatures &requested_features,
+    bool is_preview)
 {
   if (!requested_features.use_baking) {
 #  define ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(kernel_name) \
@@ -242,7 +251,7 @@ void OpenCLDevice::OpenCLSplitPrograms::load_kernels(
         device, \
         program_name_##kernel_name, \
         "kernel_" #kernel_name ".cl", \
-        device->get_build_options(requested_features, program_name_##kernel_name)); \
+        device->get_build_options(requested_features, program_name_##kernel_name, is_preview)); \
     program_##kernel_name.add_kernel(ustring("path_trace_" #kernel_name)); \
     programs.push_back(&program_##kernel_name);
 
@@ -250,7 +259,7 @@ void OpenCLDevice::OpenCLSplitPrograms::load_kernels(
     ADD_SPLIT_KERNEL_PROGRAM(subsurface_scatter);
     ADD_SPLIT_KERNEL_PROGRAM(direct_lighting);
     ADD_SPLIT_KERNEL_PROGRAM(indirect_background);
-    if (requested_features.use_volume) {
+    if (requested_features.use_volume || is_preview) {
       ADD_SPLIT_KERNEL_PROGRAM(do_volume);
     }
     ADD_SPLIT_KERNEL_PROGRAM(shader_eval);
@@ -265,7 +274,7 @@ void OpenCLDevice::OpenCLSplitPrograms::load_kernels(
         device,
         "split_bundle",
         "kernel_split_bundle.cl",
-        device->get_build_options(requested_features, "split_bundle"));
+        device->get_build_options(requested_features, "split_bundle", is_preview));
 
     ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(data_init);
     ADD_SPLIT_KERNEL_BUNDLE_PROGRAM(state_buffer_size);
@@ -394,7 +403,7 @@ class OpenCLSplitKernel : public DeviceSplitKernel {
         device,
         program_name,
         device->get_opencl_program_filename(kernel_name),
-        device->get_build_options(requested_features, program_name));
+        device->get_build_options(requested_features, program_name, device->use_preview_kernels));
 
     kernel->program.add_kernel(ustring("path_trace_" + kernel_name));
     kernel->program.load();
@@ -560,11 +569,6 @@ class OpenCLSplitKernel : public DeviceSplitKernel {
     size_t num_elements = max_elements_for_max_buffer_size(kg, data, max_buffer_size);
     int2 global_size = make_int2(max(round_down((int)sqrt(num_elements), 64), 64),
                                  (int)sqrt(num_elements));
-
-    if (device->info.description.find("Intel") != string::npos) {
-      global_size = make_int2(min(512, global_size.x), min(512, global_size.y));
-    }
-
     VLOG(1) << "Global size: " << global_size << ".";
     return global_size;
   }
@@ -608,6 +612,7 @@ OpenCLDevice::OpenCLDevice(DeviceInfo &info, Stats &stats, Profiler &profiler, b
     : Device(info, stats, profiler, background),
       load_kernel_num_compiling(0),
       kernel_programs(this),
+      preview_programs(this),
       memory_manager(this),
       texture_info(this, "__texture_info", MEM_GLOBAL)
 {
@@ -617,6 +622,7 @@ OpenCLDevice::OpenCLDevice(DeviceInfo &info, Stats &stats, Profiler &profiler, b
   cqCommandQueue = NULL;
   device_initialized = false;
   textures_need_update = true;
+  use_preview_kernels = !background;
 
   vector<OpenCLPlatformDevice> usable_devices;
   OpenCLInfo::get_usable_devices(&usable_devices);
@@ -672,6 +678,9 @@ OpenCLDevice::OpenCLDevice(DeviceInfo &info, Stats &stats, Profiler &profiler, b
   device_initialized = true;
 
   split_kernel = new OpenCLSplitKernel(this);
+  if (use_preview_kernels) {
+    load_preview_kernels();
+  }
 }
 
 OpenCLDevice::~OpenCLDevice()
@@ -762,7 +771,7 @@ bool OpenCLDevice::load_kernels(const DeviceRequestedFeatures &requested_feature
   load_required_kernels(requested_features);
 
   vector<OpenCLProgram *> programs;
-  kernel_programs.load_kernels(programs, requested_features);
+  kernel_programs.load_kernels(programs, requested_features, false);
 
   if (!requested_features.use_baking && requested_features.use_denoising) {
     denoising_program = OpenCLProgram(
@@ -840,6 +849,19 @@ void OpenCLDevice::load_required_kernels(const DeviceRequestedFeatures &requeste
   }
 }
 
+void OpenCLDevice::load_preview_kernels()
+{
+  DeviceRequestedFeatures no_features;
+  vector<OpenCLProgram *> programs;
+  preview_programs.load_kernels(programs, no_features, true);
+
+  foreach (OpenCLProgram *program, programs) {
+    if (!program->load()) {
+      load_required_kernel_task_pool.push(function_bind(&OpenCLProgram::compile, program));
+    }
+  }
+}
+
 bool OpenCLDevice::wait_for_availability(const DeviceRequestedFeatures &requested_features)
 {
   if (requested_features.use_baking) {
@@ -847,18 +869,59 @@ bool OpenCLDevice::wait_for_availability(const DeviceRequestedFeatures &requeste
     return true;
   }
 
-  load_kernel_task_pool.wait_work();
+  if (background) {
+    load_kernel_task_pool.wait_work();
+    use_preview_kernels = false;
+  }
+  else {
+    /* We use a device setting to determine to load preview kernels or not
+     * Better to check on device level than per kernel as mixing preview and
+     * non-preview kernels does not work due to different data types */
+    if (use_preview_kernels) {
+      use_preview_kernels = load_kernel_num_compiling.load() > 0;
+    }
+  }
   return split_kernel->load_kernels(requested_features);
 }
 
 OpenCLDevice::OpenCLSplitPrograms *OpenCLDevice::get_split_programs()
 {
-  return &kernel_programs;
+  return use_preview_kernels ? &preview_programs : &kernel_programs;
 }
 
 DeviceKernelStatus OpenCLDevice::get_active_kernel_switch_state()
 {
-  return DEVICE_KERNEL_USING_FEATURE_KERNEL;
+  /* Do not switch kernels for background renderings
+   * We do foreground rendering but use the preview kernels
+   * Check for the optimized kernels
+   *
+   * This works also the other way around, where we are using
+   * optimized kernels but new ones are being compiled due
+   * to other features that are needed */
+  if (background) {
+    /* The if-statements below would find the same result,
+     * But as the `finished` method uses a mutex we added
+     * this as an early exit */
+    return DEVICE_KERNEL_USING_FEATURE_KERNEL;
+  }
+
+  bool other_kernels_finished = load_kernel_num_compiling.load() == 0;
+  if (use_preview_kernels) {
+    if (other_kernels_finished) {
+      return DEVICE_KERNEL_FEATURE_KERNEL_AVAILABLE;
+    }
+    else {
+      return DEVICE_KERNEL_WAITING_FOR_FEATURE_KERNEL;
+    }
+  }
+  else {
+    if (other_kernels_finished) {
+      return DEVICE_KERNEL_USING_FEATURE_KERNEL;
+    }
+    else {
+      return DEVICE_KERNEL_FEATURE_KERNEL_INVALID;
+    }
+  }
 }
 
 void OpenCLDevice::mem_alloc(device_memory &mem)

intern/cycles/graph/node_type.h

@@ -148,17 +148,16 @@ struct NodeType {
 #define NODE_DECLARE \
   static const NodeType *get_node_type(); \
   template<typename T> static const NodeType *register_type(); \
-  static Node *create(const NodeType *type); \
-  static const NodeType *node_type;
+  static Node *create(const NodeType *type);
 
 #define NODE_DEFINE(structname) \
-  const NodeType *structname::node_type = structname::register_type<structname>(); \
   Node *structname::create(const NodeType *) \
   { \
     return new structname(); \
   } \
   const NodeType *structname::get_node_type() \
   { \
+    static const NodeType *node_type = register_type<structname>(); \
     return node_type; \
   } \
   template<typename T> const NodeType *structname::register_type()
@@ -170,8 +169,6 @@ struct NodeType {
 #define NODE_ABSTRACT_DEFINE(structname) \
   const NodeType *structname::get_node_base_type() \
   { \
-    /* Base types constructed in this getter to ensure correct initialization \
-     * order. Regular types are not so they are auto-registered for XML parsing. */ \
     static const NodeType *node_base_type = register_base_type<structname>(); \
     return node_base_type; \
   } \

intern/cycles/kernel/CMakeLists.txt

@@ -93,6 +93,7 @@ set(SRC_BVH_HEADERS
   bvh/bvh_local.h
   bvh/bvh_traversal.h
   bvh/bvh_types.h
+  bvh/bvh_util.h
   bvh/bvh_volume.h
   bvh/bvh_volume_all.h
   bvh/bvh_embree.h

intern/cycles/kernel/bvh/bvh.h

@@ -29,9 +29,10 @@
 #  include "kernel/bvh/bvh_embree.h"
 #endif
 
-CCL_NAMESPACE_BEGIN
-
 #include "kernel/bvh/bvh_types.h"
+#include "kernel/bvh/bvh_util.h"
+
+CCL_NAMESPACE_BEGIN
 
 #ifndef __KERNEL_OPTIX__
 
@@ -533,97 +534,4 @@ ccl_device_intersect uint scene_intersect_volume_all(KernelGlobals *kg,
 }
 #endif /* __VOLUME_RECORD_ALL__ */
 
-/* Ray offset to avoid self intersection.
- *
- * This function should be used to compute a modified ray start position for
- * rays leaving from a surface. */
-
-ccl_device_inline float3 ray_offset(float3 P, float3 Ng)
-{
-#ifdef __INTERSECTION_REFINE__
-  const float epsilon_f = 1e-5f;
-  /* ideally this should match epsilon_f, but instancing and motion blur
-   * precision makes it problematic */
-  const float epsilon_test = 1.0f;
-  const int epsilon_i = 32;
-
-  float3 res;
-
-  /* x component */
-  if (fabsf(P.x) < epsilon_test) {
-    res.x = P.x + Ng.x * epsilon_f;
-  }
-  else {
-    uint ix = __float_as_uint(P.x);
-    ix += ((ix ^ __float_as_uint(Ng.x)) >> 31) ? -epsilon_i : epsilon_i;
-    res.x = __uint_as_float(ix);
-  }
-
-  /* y component */
-  if (fabsf(P.y) < epsilon_test) {
-    res.y = P.y + Ng.y * epsilon_f;
-  }
-  else {
-    uint iy = __float_as_uint(P.y);
-    iy += ((iy ^ __float_as_uint(Ng.y)) >> 31) ? -epsilon_i : epsilon_i;
-    res.y = __uint_as_float(iy);
-  }
-
-  /* z component */
-  if (fabsf(P.z) < epsilon_test) {
-    res.z = P.z + Ng.z * epsilon_f;
-  }
-  else {
-    uint iz = __float_as_uint(P.z);
-    iz += ((iz ^ __float_as_uint(Ng.z)) >> 31) ? -epsilon_i : epsilon_i;
-    res.z = __uint_as_float(iz);
-  }
-
-  return res;
-#else
-  const float epsilon_f = 1e-4f;
-  return P + epsilon_f * Ng;
-#endif
-}
-
-#if defined(__VOLUME_RECORD_ALL__) || (defined(__SHADOW_RECORD_ALL__) && defined(__KERNEL_CPU__))
-/* ToDo: Move to another file? */
-ccl_device int intersections_compare(const void *a, const void *b)
-{
-  const Intersection *isect_a = (const Intersection *)a;
-  const Intersection *isect_b = (const Intersection *)b;
-
-  if (isect_a->t < isect_b->t)
-    return -1;
-  else if (isect_a->t > isect_b->t)
-    return 1;
-  else
-    return 0;
-}
-#endif
-
-#if defined(__SHADOW_RECORD_ALL__)
-ccl_device_inline void sort_intersections(Intersection *hits, uint num_hits)
-{
-#  ifdef __KERNEL_GPU__
-  /* Use bubble sort which has more friendly memory pattern on GPU. */
-  bool swapped;
-  do {
-    swapped = false;
-    for (int j = 0; j < num_hits - 1; ++j) {
-      if (hits[j].t > hits[j + 1].t) {
-        struct Intersection tmp = hits[j];
-        hits[j] = hits[j + 1];
-        hits[j + 1] = tmp;
-        swapped = true;
-      }
-    }
-    --num_hits;
-  } while (swapped);
-#  else
-  qsort(hits, num_hits, sizeof(Intersection), intersections_compare);
-#  endif
-}
-#endif /* __SHADOW_RECORD_ALL__ | __VOLUME_RECORD_ALL__ */
-
 CCL_NAMESPACE_END

intern/cycles/kernel/bvh/bvh_shadow_all.h

@@ -180,25 +180,10 @@ ccl_device_inline
 
               /* todo: optimize so primitive visibility flag indicates if
                * the primitive has a transparent shadow shader? */
-              int prim = kernel_tex_fetch(__prim_index, isect_array->prim);
-              int shader = 0;
-
-#ifdef __HAIR__
-              if (kernel_tex_fetch(__prim_type, isect_array->prim) & PRIMITIVE_ALL_TRIANGLE)
-#endif
-              {
-                shader = kernel_tex_fetch(__tri_shader, prim);
-              }
-#ifdef __HAIR__
-              else {
-                float4 str = kernel_tex_fetch(__curves, prim);
-                shader = __float_as_int(str.z);
-              }
-#endif
-              int flag = kernel_tex_fetch(__shaders, (shader & SHADER_MASK)).flags;
+              const int flags = intersection_get_shader_flags(kg, isect_array);
 
               /* if no transparent shadows, all light is blocked */
-              if (!(flag & SD_HAS_TRANSPARENT_SHADOW)) {
+              if (!(flags & SD_HAS_TRANSPARENT_SHADOW)) {
                 return true;
               }
               /* if maximum number of hits reached, block all light */

intern/cycles/kernel/bvh/bvh_util.h

@@ -0,0 +1,162 @@
+/*
+ * Copyright 2011-2013 Blender Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+CCL_NAMESPACE_BEGIN
+
+/* Ray offset to avoid self intersection.
+ *
+ * This function should be used to compute a modified ray start position for
+ * rays leaving from a surface. */
+
+ccl_device_inline float3 ray_offset(float3 P, float3 Ng)
+{
+#ifdef __INTERSECTION_REFINE__
+  const float epsilon_f = 1e-5f;
+  /* ideally this should match epsilon_f, but instancing and motion blur
+   * precision makes it problematic */
+  const float epsilon_test = 1.0f;
+  const int epsilon_i = 32;
+
+  float3 res;
+
+  /* x component */
+  if (fabsf(P.x) < epsilon_test) {
+    res.x = P.x + Ng.x * epsilon_f;
+  }
+  else {
+    uint ix = __float_as_uint(P.x);
+    ix += ((ix ^ __float_as_uint(Ng.x)) >> 31) ? -epsilon_i : epsilon_i;
+    res.x = __uint_as_float(ix);
+  }
+
+  /* y component */
+  if (fabsf(P.y) < epsilon_test) {
+    res.y = P.y + Ng.y * epsilon_f;
+  }
+  else {
+    uint iy = __float_as_uint(P.y);
+    iy += ((iy ^ __float_as_uint(Ng.y)) >> 31) ? -epsilon_i : epsilon_i;
+    res.y = __uint_as_float(iy);
+  }
+
+  /* z component */
+  if (fabsf(P.z) < epsilon_test) {
+    res.z = P.z + Ng.z * epsilon_f;
+  }
+  else {
+    uint iz = __float_as_uint(P.z);
+    iz += ((iz ^ __float_as_uint(Ng.z)) >> 31) ? -epsilon_i : epsilon_i;
+    res.z = __uint_as_float(iz);
+  }
+
+  return res;
+#else
+  const float epsilon_f = 1e-4f;
+  return P + epsilon_f * Ng;
+#endif
+}
+
+#if defined(__VOLUME_RECORD_ALL__) || (defined(__SHADOW_RECORD_ALL__) && defined(__KERNEL_CPU__))
+/* ToDo: Move to another file? */
+ccl_device int intersections_compare(const void *a, const void *b)
+{
+  const Intersection *isect_a = (const Intersection *)a;
+  const Intersection *isect_b = (const Intersection *)b;
+
+  if (isect_a->t < isect_b->t)
+    return -1;
+  else if (isect_a->t > isect_b->t)
+    return 1;
+  else
+    return 0;
+}
+#endif
+
+#if defined(__SHADOW_RECORD_ALL__)
+ccl_device_inline void sort_intersections(Intersection *hits, uint num_hits)
+{
+  kernel_assert(num_hits > 0);
+
+#  ifdef __KERNEL_GPU__
+  /* Use bubble sort which has more friendly memory pattern on GPU. */
+  bool swapped;
+  do {
+    swapped = false;
+    for (int j = 0; j < num_hits - 1; ++j) {
+      if (hits[j].t > hits[j + 1].t) {
+        struct Intersection tmp = hits[j];
+        hits[j] = hits[j + 1];
+        hits[j + 1] = tmp;
+        swapped = true;
+      }
+    }
+    --num_hits;
+  } while (swapped);
+#  else
+  qsort(hits, num_hits, sizeof(Intersection), intersections_compare);
+#  endif
+}
+#endif /* __SHADOW_RECORD_ALL__ | __VOLUME_RECORD_ALL__ */
+
+/* Utility to quickly get a shader flags from an intersection. */
+
+ccl_device_forceinline int intersection_get_shader_flags(KernelGlobals *ccl_restrict kg,
+                                                         const Intersection *isect)
+{
+  const int prim = kernel_tex_fetch(__prim_index, isect->prim);
+  int shader = 0;
+
+#ifdef __HAIR__
+  if (kernel_tex_fetch(__prim_type, isect->prim) & PRIMITIVE_ALL_TRIANGLE)
+#endif
+  {
+    shader = kernel_tex_fetch(__tri_shader, prim);
+  }
+#ifdef __HAIR__
+  else {
+    float4 str = kernel_tex_fetch(__curves, prim);
+    shader = __float_as_int(str.z);
+  }
+#endif
+
+  return kernel_tex_fetch(__shaders, (shader & SHADER_MASK)).flags;
+}
+
+ccl_device_forceinline int intersection_get_shader(KernelGlobals *ccl_restrict kg,
+                                                   const Intersection *isect)
+{
+  const int prim = kernel_tex_fetch(__prim_index, isect->prim);
+  int shader = 0;
+
+#ifdef __HAIR__
+  if (kernel_tex_fetch(__prim_type, isect->prim) & PRIMITIVE_ALL_TRIANGLE)
+#endif
+  {
+    shader = kernel_tex_fetch(__tri_shader, prim);
+  }
+#ifdef __HAIR__
+  else {
+    float4 str = kernel_tex_fetch(__curves, prim);
+    shader = __float_as_int(str.z);
+  }
+#endif
+
+  return shader & SHADER_MASK;
+}
+
+CCL_NAMESPACE_END

intern/cycles/kernel/closure/alloc.h

@@ -57,24 +57,14 @@ ccl_device ccl_addr_space void *closure_alloc_extra(ShaderData *sd, int size)
 
 ccl_device_inline ShaderClosure *bsdf_alloc(ShaderData *sd, int size, float3 weight)
 {
-  kernel_assert(isfinite3_safe(weight));
+  ShaderClosure *sc = closure_alloc(sd, size, CLOSURE_NONE_ID, weight);
 
-  const float sample_weight = fabsf(average(weight));
+  if (sc == NULL)
+    return NULL;
 
-  /* Use comparison this way to help dealing with non-finite weight: if the average is not finite
-   * we will not allocate new closure. */
-  if (sample_weight >= CLOSURE_WEIGHT_CUTOFF) {
-    ShaderClosure *sc = closure_alloc(sd, size, CLOSURE_NONE_ID, weight);
-    if (sc == NULL) {
-      return NULL;
-    }
-
-    sc->sample_weight = sample_weight;
-
-    return sc;
-  }
-
-  return NULL;
+  float sample_weight = fabsf(average(weight));
+  sc->sample_weight = sample_weight;
+  return (sample_weight >= CLOSURE_WEIGHT_CUTOFF) ? sc : NULL;
 }
 
 #ifdef __OSL__
@@ -83,27 +73,17 @@ ccl_device_inline ShaderClosure *bsdf_alloc_osl(ShaderData *sd,
                                                 float3 weight,
                                                 void *data)
 {
-  kernel_assert(isfinite3_safe(weight));
+  ShaderClosure *sc = closure_alloc(sd, size, CLOSURE_NONE_ID, weight);
 
-  const float sample_weight = fabsf(average(weight));
+  if (!sc)
+    return NULL;
 
-  /* Use comparison this way to help dealing with non-finite weight: if the average is not finite
-   * we will not allocate new closure. */
-  if (sample_weight >= CLOSURE_WEIGHT_CUTOFF) {
-    ShaderClosure *sc = closure_alloc(sd, size, CLOSURE_NONE_ID, weight);
-    if (!sc) {
-      return NULL;
-    }
+  memcpy((void *)sc, data, size);
 
-    memcpy((void *)sc, data, size);
-
-    sc->weight = weight;
-    sc->sample_weight = sample_weight;
-
-    return sc;
-  }
-
-  return NULL;
+  float sample_weight = fabsf(average(weight));
+  sc->weight = weight;
+  sc->sample_weight = sample_weight;
+  return (sample_weight >= CLOSURE_WEIGHT_CUTOFF) ? sc : NULL;
 }
 #endif
 

intern/cycles/kernel/kernel_light_common.h

@@ -200,12 +200,12 @@ ccl_device bool light_spread_clamp_area_light(const float3 P,
    * uv coordinates. */
   const float new_center_u = 0.5f * (min_u + max_u);
   const float new_center_v = 0.5f * (min_v + max_v);
-  const float new_len_u = max_u - min_u;
-  const float new_len_v = max_v - min_v;
+  const float new_len_u = 0.5f * (max_u - min_u);
+  const float new_len_v = 0.5f * (max_v - min_v);
 
   *lightP = *lightP + new_center_u * u + new_center_v * v;
-  *axisu = u * new_len_u;
-  *axisv = v * new_len_v;
+  *axisu = u * new_len_u * 2.0f;
+  *axisv = v * new_len_v * 2.0f;
 
   return true;
 }

intern/cycles/kernel/kernel_montecarlo.h

@@ -195,108 +195,31 @@ ccl_device float2 regular_polygon_sample(float corners, float rotation, float u,
 
 ccl_device float3 ensure_valid_reflection(float3 Ng, float3 I, float3 N)
 {
-  float3 R = 2 * dot(N, I) * N - I;
+  float3 R;
+  float NI = dot(N, I);
+  float NgR, threshold;
 
-  /* Reflection rays may always be at least as shallow as the incoming ray. */
-  float threshold = min(0.9f * dot(Ng, I), 0.01f);
-  if (dot(Ng, R) >= threshold) {
-    return N;
-  }
+  /* Check if the incident ray is coming from behind normal N. */
+  if (NI > 0) {
+    /* Normal reflection */
+    R = (2 * NI) * N - I;
+    NgR = dot(Ng, R);
 
-  /* Form coordinate system with Ng as the Z axis and N inside the X-Z-plane.
-   * The X axis is found by normalizing the component of N that's orthogonal to Ng.
-   * The Y axis isn't actually needed.
-   */
-  float NdotNg = dot(N, Ng);
-  float3 X = normalize(N - NdotNg * Ng);
-
-  /* Keep math expressions. */
-  /* clang-format off */
-  /* Calculate N.z and N.x in the local coordinate system.
-   *
-   * The goal of this computation is to find a N' that is rotated towards Ng just enough
-   * to lift R' above the threshold (here called t), therefore dot(R', Ng) = t.
-   *
-   * According to the standard reflection equation,
-   * this means that we want dot(2*dot(N', I)*N' - I, Ng) = t.
-   *
-   * Since the Z axis of our local coordinate system is Ng, dot(x, Ng) is just x.z, so we get
-   * 2*dot(N', I)*N'.z - I.z = t.
-   *
-   * The rotation is simple to express in the coordinate system we formed -
-   * since N lies in the X-Z-plane, we know that N' will also lie in the X-Z-plane,
-   * so N'.y = 0 and therefore dot(N', I) = N'.x*I.x + N'.z*I.z .
-   *
-   * Furthermore, we want N' to be normalized, so N'.x = sqrt(1 - N'.z^2).
-   *
-   * With these simplifications,
-   * we get the final equation 2*(sqrt(1 - N'.z^2)*I.x + N'.z*I.z)*N'.z - I.z = t.
-   *
-   * The only unknown here is N'.z, so we can solve for that.
-   *
-   * The equation has four solutions in general:
-   *
-   * N'.z = +-sqrt(0.5*(+-sqrt(I.x^2*(I.x^2 + I.z^2 - t^2)) + t*I.z + I.x^2 + I.z^2)/(I.x^2 + I.z^2))
-   * We can simplify this expression a bit by grouping terms:
-   *
-   * a = I.x^2 + I.z^2
-   * b = sqrt(I.x^2 * (a - t^2))
-   * c = I.z*t + a
-   * N'.z = +-sqrt(0.5*(+-b + c)/a)
-   *
-   * Two solutions can immediately be discarded because they're negative so N' would lie in the
-   * lower hemisphere.
-   */
-  /* clang-format on */
-
-  float Ix = dot(I, X), Iz = dot(I, Ng);
-  float Ix2 = sqr(Ix), Iz2 = sqr(Iz);
-  float a = Ix2 + Iz2;
-
-  float b = safe_sqrtf(Ix2 * (a - sqr(threshold)));
-  float c = Iz * threshold + a;
-
-  /* Evaluate both solutions.
-   * In many cases one can be immediately discarded (if N'.z would be imaginary or larger than
-   * one), so check for that first. If no option is viable (might happen in extreme cases like N
-   * being in the wrong hemisphere), give up and return Ng. */
-  float fac = 0.5f / a;
-  float N1_z2 = fac * (b + c), N2_z2 = fac * (-b + c);
-  bool valid1 = (N1_z2 > 1e-5f) && (N1_z2 <= (1.0f + 1e-5f));
-  bool valid2 = (N2_z2 > 1e-5f) && (N2_z2 <= (1.0f + 1e-5f));
-
-  float2 N_new;
-  if (valid1 && valid2) {
-    /* If both are possible, do the expensive reflection-based check. */
-    float2 N1 = make_float2(safe_sqrtf(1.0f - N1_z2), safe_sqrtf(N1_z2));
-    float2 N2 = make_float2(safe_sqrtf(1.0f - N2_z2), safe_sqrtf(N2_z2));
-
-    float R1 = 2 * (N1.x * Ix + N1.y * Iz) * N1.y - Iz;
-    float R2 = 2 * (N2.x * Ix + N2.y * Iz) * N2.y - Iz;
-
-    valid1 = (R1 >= 1e-5f);
-    valid2 = (R2 >= 1e-5f);
-    if (valid1 && valid2) {
-      /* If both solutions are valid, return the one with the shallower reflection since it will be
-       * closer to the input (if the original reflection wasn't shallow, we would not be in this
-       * part of the function). */
-      N_new = (R1 < R2) ? N1 : N2;
+    /* Reflection rays may always be at least as shallow as the incoming ray. */
+    threshold = min(0.9f * dot(Ng, I), 0.01f);
+    if (NgR >= threshold) {
+      return N;
     }
-    else {
-      /* If only one reflection is valid (= positive), pick that one. */
-      N_new = (R1 > R2) ? N1 : N2;
-    }
-  }
-  else if (valid1 || valid2) {
-    /* Only one solution passes the N'.z criterium, so pick that one. */
-    float Nz2 = valid1 ? N1_z2 : N2_z2;
-    N_new = make_float2(safe_sqrtf(1.0f - Nz2), safe_sqrtf(Nz2));
   }
   else {
-    return Ng;
+    /* Bad incident */
+    R = -I;
+    NgR = dot(Ng, R);
+    threshold = 0.01f;
   }
 
-  return N_new.x * X + N_new.y * Ng;
+  R = R + Ng * (threshold - NgR);            /* Lift the reflection above the threshold. */
+  return normalize(I * len(R) + R * len(I)); /* Find a bisector. */
 }
 
 CCL_NAMESPACE_END

intern/cycles/kernel/kernel_path.h

@@ -65,7 +65,6 @@ ccl_device_forceinline bool kernel_path_scene_intersect(KernelGlobals *kg,
   uint visibility = path_state_ray_visibility(kg, state);
 
   if (path_state_ao_bounce(kg, state)) {
-    visibility = PATH_RAY_SHADOW;
     ray->t = kernel_data.background.ao_distance;
   }
 
@@ -416,7 +415,13 @@ ccl_device void kernel_path_indirect(KernelGlobals *kg,
         break;
       }
       else if (path_state_ao_bounce(kg, state)) {
-        break;
+        if (intersection_get_shader_flags(kg, &isect) &
+            (SD_HAS_TRANSPARENT_SHADOW | SD_HAS_EMISSION)) {
+          state->flag |= PATH_RAY_TERMINATE_AFTER_TRANSPARENT;
+        }
+        else {
+          break;
+        }
       }
 
       /* Setup shader data. */
@@ -554,7 +559,13 @@ ccl_device_forceinline void kernel_path_integrate(KernelGlobals *kg,
         break;
       }
       else if (path_state_ao_bounce(kg, state)) {
-        break;
+        if (intersection_get_shader_flags(kg, &isect) &
+            (SD_HAS_TRANSPARENT_SHADOW | SD_HAS_EMISSION)) {
+          state->flag |= PATH_RAY_TERMINATE_AFTER_TRANSPARENT;
+        }
+        else {
+          break;
+        }
       }
 
       /* Setup shader data. */

intern/cycles/kernel/kernel_subsurface.h

@@ -25,9 +25,8 @@ CCL_NAMESPACE_BEGIN
 ccl_device_inline float3
 subsurface_scatter_eval(ShaderData *sd, const ShaderClosure *sc, float disk_r, float r, bool all)
 {
-  /* This is the Veach one-sample model with balance heuristic, some pdf
-   * factors drop out when using balance heuristic weighting. For branched
-   * path tracing (all) we sample all closure and don't use MIS. */
+  /* this is the veach one-sample model with balance heuristic, some pdf
+   * factors drop out when using balance heuristic weighting */
   float3 eval_sum = zero_float3();
   float pdf_sum = 0.0f;
   float sample_weight_inv = 0.0f;
@@ -66,30 +65,6 @@ subsurface_scatter_eval(ShaderData *sd, const ShaderClosure *sc, float disk_r, f
   return (pdf_sum > 0.0f) ? eval_sum / pdf_sum : zero_float3();
 }
 
-ccl_device_inline float3 subsurface_scatter_walk_eval(ShaderData *sd,
-                                                      const ShaderClosure *sc,
-                                                      float3 throughput,
-                                                      bool all)
-{
-  /* This is the Veach one-sample model with balance heuristic, some pdf
-   * factors drop out when using balance heuristic weighting. For branched
-   * path tracing (all) we sample all closure and don't use MIS. */
-  if (!all) {
-    float bssrdf_weight = 0.0f;
-    float weight = sc->sample_weight;
-
-    for (int i = 0; i < sd->num_closure; i++) {
-      sc = &sd->closure[i];
-
-      if (CLOSURE_IS_BSSRDF(sc->type)) {
-        bssrdf_weight += sc->sample_weight;
-      }
-    }
-    throughput *= bssrdf_weight / weight;
-  }
-  return throughput;
-}
-
 /* replace closures with a single diffuse bsdf closure after scatter step */
 ccl_device void subsurface_scatter_setup_diffuse_bsdf(
     KernelGlobals *kg, ShaderData *sd, ClosureType type, float roughness, float3 weight, float3 N)
@@ -462,8 +437,7 @@ ccl_device_noinline
                            ccl_addr_space PathState *state,
                            const ShaderClosure *sc,
                            const float bssrdf_u,
-                           const float bssrdf_v,
-                           bool all)
+                           const float bssrdf_v)
 {
   /* Sample diffuse surface scatter into the object. */
   float3 D;
@@ -632,10 +606,10 @@ ccl_device_noinline
       t = ray->t;
     }
     else if (bounce == 0) {
-      /* Restore original position if nothing was hit after the first bounce,
-       * without the ray_offset() that was added to avoid self-intersection.
-       * Otherwise if that offset is relatively large compared to the scattering
-       * radius, we never go back up high enough to exit the surface. */
+      /* Restore original position if nothing was hit after the first bounce.
+       * Otherwise if the ray_offset() to avoid self-intersection is relatively
+       * large compared to the scattering radius, we go never backup high enough
+       * to exit the surface. */
       ray->P = sd->P;
     }
 
@@ -695,7 +669,7 @@ ccl_device_noinline
   /* TODO: gain back performance lost from merging with disk BSSRDF. We
    * only need to return on hit so this indirect ray push/pop overhead
    * is not actually needed, but it does keep the code simpler. */
-  ss_isect->weight[0] = subsurface_scatter_walk_eval(sd, sc, throughput, all);
+  ss_isect->weight[0] = throughput;
 #ifdef __SPLIT_KERNEL__
   ss_isect->ray = *ray;
 #endif
@@ -717,7 +691,7 @@ ccl_device_inline int subsurface_scatter_multi_intersect(KernelGlobals *kg,
     return subsurface_scatter_disk(kg, ss_isect, sd, sc, lcg_state, bssrdf_u, bssrdf_v, all);
   }
   else {
-    return subsurface_random_walk(kg, ss_isect, sd, state, sc, bssrdf_u, bssrdf_v, all);
+    return subsurface_random_walk(kg, ss_isect, sd, state, sc, bssrdf_u, bssrdf_v);
   }
 }
 

intern/cycles/kernel/kernel_types.h

@@ -99,23 +99,27 @@ CCL_NAMESPACE_BEGIN
 #define __AO__
 #define __PASSES__
 #define __HAIR__
-#define __SVM__
-#define __EMISSION__
-#define __HOLDOUT__
-#define __MULTI_CLOSURE__
-#define __TRANSPARENT_SHADOWS__
-#define __BACKGROUND_MIS__
-#define __LAMP_MIS__
-#define __CAMERA_MOTION__
-#define __OBJECT_MOTION__
-#define __BAKING__
-#define __PRINCIPLED__
-#define __SUBSURFACE__
-#define __VOLUME__
-#define __VOLUME_SCATTER__
-#define __CMJ__
-#define __SHADOW_RECORD_ALL__
-#define __BRANCHED_PATH__
+
+/* Without these we get an AO render, used by OpenCL preview kernel. */
+#ifndef __KERNEL_AO_PREVIEW__
+#  define __SVM__
+#  define __EMISSION__
+#  define __HOLDOUT__
+#  define __MULTI_CLOSURE__
+#  define __TRANSPARENT_SHADOWS__
+#  define __BACKGROUND_MIS__
+#  define __LAMP_MIS__
+#  define __CAMERA_MOTION__
+#  define __OBJECT_MOTION__
+#  define __BAKING__
+#  define __PRINCIPLED__
+#  define __SUBSURFACE__
+#  define __VOLUME__
+#  define __VOLUME_SCATTER__
+#  define __CMJ__
+#  define __SHADOW_RECORD_ALL__
+#  define __BRANCHED_PATH__
+#endif
 
 /* Device specific features */
 #ifdef __KERNEL_CPU__
@@ -891,6 +895,8 @@ enum ShaderDataFlag {
   SD_HAS_CONSTANT_EMISSION = (1 << 27),
   /* Needs to access attributes for volume rendering */
   SD_NEED_VOLUME_ATTRIBUTES = (1 << 28),
+  /* Shader has emission */
+  SD_HAS_EMISSION = (1 << 29),
 
   SD_SHADER_FLAGS = (SD_USE_MIS | SD_HAS_TRANSPARENT_SHADOW | SD_HAS_VOLUME | SD_HAS_ONLY_VOLUME |
                      SD_HETEROGENEOUS_VOLUME | SD_HAS_BSSRDF_BUMP | SD_VOLUME_EQUIANGULAR |

intern/cycles/kernel/shaders/stdcycles.h

@@ -84,67 +84,30 @@ closure color principled_hair(normal N,
 closure color henyey_greenstein(float g) BUILTIN;
 closure color absorption() BUILTIN;
 
-normal ensure_valid_reflection(normal Ng, vector I, normal N)
+normal ensure_valid_reflection(normal Ng, normal I, normal N)
 {
   /* The implementation here mirrors the one in kernel_montecarlo.h,
    * check there for an explanation of the algorithm. */
+  vector R;
+  float NI = dot(N, I);
+  float NgR, threshold;
 
-  float sqr(float x)
-  {
-    return x * x;
-  }
-
-  vector R = 2 * dot(N, I) * N - I;
-
-  float threshold = min(0.9 * dot(Ng, I), 0.01);
-  if (dot(Ng, R) >= threshold) {
-    return N;
-  }
-
-  float NdotNg = dot(N, Ng);
-  vector X = normalize(N - NdotNg * Ng);
-
-  float Ix = dot(I, X), Iz = dot(I, Ng);
-  float Ix2 = sqr(Ix), Iz2 = sqr(Iz);
-  float a = Ix2 + Iz2;
-
-  float b = sqrt(Ix2 * (a - sqr(threshold)));
-  float c = Iz * threshold + a;
-
-  float fac = 0.5 / a;
-  float N1_z2 = fac * (b + c), N2_z2 = fac * (-b + c);
-  int valid1 = (N1_z2 > 1e-5) && (N1_z2 <= (1.0 + 1e-5));
-  int valid2 = (N2_z2 > 1e-5) && (N2_z2 <= (1.0 + 1e-5));
-
-  float N_new_x, N_new_z;
-  if (valid1 && valid2) {
-    float N1_x = sqrt(1.0 - N1_z2), N1_z = sqrt(N1_z2);
-    float N2_x = sqrt(1.0 - N2_z2), N2_z = sqrt(N2_z2);
-
-    float R1 = 2 * (N1_x * Ix + N1_z * Iz) * N1_z - Iz;
-    float R2 = 2 * (N2_x * Ix + N2_z * Iz) * N2_z - Iz;
-
-    valid1 = (R1 >= 1e-5);
-    valid2 = (R2 >= 1e-5);
-    if (valid1 && valid2) {
-      N_new_x = (R1 < R2) ? N1_x : N2_x;
-      N_new_z = (R1 < R2) ? N1_z : N2_z;
+  if (NI > 0) {
+    R = (2 * NI) * N - I;
+    NgR = dot(Ng, R);
+    threshold = min(0.9 * dot(Ng, I), 0.01);
+    if (NgR >= threshold) {
+      return N;
     }
-    else {
-      N_new_x = (R1 > R2) ? N1_x : N2_x;
-      N_new_z = (R1 > R2) ? N1_z : N2_z;
-    }
-  }
-  else if (valid1 || valid2) {
-    float Nz2 = valid1 ? N1_z2 : N2_z2;
-    N_new_x = sqrt(1.0 - Nz2);
-    N_new_z = sqrt(Nz2);
   }
   else {
-    return Ng;
+    R = -I;
+    NgR = dot(Ng, R);
+    threshold = 0.01;
   }
 
-  return N_new_x * X + N_new_z * Ng;
+  R = R + Ng * (threshold - NgR);
+  return normalize(I * length(R) + R * length(I));
 }
 
 #endif /* CCL_STDOSL_H */

intern/cycles/kernel/svm/svm_tex_coord.h

@@ -370,13 +370,10 @@ ccl_device void svm_node_tangent(KernelGlobals *kg, ShaderData *sd, float *stack
 
   if (direction_type == NODE_TANGENT_UVMAP) {
     /* UV map */
-    if (desc.offset == ATTR_STD_NOT_FOUND) {
-      stack_store_float3(stack, tangent_offset, zero_float3());
-      return;
-    }
-    else {
+    if (desc.offset == ATTR_STD_NOT_FOUND)
+      tangent = make_float3(0.0f, 0.0f, 0.0f);
+    else
       tangent = attribute_value;
-    }
   }
   else {
     /* radial */

intern/cycles/render/attribute.cpp

@@ -689,9 +689,6 @@ void AttributeSet::update(AttributeSet &&new_attributes)
 
     it++;
   }
-
-  /* If all attributes were replaced, transform is no longer applied. */
-  geometry->transform_applied = false;
 }
 
 void AttributeSet::clear_modified()

intern/cycles/render/geometry.cpp

@@ -46,12 +46,6 @@ CCL_NAMESPACE_BEGIN
 
 /* Geometry */
 
-PackFlags operator|=(PackFlags &pack_flags, uint32_t value)
-{
-  pack_flags = (PackFlags)((uint32_t)pack_flags | value);
-  return pack_flags;
-}
-
 NODE_ABSTRACT_DEFINE(Geometry)
 {
   NodeType *type = NodeType::add("geometry_base", NULL);
@@ -1241,16 +1235,7 @@ void GeometryManager::device_update_bvh(Device *device,
 
   const bool can_refit = scene->bvh != nullptr &&
                          (bparams.bvh_layout == BVHLayout::BVH_LAYOUT_OPTIX);
-
-  PackFlags pack_flags = PackFlags::PACK_NONE;
-
-  if (scene->bvh == nullptr) {
-    pack_flags |= PackFlags::PACK_ALL;
-  }
-
-  if (dscene->prim_visibility.is_modified()) {
-    pack_flags |= PackFlags::PACK_VISIBILITY;
-  }
+  const bool pack_all = scene->bvh == nullptr;
 
   BVH *bvh = scene->bvh;
   if (!scene->bvh) {
@@ -1288,14 +1273,10 @@ void GeometryManager::device_update_bvh(Device *device,
 
     pack.root_index = -1;
 
-    if (pack_flags != PackFlags::PACK_ALL) {
+    if (!pack_all) {
       /* if we do not need to recreate the BVH, then only the vertices are updated, so we can
        * safely retake the memory */
       dscene->prim_tri_verts.give_data(pack.prim_tri_verts);
-
-      if ((pack_flags & PackFlags::PACK_VISIBILITY) != 0) {
-        dscene->prim_visibility.give_data(pack.prim_visibility);
-      }
     }
     else {
       /* It is not strictly necessary to skip those resizes we if do not have to repack, as the OS
@@ -1324,21 +1305,13 @@ void GeometryManager::device_update_bvh(Device *device,
     // Iterate over scene mesh list instead of objects, since 'optix_prim_offset' was calculated
     // based on that list, which may be ordered differently from the object list.
     foreach (Geometry *geom, scene->geometry) {
-      /* Make a copy of the pack_flags so the current geometry's flags do not pollute the others'.
-       */
-      PackFlags geom_pack_flags = pack_flags;
-
-      if (geom->is_modified()) {
-        geom_pack_flags |= PackFlags::PACK_VERTICES;
-      }
-
-      if (geom_pack_flags == PACK_NONE) {
+      if (!pack_all && !geom->is_modified()) {
         continue;
       }
 
       const pair<int, uint> &info = geometry_to_object_info[geom];
       pool.push(function_bind(
-          &Geometry::pack_primitives, geom, &pack, info.first, info.second, geom_pack_flags));
+          &Geometry::pack_primitives, geom, &pack, info.first, info.second, pack_all));
     }
     pool.wait_work();
   }
@@ -1373,7 +1346,7 @@ void GeometryManager::device_update_bvh(Device *device,
     dscene->prim_type.steal_data(pack.prim_type);
     dscene->prim_type.copy_to_device();
   }
-  if (pack.prim_visibility.size() && (dscene->prim_visibility.is_modified() || has_bvh2_layout)) {
+  if (pack.prim_visibility.size() && (dscene->prim_visibility.need_realloc() || has_bvh2_layout)) {
     dscene->prim_visibility.steal_data(pack.prim_visibility);
     dscene->prim_visibility.copy_to_device();
   }
@@ -1621,10 +1594,6 @@ void GeometryManager::device_update_preprocess(Device *device, Scene *scene, Pro
     }
   }
 
-  if ((update_flags & VISIBILITY_MODIFIED) != 0) {
-    dscene->prim_visibility.tag_modified();
-  }
-
   if (device_update_flags & ATTR_FLOAT_NEEDS_REALLOC) {
     dscene->attributes_map.tag_realloc();
     dscene->attributes_float.tag_realloc();
@@ -1951,8 +1920,7 @@ void GeometryManager::device_update(Device *device,
    * Also update the BVH if the transformations change, we cannot rely on tagging the Geometry
    * as modified in this case, as we may accumulate displacement if the vertices do not also
    * change. */
-  bool need_update_scene_bvh = (scene->bvh == nullptr ||
-                                (update_flags & (TRANSFORM_MODIFIED | VISIBILITY_MODIFIED)) != 0);
+  bool need_update_scene_bvh = (scene->bvh == nullptr || (update_flags & TRANSFORM_MODIFIED) != 0);
   {
     scoped_callback_timer timer([scene](double time) {
       if (scene->update_stats) {

intern/cycles/render/geometry.h

@@ -43,24 +43,6 @@ class Shader;
 class Volume;
 struct PackedBVH;
 
-/* Flags used to determine which geometry data need to be packed. */
-enum PackFlags : uint32_t {
-  PACK_NONE = 0u,
-
-  /* Pack the geometry information (e.g. triangle or curve keys indices). */
-  PACK_GEOMETRY = (1u << 0),
-
-  /* Pack the vertice, for Meshes and Volumes' bouding meshes. */
-  PACK_VERTICES = (1u << 1),
-
-  /* Pack the visibility flags for each triangle or curve. */
-  PACK_VISIBILITY = (1u << 2),
-
-  PACK_ALL = (PACK_GEOMETRY | PACK_VERTICES | PACK_VISIBILITY),
-};
-
-PackFlags operator|=(PackFlags &pack_flags, uint32_t value);
-
 /* Geometry
  *
  * Base class for geometric types like Mesh and Hair. */
@@ -144,10 +126,7 @@ class Geometry : public Node {
                    int n,
                    int total);
 
-  virtual void pack_primitives(PackedBVH *pack,
-                               int object,
-                               uint visibility,
-                               PackFlags pack_flags) = 0;
+  virtual void pack_primitives(PackedBVH *pack, int object, uint visibility, bool pack_all) = 0;
 
   /* Check whether the geometry should have own BVH built separately. Briefly,
    * own BVH is needed for geometry, if:
@@ -212,8 +191,6 @@ class GeometryManager {
 
     TRANSFORM_MODIFIED = (1 << 10),
 
-    VISIBILITY_MODIFIED = (1 << 11),
-
     /* tag everything in the manager for an update */
     UPDATE_ALL = ~0u,
 

intern/cycles/render/hair.cpp

@@ -494,47 +494,38 @@ void Hair::pack_curves(Scene *scene,
   }
 }
 
-void Hair::pack_primitives(PackedBVH *pack, int object, uint visibility, PackFlags pack_flags)
+void Hair::pack_primitives(PackedBVH *pack, int object, uint visibility, bool pack_all)
 {
   if (curve_first_key.empty())
     return;
 
-  /* Separate loop as other arrays are not initialized if their packing is not required. */
-  if ((pack_flags & PACK_VISIBILITY) != 0) {
-    unsigned int *prim_visibility = &pack->prim_visibility[optix_prim_offset];
-
-    size_t index = 0;
-    for (size_t j = 0; j < num_curves(); ++j) {
-      Curve curve = get_curve(j);
-      for (size_t k = 0; k < curve.num_segments(); ++k, ++index) {
-        prim_visibility[index] = visibility;
-      }
-    }
+  /* If the BVH does not have to be recreated, we can bail out. */
+  if (!pack_all) {
+    return;
   }
 
-  if ((pack_flags & PACK_GEOMETRY) != 0) {
-    unsigned int *prim_tri_index = &pack->prim_tri_index[optix_prim_offset];
-    int *prim_type = &pack->prim_type[optix_prim_offset];
-    int *prim_index = &pack->prim_index[optix_prim_offset];
-    int *prim_object = &pack->prim_object[optix_prim_offset];
-    // 'pack->prim_time' is unused by Embree and OptiX
+  unsigned int *prim_tri_index = &pack->prim_tri_index[optix_prim_offset];
+  int *prim_type = &pack->prim_type[optix_prim_offset];
+  unsigned int *prim_visibility = &pack->prim_visibility[optix_prim_offset];
+  int *prim_index = &pack->prim_index[optix_prim_offset];
+  int *prim_object = &pack->prim_object[optix_prim_offset];
+  // 'pack->prim_time' is unused by Embree and OptiX
 
-    uint type = has_motion_blur() ?
-                    ((curve_shape == CURVE_RIBBON) ? PRIMITIVE_MOTION_CURVE_RIBBON :
-                                                     PRIMITIVE_MOTION_CURVE_THICK) :
-                    ((curve_shape == CURVE_RIBBON) ? PRIMITIVE_CURVE_RIBBON :
-                                                     PRIMITIVE_CURVE_THICK);
+  uint type = has_motion_blur() ?
+                  ((curve_shape == CURVE_RIBBON) ? PRIMITIVE_MOTION_CURVE_RIBBON :
+                                                   PRIMITIVE_MOTION_CURVE_THICK) :
+                  ((curve_shape == CURVE_RIBBON) ? PRIMITIVE_CURVE_RIBBON : PRIMITIVE_CURVE_THICK);
 
-    size_t index = 0;
-    for (size_t j = 0; j < num_curves(); ++j) {
-      Curve curve = get_curve(j);
-      for (size_t k = 0; k < curve.num_segments(); ++k, ++index) {
-        prim_tri_index[index] = -1;
-        prim_type[index] = PRIMITIVE_PACK_SEGMENT(type, k);
-        // Each curve segment points back to its curve index
-        prim_index[index] = j + prim_offset;
-        prim_object[index] = object;
-      }
+  size_t index = 0;
+  for (size_t j = 0; j < num_curves(); ++j) {
+    Curve curve = get_curve(j);
+    for (size_t k = 0; k < curve.num_segments(); ++k, ++index) {
+      prim_tri_index[index] = -1;
+      prim_type[index] = PRIMITIVE_PACK_SEGMENT(type, k);
+      prim_visibility[index] = visibility;
+      // Each curve segment points back to its curve index
+      prim_index[index] = j + prim_offset;
+      prim_object[index] = object;
     }
   }
 }

intern/cycles/render/hair.h

@@ -146,10 +146,7 @@ class Hair : public Geometry {
   /* BVH */
   void pack_curves(Scene *scene, float4 *curve_key_co, float4 *curve_data, size_t curvekey_offset);
 
-  void pack_primitives(PackedBVH *pack,
-                       int object,
-                       uint visibility,
-                       PackFlags pack_flags) override;
+  void pack_primitives(PackedBVH *pack, int object, uint visibility, bool pack_all) override;
 };
 
 CCL_NAMESPACE_END

intern/cycles/render/light.cpp

@@ -864,7 +864,7 @@ void LightManager::device_update_points(Device *, DeviceScene *dscene, Scene *sc
       const float min_spread_angle = 1.0f * M_PI_F / 180.0f;
       const float spread_angle = 0.5f * (M_PI_F - max(light->spread, min_spread_angle));
       /* Normalization computed using:
-       * integrate cos(x) * (1 - tan(x) * tan(a)) * sin(x) from x = 0 to pi/2 - a. */
+       * integrate cos(x) (1 - tan(x) * tan(a)) * sin(x) from x = a to pi/2. */
       const float tan_spread = tanf(spread_angle);
       const float normalize_spread = 2.0f / (2.0f + (2.0f * spread_angle - M_PI_F) * tan_spread);
 

intern/cycles/render/mesh.cpp

@@ -805,7 +805,7 @@ void Mesh::pack_patches(uint *patch_data, uint vert_offset, uint face_offset, ui
   }
 }
 
-void Mesh::pack_primitives(ccl::PackedBVH *pack, int object, uint visibility, PackFlags pack_flags)
+void Mesh::pack_primitives(ccl::PackedBVH *pack, int object, uint visibility, bool pack_all)
 {
   if (triangles.empty())
     return;
@@ -819,38 +819,28 @@ void Mesh::pack_primitives(ccl::PackedBVH *pack, int object, uint visibility, Pa
 
   uint type = has_motion_blur() ? PRIMITIVE_MOTION_TRIANGLE : PRIMITIVE_TRIANGLE;
 
-  /* Separate loop as other arrays are not initialized if their packing is not required. */
-  if ((pack_flags & PackFlags::PACK_VISIBILITY) != 0) {
-    unsigned int *prim_visibility = &pack->prim_visibility[optix_prim_offset];
-    for (size_t k = 0; k < num_prims; ++k) {
-      prim_visibility[k] = visibility;
-    }
-  }
-
-  if ((pack_flags & PackFlags::PACK_GEOMETRY) != 0) {
+  if (pack_all) {
     /* Use optix_prim_offset for indexing as those arrays also contain data for Hair geometries. */
     unsigned int *prim_tri_index = &pack->prim_tri_index[optix_prim_offset];
     int *prim_type = &pack->prim_type[optix_prim_offset];
+    unsigned int *prim_visibility = &pack->prim_visibility[optix_prim_offset];
     int *prim_index = &pack->prim_index[optix_prim_offset];
     int *prim_object = &pack->prim_object[optix_prim_offset];
 
     for (size_t k = 0; k < num_prims; ++k) {
-      if ((pack_flags & PackFlags::PACK_GEOMETRY) != 0) {
-        prim_tri_index[k] = (prim_offset + k) * 3;
-        prim_type[k] = type;
-        prim_index[k] = prim_offset + k;
-        prim_object[k] = object;
-      }
+      prim_tri_index[k] = (prim_offset + k) * 3;
+      prim_type[k] = type;
+      prim_index[k] = prim_offset + k;
+      prim_object[k] = object;
+      prim_visibility[k] = visibility;
     }
   }
 
-  if ((pack_flags & PackFlags::PACK_VERTICES) != 0) {
-    for (size_t k = 0; k < num_prims; ++k) {
-      const Mesh::Triangle t = get_triangle(k);
-      prim_tri_verts[k * 3] = float3_to_float4(verts[t.v[0]]);
-      prim_tri_verts[k * 3 + 1] = float3_to_float4(verts[t.v[1]]);
-      prim_tri_verts[k * 3 + 2] = float3_to_float4(verts[t.v[2]]);
-    }
+  for (size_t k = 0; k < num_prims; ++k) {
+    const Mesh::Triangle t = get_triangle(k);
+    prim_tri_verts[k * 3] = float3_to_float4(verts[t.v[0]]);
+    prim_tri_verts[k * 3 + 1] = float3_to_float4(verts[t.v[1]]);
+    prim_tri_verts[k * 3 + 2] = float3_to_float4(verts[t.v[2]]);
   }
 }
 

intern/cycles/render/mesh.h

@@ -232,10 +232,7 @@ class Mesh : public Geometry {
                   size_t tri_offset);
   void pack_patches(uint *patch_data, uint vert_offset, uint face_offset, uint corner_offset);
 
-  void pack_primitives(PackedBVH *pack,
-                       int object,
-                       uint visibility,
-                       PackFlags pack_flags) override;
+  void pack_primitives(PackedBVH *pack, int object, uint visibility, bool pack_all) override;
 
   void tessellate(DiagSplit *split);
 

intern/cycles/render/nodes.h

@@ -1600,23 +1600,11 @@ class SetNormalNode : public ShaderNode {
   NODE_SOCKET_API(float3, direction)
 };
 
-class OSLNode final : public ShaderNode {
+class OSLNode : public ShaderNode {
  public:
   static OSLNode *create(ShaderGraph *graph, size_t num_inputs, const OSLNode *from = NULL);
   ~OSLNode();
 
-  static void operator delete(void *ptr)
-  {
-    /* Override delete operator to silence new-delete-type-mismatch ASAN warnings
-     * regarding size mismatch in the destructor. This is intentional as we allocate
-     * extra space at the end of the node. */
-    ::operator delete(ptr);
-  }
-  static void operator delete(void *, void *)
-  {
-    /* Deliberately empty placement delete operator, to avoid MSVC warning C4291. */
-  }
-
   ShaderNode *clone(ShaderGraph *graph) const;
 
   char *input_default_value();

intern/cycles/render/object.cpp

@@ -220,10 +220,6 @@ void Object::tag_update(Scene *scene)
       flag |= ObjectManager::TRANSFORM_MODIFIED;
     }
 
-    if (visibility_is_modified()) {
-      flag |= ObjectManager::VISIBILITY_MODIFIED;
-    }
-
     foreach (Node *node, geometry->get_used_shaders()) {
       Shader *shader = static_cast<Shader *>(node);
       if (shader->get_use_mis() && shader->has_surface_emission)
@@ -918,10 +914,6 @@ void ObjectManager::tag_update(Scene *scene, uint32_t flag)
       geometry_flag |= GeometryManager::TRANSFORM_MODIFIED;
     }
 
-    if ((flag & VISIBILITY_MODIFIED) != 0) {
-      geometry_flag |= GeometryManager::VISIBILITY_MODIFIED;
-    }
-
     scene->geometry_manager->tag_update(scene, geometry_flag);
   }
 

intern/cycles/render/object.h

@@ -134,7 +134,6 @@ class ObjectManager {
     OBJECT_MODIFIED = (1 << 5),
     HOLDOUT_MODIFIED = (1 << 6),
     TRANSFORM_MODIFIED = (1 << 7),
-    VISIBILITY_MODIFIED = (1 << 8),
 
     /* tag everything in the manager for an update */
     UPDATE_ALL = ~0u,

intern/cycles/render/scene.cpp

@@ -526,6 +526,9 @@ bool Scene::update(Progress &progress, bool &kernel_switch_needed)
     DeviceKernelStatus kernel_switch_status = device->get_active_kernel_switch_state();
     kernel_switch_needed = kernel_switch_status == DEVICE_KERNEL_FEATURE_KERNEL_AVAILABLE ||
                            kernel_switch_status == DEVICE_KERNEL_FEATURE_KERNEL_INVALID;
+    if (kernel_switch_status == DEVICE_KERNEL_WAITING_FOR_FEATURE_KERNEL) {
+      progress.set_kernel_status("Compiling render kernels");
+    }
     if (new_kernels_needed || kernel_switch_needed) {
       progress.set_kernel_status("Compiling render kernels");
       device->wait_for_availability(loaded_kernel_features);
@@ -563,6 +566,9 @@ bool Scene::load_kernels(Progress &progress, bool lock_scene)
       return false;
     }
 
+    progress.add_skip_time(timer, false);
+    VLOG(1) << "Total time spent loading kernels: " << time_dt() - timer.get_start();
+
     kernels_loaded = true;
     loaded_kernel_features = requested_features;
     return true;

intern/cycles/render/session.cpp

@@ -243,6 +243,11 @@ void Session::run_gpu()
       }
     }
 
+    /* Don't go in pause mode when image was rendered with preview kernels
+     * When feature kernels become available the session will be reset. */
+    else if (no_tiles && kernel_state == DEVICE_KERNEL_WAITING_FOR_FEATURE_KERNEL) {
+      time_sleep(0.1);
+    }
     else if (no_tiles && kernel_state == DEVICE_KERNEL_FEATURE_KERNEL_AVAILABLE) {
       reset_gpu(tile_manager.params, params.samples);
     }
@@ -757,6 +762,11 @@ void Session::run_cpu()
       }
     }
 
+    /* Don't go in pause mode when preview kernels are used
+     * When feature kernels become available the session will be reset. */
+    else if (no_tiles && kernel_state == DEVICE_KERNEL_WAITING_FOR_FEATURE_KERNEL) {
+      time_sleep(0.1);
+    }
     else if (no_tiles && kernel_state == DEVICE_KERNEL_FEATURE_KERNEL_AVAILABLE) {
       reset_cpu(tile_manager.params, params.samples);
     }

intern/cycles/render/shader.cpp

@@ -528,6 +528,8 @@ void ShaderManager::device_update_common(Device *device,
 
     if (shader->get_use_mis())
       flag |= SD_USE_MIS;
+    if (shader->has_surface_emission)
+      flag |= SD_HAS_EMISSION;
     if (shader->has_surface_transparent && shader->get_use_transparent_shadow())
       flag |= SD_HAS_TRANSPARENT_SHADOW;
     if (shader->has_volume) {

intern/cycles/util/util_simd.h

@@ -124,7 +124,7 @@ static struct StepTy {
 template<class type, int i0, int i1, int i2, int i3> type shuffle_neon(const type &a)
 {
   if (i0 == i1 && i0 == i2 && i0 == i3) {
-    return vdupq_laneq_s32(a, i0);
+    return type(vdupq_laneq_s32(int32x4_t(a), i0));
   }
   static const uint8_t tbl[16] = {(i0 * 4) + 0,
                                   (i0 * 4) + 1,
@@ -143,7 +143,7 @@ template<class type, int i0, int i1, int i2, int i3> type shuffle_neon(const typ
                                   (i3 * 4) + 2,
                                   (i3 * 4) + 3};
 
-  return vqtbl1q_s8(int8x16_t(a), *(int8x16_t *)tbl);
+  return type(vqtbl1q_s8(int8x16_t(a), *(uint8x16_t *)tbl));
 }
 
 template<class type, int i0, int i1, int i2, int i3>
@@ -167,7 +167,7 @@ type shuffle_neon(const type &a, const type &b)
                                     (i3 * 4) + 2,
                                     (i3 * 4) + 3};
 
-    return vqtbl1q_s8(int8x16_t(b), *(int8x16_t *)tbl);
+    return type(vqtbl1q_s8(int8x16_t(b), *(uint8x16_t *)tbl));
   }
   else {
 
@@ -188,7 +188,7 @@ type shuffle_neon(const type &a, const type &b)
                                     (i3 * 4) + 2 + 16,
                                     (i3 * 4) + 3 + 16};
 
-    return vqtbl2q_s8((int8x16x2_t){a, b}, *(int8x16_t *)tbl);
+    return type(vqtbl2q_s8((int8x16x2_t){int8x16_t(a), int8x16_t(b)}, *(uint8x16_t *)tbl));
   }
 }
 #endif /* __KERNEL_NEON */

intern/cycles/util/util_sseb.h

@@ -283,7 +283,7 @@ __forceinline uint32_t popcnt(const sseb &a)
 {
 #    if defined(__KERNEL_NEON__)
   const int32x4_t mask = {1, 1, 1, 1};
-  int32x4_t t = vandq_s32(a.m128, mask);
+  int32x4_t t = vandq_s32(vreinterpretq_s32_m128(a.m128), mask);
   return vaddvq_s32(t);
 #    else
   return _mm_popcnt_u32(_mm_movemask_ps(a));
@@ -299,7 +299,7 @@ __forceinline uint32_t popcnt(const sseb &a)
 __forceinline bool reduce_and(const sseb &a)
 {
 #  if defined(__KERNEL_NEON__)
-  return vaddvq_s32(a.m128) == -4;
+  return vaddvq_s32(vreinterpretq_s32_m128(a.m128)) == -4;
 #  else
   return _mm_movemask_ps(a) == 0xf;
 #  endif
@@ -307,7 +307,7 @@ __forceinline bool reduce_and(const sseb &a)
 __forceinline bool reduce_or(const sseb &a)
 {
 #  if defined(__KERNEL_NEON__)
-  return vaddvq_s32(a.m128) != 0x0;
+  return vaddvq_s32(vreinterpretq_s32_m128(a.m128)) != 0x0;
 #  else
   return _mm_movemask_ps(a) != 0x0;
 #  endif
@@ -315,7 +315,7 @@ __forceinline bool reduce_or(const sseb &a)
 __forceinline bool all(const sseb &b)
 {
 #  if defined(__KERNEL_NEON__)
-  return vaddvq_s32(b.m128) == -4;
+  return vaddvq_s32(vreinterpretq_s32_m128(b.m128)) == -4;
 #  else
   return _mm_movemask_ps(b) == 0xf;
 #  endif
@@ -323,7 +323,7 @@ __forceinline bool all(const sseb &b)
 __forceinline bool any(const sseb &b)
 {
 #  if defined(__KERNEL_NEON__)
-  return vaddvq_s32(b.m128) != 0x0;
+  return vaddvq_s32(vreinterpretq_s32_m128(b.m128)) != 0x0;
 #  else
   return _mm_movemask_ps(b) != 0x0;
 #  endif
@@ -331,7 +331,7 @@ __forceinline bool any(const sseb &b)
 __forceinline bool none(const sseb &b)
 {
 #  if defined(__KERNEL_NEON__)
-  return vaddvq_s32(b.m128) == 0x0;
+  return vaddvq_s32(vreinterpretq_s32_m128(b.m128)) == 0x0;
 #  else
   return _mm_movemask_ps(b) == 0x0;
 #  endif

intern/cycles/util/util_ssef.h

@@ -596,7 +596,7 @@ template<size_t i0, size_t i1, size_t i2, size_t i3>
 __forceinline const ssef shuffle(const ssef &b)
 {
 #  ifdef __KERNEL_NEON__
-  return shuffle_neon<ssef, i0, i1, i2, i3>(b.m128);
+  return shuffle_neon<float32x4_t, i0, i1, i2, i3>(b.m128);
 #  else
   return _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(b), _MM_SHUFFLE(i3, i2, i1, i0)));
 #  endif
@@ -625,7 +625,7 @@ __forceinline const ssef shuffle(const ssef &a, const ssef &b)
 template<size_t i0> __forceinline const ssef shuffle(const ssef &a, const ssef &b)
 {
 #  ifdef __KERNEL_NEON__
-  return shuffle<float32x4_t, i0, i0, i0, i0>(a, b);
+  return shuffle_neon<float32x4_t, i0, i0, i0, i0>(a, b);
 #  else
   return _mm_shuffle_ps(a, b, _MM_SHUFFLE(i0, i0, i0, i0));
 #  endif

intern/cycles/util/util_ssei.h

@@ -446,7 +446,8 @@ template<size_t i0, size_t i1, size_t i2, size_t i3>
 __forceinline const ssei shuffle(const ssei &a)
 {
 #  ifdef __KERNEL_NEON__
-  return shuffle_neon<ssei, i0, i1, i2, i3>(a);
+  int32x4_t result = shuffle_neon<int32x4_t, i0, i1, i2, i3>(vreinterpretq_s32_m128i(a));
+  return vreinterpretq_m128i_s32(result);
 #  else
   return _mm_shuffle_epi32(a, _MM_SHUFFLE(i3, i2, i1, i0));
 #  endif
@@ -456,7 +457,9 @@ template<size_t i0, size_t i1, size_t i2, size_t i3>
 __forceinline const ssei shuffle(const ssei &a, const ssei &b)
 {
 #  ifdef __KERNEL_NEON__
-  return shuffle_neon<ssei, i0, i1, i2, i3>(a, b);
+  int32x4_t result = shuffle_neon<int32x4_t, i0, i1, i2, i3>(vreinterpretq_s32_m128i(a),
+                                                             vreinterpretq_s32_m128i(b));
+  return vreinterpretq_m128i_s32(result);
 #  else
   return _mm_castps_si128(
       _mm_shuffle_ps(_mm_castsi128_ps(a), _mm_castsi128_ps(b), _MM_SHUFFLE(i3, i2, i1, i0)));
@@ -514,7 +517,7 @@ __forceinline const ssei vreduce_add(const ssei &v)
 __forceinline int reduce_min(const ssei &v)
 {
 #    ifdef __KERNEL_NEON__
-  return vminvq_s32(v);
+  return vminvq_s32(vreinterpretq_s32_m128i(v));
 #    else
   return extract<0>(vreduce_min(v));
 #    endif
@@ -522,7 +525,7 @@ __forceinline int reduce_min(const ssei &v)
 __forceinline int reduce_max(const ssei &v)
 {
 #    ifdef __KERNEL_NEON__
-  return vmaxvq_s32(v);
+  return vmaxvq_s32(vreinterpretq_s32_m128i(v));
 #    else
   return extract<0>(vreduce_max(v));
 #    endif
@@ -530,7 +533,7 @@ __forceinline int reduce_max(const ssei &v)
 __forceinline int reduce_add(const ssei &v)
 {
 #    ifdef __KERNEL_NEON__
-  return vaddvq_s32(v);
+  return vaddvq_s32(vreinterpretq_s32_m128i(v));
 #    else
   return extract<0>(vreduce_add(v));
 #    endif

intern/cycles/util/util_system.cpp

@@ -145,8 +145,7 @@ int system_cpu_num_active_group_processors()
   return numaAPI_GetNumCurrentNodesProcessors();
 }
 
-/* Equivalent of Windows __cpuid for x86 processors on other platforms. */
-#if (!defined(_WIN32) || defined(FREE_WINDOWS)) && (defined(__x86_64__) || defined(__i386__))
+#if !defined(_WIN32) || defined(FREE_WINDOWS)
 static void __cpuid(int data[4], int selector)
 {
 #  if defined(__x86_64__)
@@ -167,34 +166,7 @@ static void __cpuid(int data[4], int selector)
 
 string system_cpu_brand_string()
 {
-#if defined(__APPLE__)
-  /* Get from system on macOS. */
-  char modelname[512] = "";
-  size_t bufferlen = 512;
-  if (sysctlbyname("machdep.cpu.brand_string", &modelname, &bufferlen, NULL, 0) == 0) {
-    return modelname;
-  }
-#elif defined(WIN32) || defined(__x86_64__) || defined(__i386__)
-  /* Get from intrinsics on Windows and x86. */
-  char buf[49] = {0};
-  int result[4] = {0};
-
-  __cpuid(result, 0x80000000);
-
-  if (result[0] != 0 && result[0] >= (int)0x80000004) {
-    __cpuid((int *)(buf + 0), 0x80000002);
-    __cpuid((int *)(buf + 16), 0x80000003);
-    __cpuid((int *)(buf + 32), 0x80000004);
-
-    string brand = buf;
-
-    /* Make it a bit more presentable. */
-    brand = string_remove_trademark(brand);
-
-    return brand;
-  }
-#else
-  /* Get from /proc/cpuinfo on Unix systems. */
+#if !defined(WIN32) && !defined(__x86_64__) && !defined(__i386__)
   FILE *cpuinfo = fopen("/proc/cpuinfo", "r");
   if (cpuinfo != nullptr) {
     char cpuinfo_buf[513] = "";
@@ -214,6 +186,24 @@ string system_cpu_brand_string()
       }
     }
   }
+#else
+  char buf[49] = {0};
+  int result[4] = {0};
+
+  __cpuid(result, 0x80000000);
+
+  if (result[0] != 0 && result[0] >= (int)0x80000004) {
+    __cpuid((int *)(buf + 0), 0x80000002);
+    __cpuid((int *)(buf + 16), 0x80000003);
+    __cpuid((int *)(buf + 32), 0x80000004);
+
+    string brand = buf;
+
+    /* make it a bit more presentable */
+    brand = string_remove_trademark(brand);
+
+    return brand;
+  }
 #endif
   return "Unknown CPU";
 }
@@ -223,7 +213,7 @@ int system_cpu_bits()
   return (sizeof(void *) * 8);
 }
 
-#if defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86)
+#if defined(__x86_64__) || defined(_M_X64) || defined(i386) || defined(_M_IX86)
 
 struct CPUCapabilities {
   bool x64;

intern/cycles/util/util_texture.h

@@ -21,18 +21,12 @@
 
 CCL_NAMESPACE_BEGIN
 
-/* Texture limits on devices. */
-#define TEX_NUM_MAX (INT_MAX >> 4)
-
 /* Color to use when textures are not found. */
 #define TEX_IMAGE_MISSING_R 1
 #define TEX_IMAGE_MISSING_G 0
 #define TEX_IMAGE_MISSING_B 1
 #define TEX_IMAGE_MISSING_A 1
 
-/* Texture type. */
-#define kernel_tex_type(tex) (tex & IMAGE_DATA_TYPE_MASK)
-
 /* Interpolation types for textures
  * cuda also use texture space to store other objects */
 typedef enum InterpolationType {
@@ -45,9 +39,6 @@ typedef enum InterpolationType {
   INTERPOLATION_NUM_TYPES,
 } InterpolationType;
 
-/* Texture types
- * Since we store the type in the lower bits of a flat index,
- * the shift and bit mask constant below need to be kept in sync. */
 typedef enum ImageDataType {
   IMAGE_DATA_TYPE_FLOAT4 = 0,
   IMAGE_DATA_TYPE_BYTE4 = 1,
@@ -75,9 +66,6 @@ typedef enum ImageAlphaType {
   IMAGE_ALPHA_NUM_TYPES,
 } ImageAlphaType;
 
-#define IMAGE_DATA_TYPE_SHIFT 4
-#define IMAGE_DATA_TYPE_MASK 0xF
-
 /* Extension types for textures.
  *
  * Defines how the image is extrapolated past its original bounds. */